@soimy/dingtalk 3.6.6 → 3.6.8

package/dist/index.js

@@ -790,7 +790,7 @@ function cleanupOrphanedTempFiles(log) {
   let cleaned = 0;
   try {
     const files = fs.readdirSync(tempDir);
-    const now = Date.now();
+    const now2 = Date.now();
     const maxAge = 24 * 60 * 60 * 1e3;
     for (const file of files) {
       if (!dingtalkPattern.test(file)) {
@@ -799,7 +799,7 @@ function cleanupOrphanedTempFiles(log) {
       const filePath = path2.join(tempDir, file);
       try {
         const stats = fs.statSync(filePath);
-        if (now - stats.mtime.getTime() > maxAge) {
+        if (now2 - stats.mtime.getTime() > maxAge) {
           fs.unlinkSync(filePath);
           cleaned++;
           log?.debug?.(`[DingTalk] Cleaned up orphaned temp file: ${file}`);
@@ -846,9 +846,9 @@ function getCurrentTimestamp() {
 var accessTokenCache = /* @__PURE__ */ new Map();
 async function getAccessToken(config, log) {
   const cacheKey = config.clientId;
-  const now = Date.now();
+  const now2 = Date.now();
   const cached = accessTokenCache.get(cacheKey);
-  if (cached && cached.expiry > now + 6e4) {
+  if (cached && cached.expiry > now2 + 6e4) {
     return cached.accessToken;
   }
   const runtimeConfig = await resolveRuntimeConfig(config, log);
@@ -863,7 +863,7 @@ async function getAccessToken(config, log) {
       );
       accessTokenCache.set(cacheKey, {
         accessToken: response.data.accessToken,
-        expiry: now + response.data.expireIn * 1e3
+        expiry: now2 + response.data.expireIn * 1e3
       });
       return response.data.accessToken;
     },
@@ -1050,7 +1050,7 @@ function normalizeAllowFrom(list) {
 function isSenderAllowed(params) {
   const { allow, senderId } = params;
   if (!allow.hasEntries) {
-    return true;
+    return false;
   }
   if (allow.hasWildcard) {
     return true;
@@ -2681,7 +2681,7 @@ function normalizePendingState(parsed) {
     updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
     pendingCards: records2.filter(
       (entry) => Boolean(
-        entry && typeof entry.accountId === "string" && typeof entry.cardInstanceId === "string" && (entry.outTrackId === void 0 || typeof entry.outTrackId === "string") && typeof entry.conversationId === "string" && (entry.lastContent === void 0 || typeof entry.lastContent === "string") && (entry.lastBlockListJson === void 0 || typeof entry.lastBlockListJson === "string") && (entry.streamLifecycleOpened === void 0 || typeof entry.streamLifecycleOpened === "boolean")
+        entry && typeof entry.accountId === "string" && typeof entry.cardInstanceId === "string" && (entry.outTrackId === void 0 || typeof entry.outTrackId === "string") && (entry.processQueryKey === void 0 || typeof entry.processQueryKey === "string") && typeof entry.conversationId === "string" && (entry.lastContent === void 0 || typeof entry.lastContent === "string") && (entry.lastBlockListJson === void 0 || typeof entry.lastBlockListJson === "string") && (entry.streamLifecycleOpened === void 0 || typeof entry.streamLifecycleOpened === "boolean") && (entry.recoveryAction === void 0 || entry.recoveryAction === "finalize" || entry.recoveryAction === "recall")
       )
     )
   };
@@ -2738,6 +2738,7 @@ function upsertPendingCard(card, storePath, log) {
     accountId: card.accountId,
     cardInstanceId: card.cardInstanceId,
     outTrackId: card.outTrackId,
+    processQueryKey: card.processQueryKey,
     conversationId: card.conversationId,
     contextConversationId: card.contextConversationId,
     createdAt: card.createdAt,
@@ -2800,6 +2801,28 @@ function removePendingCardById(cardInstanceId, storePath, log) {
   state.updatedAt = Date.now();
   writePendingCardState(state, storePath, log);
 }
+function retainPendingCardForRecovery(card, recoveryAction, log) {
+  if (!card.accountId || !card.storePath) {
+    return;
+  }
+  const state = readPendingCardState(card.storePath, log);
+  const index = state.pendingCards.findIndex((item) => item.cardInstanceId === card.cardInstanceId);
+  if (index < 0) {
+    return;
+  }
+  const existing = state.pendingCards[index];
+  state.pendingCards[index] = {
+    ...existing,
+    state: AICardStatus.FAILED,
+    lastUpdated: Date.now(),
+    lastContent: card.lastStreamedContent ?? existing.lastContent,
+    lastBlockListJson: card.lastBlockListJson ?? existing.lastBlockListJson,
+    streamLifecycleOpened: card.streamLifecycleOpened,
+    recoveryAction
+  };
+  state.updatedAt = Date.now();
+  writePendingCardState(state, card.storePath, log);
+}
 function listPendingCardsByAccount(accountId, storePath, log) {
   const state = readPendingCardState(storePath, log);
   return state.pendingCards.filter((item) => item.accountId === accountId);
@@ -2827,6 +2850,37 @@ async function ensureFreshToken(card, log) {
     }
   }
 }
+async function sendTemplateMismatchNotification(card, text, log) {
+  const config = card.config;
+  if (!config) {
+    return;
+  }
+  try {
+    const token = await getAccessToken(config, log);
+    const { targetId, isExplicitUser } = stripTargetPrefix(card.conversationId);
+    const resolvedTarget = resolveOriginalPeerId(targetId);
+    const isGroup = !isExplicitUser && resolvedTarget.startsWith("cid");
+    const url = isGroup ? "https://api.dingtalk.com/v1.0/robot/groupMessages/send" : "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
+    const payload = {
+      robotCode: resolveRobotCode(config),
+      msgKey: "sampleMarkdown",
+      msgParam: JSON.stringify({ title: "OpenClaw \u63D0\u9192", text })
+    };
+    if (isGroup) {
+      payload.openConversationId = resolvedTarget;
+    } else {
+      payload.userIds = [resolvedTarget];
+    }
+    await http_client_default({
+      url,
+      method: "POST",
+      data: payload,
+      headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" }
+    });
+  } catch (sendErr) {
+    log?.warn?.(`[DingTalk][AICard] Failed to send error notification to user: ${sendErr.message}`);
+  }
+}
 async function sendProactiveCardText(config, conversationId, content, log) {
   try {
     const card = await createAICard(config, conversationId, log, { persistPending: false });
@@ -2867,7 +2921,7 @@ async function finalizePendingCardsByAccount(config, accountId, reason, storePat
     return 0;
   }
   const pendingCards = listPendingCardsByAccount(accountId, storePath, log).filter(
-    (item) => !isCardInTerminalState(item.state)
+    (item) => item.recoveryAction === "recall" && mode === "recover" || item.recoveryAction !== "recall" && (!isCardInTerminalState(item.state) || item.recoveryAction === "finalize")
   );
   if (pendingCards.length === 0) {
     return 0;
@@ -2892,6 +2946,7 @@ async function finalizePendingCardsByAccount(config, accountId, reason, storePat
       accountId: entry.accountId,
       storePath,
       outTrackId: entry.outTrackId,
+      processQueryKey: entry.processQueryKey,
       createdAt: entry.createdAt || Date.now(),
       lastUpdated: entry.lastUpdated || Date.now(),
       state: normalizeRecoveredState(entry.state),
@@ -2901,6 +2956,12 @@ async function finalizePendingCardsByAccount(config, accountId, reason, storePat
       streamLifecycleOpened: entry.streamLifecycleOpened
     };
     try {
+      if (entry.recoveryAction === "recall") {
+        if (await recallAICardMessage(card, log)) {
+          finalizedCount += 1;
+        }
+        continue;
+      }
       await finalizeStoppedAICard(card, {
         reason,
         previousContent: entry.lastContent,
@@ -3177,6 +3238,9 @@ async function commitAICardBlocks(card, options, log) {
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log?.error?.(`[DingTalk][AICard] Finalize via instances API failed: ${message}`);
+    card.state = AICardStatus.FAILED;
+    card.lastUpdated = Date.now();
+    retainPendingCardForRecovery(card, "finalize", log);
     throw err;
   }
   if (card.conversationId && options.content.trim() && card.accountId && card.processQueryKey) {
@@ -3196,6 +3260,35 @@ async function commitAICardBlocks(card, options, log) {
   removePendingCard(card, log);
   log?.info?.(`[DingTalk][AICard] Card finalized: outTrackId=${card.outTrackId || card.cardInstanceId} state=FINISHED`);
 }
+async function streamAICard(card, content, finished = false, log, options = {}) {
+  if (isCardInTerminalState(card.state)) {
+    log?.debug?.(
+      `[DingTalk][AICard] Skip stream update because card already terminal: outTrackId=${card.cardInstanceId} state=${card.state}`
+    );
+    return;
+  }
+  const template = DINGTALK_CARD_TEMPLATE;
+  try {
+    await putAICardStreamingField(card, template.contentKey, content, finished, log);
+    card.lastStreamedContent = content;
+    if (finished) {
+      card.state = AICardStatus.FINISHED;
+      removePendingCard(card, log);
+    } else if (card.state === AICardStatus.PROCESSING) {
+      card.state = AICardStatus.INPUTING;
+      upsertPendingCard(card, card.storePath, log);
+    }
+  } catch (err) {
+    card.state = AICardStatus.FAILED;
+    card.lastUpdated = Date.now();
+    retainPendingCardForRecovery(card, options.recoveryAction ?? "finalize", log);
+    if (err.response?.status === 500 && err.response?.data?.code === "unknownError") {
+      const errorMsg = "\u26A0\uFE0F **[DingTalk] AI Card \u4E32\u6D41\u66F4\u65B0\u5931\u8D25 (500 unknownError)**\n\n\u8FD9\u901A\u5E38\u8868\u793A\u5F53\u524D\u5185\u7F6E\u6A21\u677F\u5951\u7EA6\u4E0E\u9489\u9489\u4FA7\u6A21\u677F\u5B57\u6BB5\u4E0D\u4E00\u81F4\uFF0C\u5F53\u524D\u53CA\u540E\u7EED\u6D88\u606F\u5C06\u81EA\u52A8\u56DE\u9000\u4E3A Markdown \u53D1\u9001\u3002";
+      await sendTemplateMismatchNotification(card, errorMsg, log);
+    }
+    throw err;
+  }
+}
 function getCardRecallTarget(card) {
   const { targetId, isExplicitUser } = stripTargetPrefix(card.conversationId);
   const resolvedTarget = resolveOriginalPeerId(targetId);
@@ -3365,9 +3458,9 @@ function ensureSweepTimer() {
     return;
   }
   sweepTimer = setInterval(() => {
-    const now = Date.now();
+    const now2 = Date.now();
     for (const [key, record] of records) {
-      if (now - record.registeredAt > CARD_RUN_TTL_MS) {
+      if (now2 - record.registeredAt > CARD_RUN_TTL_MS) {
         records.delete(key);
       }
     }
@@ -4944,6 +5037,130 @@ async function handleInboundCommandDispatch(params) {
   return false;
 }
 
+// src/gateway/inbound-session-queue.ts
+var SESSION_QUEUE_TTL_MS = 5 * 60 * 1e3;
+var SESSION_QUEUE_CLEANUP_INTERVAL_MS = 60 * 1e3;
+var MAX_INBOUND_SESSION_QUEUE_DEPTH = 8;
+var MAX_INBOUND_SESSION_QUEUE_WAIT_MS = 15 * 60 * 1e3;
+var sessionQueues = /* @__PURE__ */ new Map();
+var sessionLastActivity = /* @__PURE__ */ new Map();
+var sessionQueueDepths = /* @__PURE__ */ new Map();
+var cleanupTimer = null;
+var InboundSessionQueueWaitTimeoutError = class extends Error {
+  constructor(queueKey) {
+    super(`Inbound session queue wait timed out for ${queueKey}`);
+    this.name = "InboundSessionQueueWaitTimeoutError";
+  }
+};
+function ensureCleanupTimer() {
+  if (cleanupTimer) {
+    return;
+  }
+  cleanupTimer = setInterval(() => {
+    const now2 = Date.now();
+    for (const [key, lastSeen] of sessionLastActivity) {
+      if (now2 - lastSeen > SESSION_QUEUE_TTL_MS && !sessionQueues.has(key)) {
+        sessionLastActivity.delete(key);
+      }
+    }
+  }, SESSION_QUEUE_CLEANUP_INTERVAL_MS);
+  if (typeof cleanupTimer?.unref === "function") {
+    cleanupTimer.unref();
+  }
+}
+function isInboundSessionQueueBusy(queueKey) {
+  return sessionQueues.has(queueKey);
+}
+function getInboundSessionQueueDepth(queueKey) {
+  return sessionQueueDepths.get(queueKey) ?? 0;
+}
+function chainInboundSessionTask(queueKey, task, options = {}) {
+  const hadPriorTask = sessionQueues.has(queueKey);
+  const previousTail = sessionQueues.get(queueKey) ?? Promise.resolve();
+  sessionLastActivity.set(queueKey, Date.now());
+  sessionQueueDepths.set(queueKey, getInboundSessionQueueDepth(queueKey) + 1);
+  ensureCleanupTimer();
+  let timedOut = false;
+  let timeout;
+  let resolveWaitingCaller;
+  let rejectWaitingCaller;
+  const maxQueueWaitMs = Math.max(0, options.maxQueueWaitMs ?? 0);
+  const caller = maxQueueWaitMs > 0 && hadPriorTask ? new Promise((resolve3, reject) => {
+    resolveWaitingCaller = resolve3;
+    rejectWaitingCaller = reject;
+    timeout = setTimeout(() => {
+      timedOut = true;
+      reject(new InboundSessionQueueWaitTimeoutError(queueKey));
+    }, maxQueueWaitMs);
+    if (typeof timeout.unref === "function") {
+      timeout.unref();
+    }
+  }) : void 0;
+  if (caller) {
+    void caller.catch(() => void 0);
+  }
+  const current = previousTail.then(() => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+    if (timedOut) {
+      throw new InboundSessionQueueWaitTimeoutError(queueKey);
+    }
+    return task();
+  });
+  const tail = current.then(
+    () => void 0,
+    () => {
+    }
+  );
+  sessionQueues.set(queueKey, tail);
+  const cleanup = () => {
+    const nextDepth = Math.max(0, getInboundSessionQueueDepth(queueKey) - 1);
+    if (nextDepth) {
+      sessionQueueDepths.set(queueKey, nextDepth);
+    } else {
+      sessionQueueDepths.delete(queueKey);
+    }
+    if (sessionQueues.get(queueKey) === tail) {
+      sessionQueues.delete(queueKey);
+      sessionLastActivity.delete(queueKey);
+    }
+  };
+  void current.then(cleanup, cleanup);
+  if (!caller) {
+    return current;
+  }
+  void current.then(
+    (value) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      resolveWaitingCaller?.(value);
+    },
+    (error) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      rejectWaitingCaller?.(error);
+    }
+  );
+  return caller;
+}
+var QUEUE_BUSY_ACK_PHRASES = [
+  "\u4E0A\u4E00\u6761\u8FD8\u6CA1\u7ED3\u675F\uFF0C\u8FD9\u6761\u6211\u5DF2\u7ECF\u8BB0\u4E0B\uFF0C\u7A0D\u540E\u6309\u987A\u5E8F\u7EE7\u7EED\u5904\u7406\u3002",
+  "\u5F53\u524D\u8FD8\u5728\u5FD9\uFF0C\u4F60\u7684\u65B0\u6D88\u606F\u5DF2\u7ECF\u6392\u961F\uFF0C\u4E0A\u4E00\u6761\u5B8C\u6210\u540E\u6211\u9A6C\u4E0A\u7EE7\u7EED\u3002",
+  "\u6211\u8FD9\u8FB9\u8FD8\u5728\u5904\u7406\u4E0A\u4E00\u6761\uFF0C\u8FD9\u6761\u5DF2\u52A0\u5165\u961F\u5217\uFF0C\u5B8C\u6210\u540E\u7EE7\u7EED\u5904\u7406\u3002"
+];
+function pickQueueBusyAckPhrase(seed) {
+  const list = QUEUE_BUSY_ACK_PHRASES;
+  const index = seed === void 0 ? Math.floor(Math.random() * list.length) : seed % list.length;
+  return list[index];
+}
+
+// src/send-service.ts
+import * as path6 from "node:path";
+
 // src/media-utils.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import * as os4 from "node:os";
@@ -6217,96 +6434,6 @@ function extractMessageContent(data) {
   };
 }
 
-// src/messaging/attachment-text-extractor.ts
-import fs4 from "node:fs/promises";
-import path6 from "node:path";
-var MAX_EXTRACTED_TEXT_CHARS = 6e3;
-var MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;
-async function isFileTooLarge(filePath) {
-  const stat = await fs4.stat(filePath);
-  return stat.size > MAX_ATTACHMENT_EXTRACT_BYTES;
-}
-function isTextLikeMimeType(mimeType) {
-  if (!mimeType) {
-    return false;
-  }
-  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "application/javascript";
-}
-function normalizeWhitespace(text) {
-  return text.replace(/\r\n/g, "\n").split("\0").join("").replace(/[ \t]{2,}/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
-}
-function limitExtractedText(text) {
-  const normalized = normalizeWhitespace(text);
-  if (!normalized) {
-    return null;
-  }
-  const truncated = normalized.length > MAX_EXTRACTED_TEXT_CHARS;
-  const limited = truncated ? `${normalized.slice(0, MAX_EXTRACTED_TEXT_CHARS)}
-
-[\u5185\u5BB9\u5DF2\u622A\u65AD]` : normalized;
-  return {
-    text: limited,
-    truncated,
-    sourceType: "text"
-  };
-}
-function stripHtml(html) {
-  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&amp;/gi, "&").replace(/&#39;/gi, "'").replace(/&quot;/gi, '"');
-}
-async function extractTextLikeFile(filePath) {
-  const raw = await fs4.readFile(filePath, "utf8");
-  return limitExtractedText(raw);
-}
-async function extractPdf(filePath) {
-  const pdfParseModule = await import("pdf-parse");
-  const fileBuffer = await fs4.readFile(filePath);
-  const parser = new pdfParseModule.PDFParse({ data: new Uint8Array(fileBuffer) });
-  try {
-    const result = await parser.getText();
-    const limited = limitExtractedText(result.text || "");
-    return limited ? { ...limited, sourceType: "pdf" } : null;
-  } finally {
-    await parser.destroy();
-  }
-}
-async function extractDocx(filePath) {
-  const mammothModule = await import("mammoth");
-  const result = await mammothModule.extractRawText({ path: filePath });
-  const limited = limitExtractedText(result.value || "");
-  return limited ? { ...limited, sourceType: "docx" } : null;
-}
-async function extractHtml(filePath) {
-  const raw = await fs4.readFile(filePath, "utf8");
-  const limited = limitExtractedText(stripHtml(raw));
-  return limited ? { ...limited, sourceType: "html" } : null;
-}
-async function extractAttachmentText(input) {
-  const mimeType = input.mimeType?.toLowerCase();
-  const fileName = (input.fileName || path6.basename(input.path)).toLowerCase();
-  if (mimeType?.startsWith("image/") || mimeType?.startsWith("audio/") || mimeType?.startsWith("video/")) {
-    return null;
-  }
-  if (await isFileTooLarge(input.path)) {
-    return null;
-  }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || fileName.endsWith(".docx")) {
-    return extractDocx(input.path);
-  }
-  if (mimeType === "application/pdf" || fileName.endsWith(".pdf")) {
-    return extractPdf(input.path);
-  }
-  if (mimeType === "text/html" || mimeType === "application/xhtml+xml" || fileName.endsWith(".html") || fileName.endsWith(".htm")) {
-    return extractHtml(input.path);
-  }
-  if (isTextLikeMimeType(mimeType) || fileName.endsWith(".txt") || fileName.endsWith(".md") || fileName.endsWith(".markdown") || fileName.endsWith(".csv") || fileName.endsWith(".json") || fileName.endsWith(".xml") || fileName.endsWith(".log")) {
-    return extractTextLikeFile(input.path);
-  }
-  return null;
-}
-
-// src/send-service.ts
-import * as path7 from "node:path";
-
 // src/proactive-risk-registry.ts
 var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var store = /* @__PURE__ */ new Map();
@@ -6694,9 +6821,9 @@ async function sendProactiveMedia(config, target, mediaPath, mediaType, options
       const durationMs = uploadedDurationMs ?? await getVoiceDurationMs(mediaPath, mediaType, log, { preReadBuffer: buffer });
       msgParam = JSON.stringify({ mediaId, duration: String(durationMs) });
     } else {
-      const filename = path7.basename(mediaPath);
+      const filename = path6.basename(mediaPath);
       const defaultExt = mediaType === "video" ? "mp4" : "file";
-      const ext = path7.extname(mediaPath).slice(1) || defaultExt;
+      const ext = path6.extname(mediaPath).slice(1) || defaultExt;
       msgKey = "sampleFile";
       msgParam = JSON.stringify({ mediaId, fileName: filename, fileType: ext });
     }
@@ -6799,7 +6926,7 @@ async function sendMedia(config, target, mediaInput, options = {}) {
   let preparedMedia;
   try {
     preparedMedia = await prepareMediaInput(mediaInput, log, config.mediaUrlAllowlist);
-    const mediaPath = preparedMedia.cleanup ? preparedMedia.path : path7.resolve(process.cwd(), preparedMedia.path);
+    const mediaPath = preparedMedia.cleanup ? preparedMedia.path : path6.resolve(process.cwd(), preparedMedia.path);
     const mediaType = resolveOutboundMediaType({
       mediaType: options.mediaType,
       mediaPath,
@@ -6855,7 +6982,7 @@ async function sendBySession(config, sessionWebhook, text, options = {}) {
         mediaLocalRoots: options.mediaLocalRoots
       });
       if (uploadResult) {
-        const imageMarkdown = `![${path7.basename(options.mediaPath)}](${uploadResult.mediaId})`;
+        const imageMarkdown = `![${path6.basename(options.mediaPath)}](${uploadResult.mediaId})`;
         text = text ? `${text}
 
 ${imageMarkdown}` : imageMarkdown;
@@ -7038,70 +7165,348 @@ async function sendMessage(config, conversationId, text, options = {}) {
   }
 }
 
-// src/messaging/btw-deliver.ts
-var MAX_QUESTION_LENGTH = 80;
-var LEADING_MENTIONS_RE = /^(?:@\S+\s+)*/u;
-function stripLeadingMentions(text) {
-  return text.replace(LEADING_MENTIONS_RE, "");
-}
-function buildBtwBlockquote(senderName, rawQuestion) {
-  const stripped = stripLeadingMentions(rawQuestion);
-  const codePoints = Array.from(stripped);
-  const truncated = codePoints.length > MAX_QUESTION_LENGTH ? `${codePoints.slice(0, MAX_QUESTION_LENGTH).join("")}\u2026` : stripped;
-  const senderPrefix = senderName ? `${senderName}: ` : "";
-  return `> ${senderPrefix}${truncated}
-
-`;
+// src/gateway/inbound-session-queue-dispatcher.ts
+var QUEUE_FULL_ACK = "\u5F53\u524D\u6D88\u606F\u8F83\u591A\uFF0C\u5DF2\u8FBE\u5230\u672C\u4F1A\u8BDD\u6392\u961F\u4E0A\u9650\uFF1B\u8BF7\u7B49\u5F85\u4E0A\u4E00\u8F6E\u5B8C\u6210\u540E\u518D\u53D1\u9001\u3002";
+var QUEUE_WAIT_TIMEOUT_ACK = "\u4E0A\u4E00\u8F6E\u5904\u7406\u65F6\u95F4\u8F83\u957F\uFF0C\u8FD9\u6761\u6D88\u606F\u672A\u6267\u884C\uFF1B\u8BF7\u7A0D\u540E\u91CD\u65B0\u53D1\u9001\u3002";
+var QUEUE_HANDLER_FAILURE_ACK = "\u672C\u6B21\u5904\u7406\u5F02\u5E38\uFF0C\u672A\u80FD\u5B8C\u6210\uFF1B\u8BF7\u7A0D\u540E\u91CD\u65B0\u53D1\u9001\u3002";
+var MIN_QUEUE_ACK_CARD_VISIBLE_MS = 750;
+var queuedAckVisibleAt = /* @__PURE__ */ new WeakMap();
+function shouldPrepareQueueAckCard(input) {
+  return input.dingtalkConfig.messageType === "card";
+}
+async function keepQueueAckCardVisible(card) {
+  const visibleAt = queuedAckVisibleAt.get(card);
+  if (!visibleAt) {
+    return;
+  }
+  const remainingMs = MIN_QUEUE_ACK_CARD_VISIBLE_MS - (Date.now() - visibleAt);
+  if (remainingMs > 0) {
+    await new Promise((resolve3) => setTimeout(resolve3, remainingMs));
+  }
 }
-async function deliverBtwReply(args) {
-  const blockquote = buildBtwBlockquote(args.senderName, args.rawQuestion);
-  const fullText = `${blockquote}${args.replyText}`;
+async function settleUnusedQueueAckCard(input, card) {
+  if (isCardInTerminalState(card.state)) {
+    return;
+  }
   try {
-    const result = await sendMessage(args.config, args.to, fullText, {
-      log: args.log,
-      accountId: args.accountId,
-      storePath: args.storePath,
-      conversationId: args.conversationId,
-      sessionWebhook: args.sessionWebhook,
-      forceMarkdown: true
-    });
-    if (!result.ok) {
-      args.log?.warn?.(
-        `[DingTalk] BTW reply delivery returned not-ok: ${result.error ?? "unknown"}`
-      );
+    if (await recallAICardMessage(card, input.log)) {
+      return;
     }
-    return { ok: result.ok, error: result.error };
   } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    args.log?.warn?.(`[DingTalk] BTW reply delivery threw: ${error}`);
-    return { ok: false, error };
+    input.log?.warn?.(
+      `[DingTalk] Failed to recall unused queue acknowledgement card: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
+  await sendQueueTerminalAck(input, "\u5DF2\u7ED3\u675F\u6392\u961F\u786E\u8BA4\uFF0C\u8BF7\u4EE5\u672C\u6B21\u5B9E\u9645\u56DE\u590D\u4E3A\u51C6\u3002", card);
 }
-
-// src/messaging/quoted-ref.ts
-function firstTrimmedString3(...candidates) {
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.trim()) {
-      return candidate.trim();
-    }
+async function settleFailedQueueAckCard(input, card) {
+  if (isCardInTerminalState(card.state)) {
+    return;
   }
-  return void 0;
+  await sendQueueTerminalAck(input, QUEUE_HANDLER_FAILURE_ACK, card);
 }
-function firstFiniteNumber(...candidates) {
-  for (const candidate of candidates) {
-    if (typeof candidate === "number" && Number.isFinite(candidate)) {
-      return candidate;
+async function dispatchInboundViaSessionQueue(input, handler) {
+  const queueKey = input.sessionKey;
+  if (!queueKey) {
+    return handler(void 0);
+  }
+  const wasBusy = isInboundSessionQueueBusy(queueKey);
+  if (getInboundSessionQueueDepth(queueKey) >= MAX_INBOUND_SESSION_QUEUE_DEPTH) {
+    await sendQueueTerminalAck(input, QUEUE_FULL_ACK);
+    return void 0;
+  }
+  let queuedAckState = "queued";
+  const preCreatedCardPromise = wasBusy && shouldPrepareQueueAckCard(input) ? tryPrepareQueueAckCard(
+    input,
+    () => queuedAckState === "timed-out" ? { content: QUEUE_WAIT_TIMEOUT_ACK, finished: true } : { content: pickQueueBusyAckPhrase(), finished: false }
+  ) : void 0;
+  try {
+    return await chainInboundSessionTask(
+      queueKey,
+      async () => {
+        const preCreatedCard = preCreatedCardPromise ? await preCreatedCardPromise : void 0;
+        if (!preCreatedCard) {
+          return handler(void 0);
+        }
+        await keepQueueAckCardVisible(preCreatedCard);
+        let handlerFailed = false;
+        try {
+          return await handler(preCreatedCard);
+        } catch (err) {
+          handlerFailed = true;
+          await settleFailedQueueAckCard(input, preCreatedCard);
+          throw err;
+        } finally {
+          if (!handlerFailed && !isCardInTerminalState(preCreatedCard.state)) {
+            await settleUnusedQueueAckCard(input, preCreatedCard);
+          }
+        }
+      },
+      {
+        maxQueueWaitMs: wasBusy ? MAX_INBOUND_SESSION_QUEUE_WAIT_MS : void 0
+      }
+    );
+  } catch (err) {
+    if (err instanceof InboundSessionQueueWaitTimeoutError) {
+      queuedAckState = "timed-out";
+      await sendQueueTerminalAck(
+        input,
+        QUEUE_WAIT_TIMEOUT_ACK,
+        preCreatedCardPromise ? await preCreatedCardPromise : void 0
+      );
+      return void 0;
     }
+    throw err;
   }
-  return void 0;
 }
-function buildInboundQuotedRef(data, content) {
-  const repliedMsg = data.text?.repliedMsg;
-  const repliedMsgId = firstTrimmedString3(repliedMsg?.msgId, data.originalMsgId, content.quoted?.msgId);
-  const fallbackCreatedAt = firstFiniteNumber(
-    repliedMsg?.createdAt,
-    content.quoted?.cardCreatedAt,
-    content.quoted?.fileCreatedAt
+async function tryPrepareQueueAckCard(input, ack) {
+  const { dingtalkConfig, data, log, to, storePath, quoteContent } = input;
+  if (!data) {
+    return void 0;
+  }
+  if (!to) {
+    return void 0;
+  }
+  let card = null;
+  let ackFinished = false;
+  try {
+    card = await createAICard(dingtalkConfig, to, log, {
+      accountId: input.accountId,
+      storePath,
+      quoteContent
+    });
+    if (!card) {
+      return void 0;
+    }
+    const { content, finished } = ack();
+    ackFinished = finished;
+    await streamAICard(card, content, finished, log, {
+      recoveryAction: finished ? "finalize" : "recall"
+    });
+    if (!finished) {
+      queuedAckVisibleAt.set(card, Date.now());
+    }
+    if (finished) {
+      return card;
+    }
+    void attachNativeAckReaction(
+      dingtalkConfig,
+      { msgId: data.msgId, conversationId: data.conversationId },
+      log
+    ).catch((err) => {
+      log?.debug?.(
+        `[DingTalk] Queue-busy ack reaction attach failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+    log?.info?.(
+      `[DingTalk] Inbound message queued behind active run for session=${input.sessionKey}; pre-created ACK card outTrackId=${card.cardInstanceId}.`
+    );
+    return card;
+  } catch (err) {
+    if (card && !ackFinished) {
+      try {
+        await recallAICardMessage(card, log);
+      } catch (recallErr) {
+        log?.warn?.(
+          `[DingTalk] Failed to recall queue ACK card after prepare failure: ${recallErr instanceof Error ? recallErr.message : String(recallErr)}`
+        );
+      }
+    }
+    log?.warn?.(
+      `[DingTalk] Queue-busy ACK card prepare failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return void 0;
+  }
+}
+async function sendQueueTerminalAck(input, content, preCreatedCard) {
+  const { dingtalkConfig, data, log, to, storePath } = input;
+  try {
+    if (preCreatedCard) {
+      try {
+        await streamAICard(preCreatedCard, content, true, log);
+        return;
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk] Queue acknowledgement card finalization failed; falling back to text: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      const card = await tryPrepareQueueAckCard(input, () => ({ content, finished: true }));
+      if (card) {
+        return;
+      }
+    }
+    if (!to) {
+      return;
+    }
+    const result = await sendMessage(dingtalkConfig, to, content, {
+      sessionWebhook: data.sessionWebhook,
+      log,
+      accountId: input.accountId,
+      storePath,
+      conversationId: data.conversationId
+    });
+    if (!result.ok) {
+      log?.warn?.(`[DingTalk] Queue terminal acknowledgement failed: ${result.error || "unknown"}`);
+    }
+  } catch (err) {
+    log?.warn?.(
+      `[DingTalk] Queue terminal acknowledgement delivery failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/messaging/attachment-text-extractor.ts
+import fs4 from "node:fs/promises";
+import path7 from "node:path";
+var MAX_EXTRACTED_TEXT_CHARS = 6e3;
+var MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;
+async function isFileTooLarge(filePath) {
+  const stat = await fs4.stat(filePath);
+  return stat.size > MAX_ATTACHMENT_EXTRACT_BYTES;
+}
+function isTextLikeMimeType(mimeType) {
+  if (!mimeType) {
+    return false;
+  }
+  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "application/javascript";
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\r\n/g, "\n").split("\0").join("").replace(/[ \t]{2,}/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function limitExtractedText(text) {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return null;
+  }
+  const truncated = normalized.length > MAX_EXTRACTED_TEXT_CHARS;
+  const limited = truncated ? `${normalized.slice(0, MAX_EXTRACTED_TEXT_CHARS)}
+
+[\u5185\u5BB9\u5DF2\u622A\u65AD]` : normalized;
+  return {
+    text: limited,
+    truncated,
+    sourceType: "text"
+  };
+}
+function stripHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&amp;/gi, "&").replace(/&#39;/gi, "'").replace(/&quot;/gi, '"');
+}
+async function extractTextLikeFile(filePath) {
+  const raw = await fs4.readFile(filePath, "utf8");
+  return limitExtractedText(raw);
+}
+async function extractPdf(filePath) {
+  const pdfParseModule = await import("pdf-parse");
+  const fileBuffer = await fs4.readFile(filePath);
+  const parser = new pdfParseModule.PDFParse({ data: new Uint8Array(fileBuffer) });
+  try {
+    const result = await parser.getText();
+    const limited = limitExtractedText(result.text || "");
+    return limited ? { ...limited, sourceType: "pdf" } : null;
+  } finally {
+    await parser.destroy();
+  }
+}
+async function extractDocx(filePath) {
+  const mammothModule = await import("mammoth");
+  const result = await mammothModule.extractRawText({ path: filePath });
+  const limited = limitExtractedText(result.value || "");
+  return limited ? { ...limited, sourceType: "docx" } : null;
+}
+async function extractHtml(filePath) {
+  const raw = await fs4.readFile(filePath, "utf8");
+  const limited = limitExtractedText(stripHtml(raw));
+  return limited ? { ...limited, sourceType: "html" } : null;
+}
+async function extractAttachmentText(input) {
+  const mimeType = input.mimeType?.toLowerCase();
+  const fileName = (input.fileName || path7.basename(input.path)).toLowerCase();
+  if (mimeType?.startsWith("image/") || mimeType?.startsWith("audio/") || mimeType?.startsWith("video/")) {
+    return null;
+  }
+  if (await isFileTooLarge(input.path)) {
+    return null;
+  }
+  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || fileName.endsWith(".docx")) {
+    return extractDocx(input.path);
+  }
+  if (mimeType === "application/pdf" || fileName.endsWith(".pdf")) {
+    return extractPdf(input.path);
+  }
+  if (mimeType === "text/html" || mimeType === "application/xhtml+xml" || fileName.endsWith(".html") || fileName.endsWith(".htm")) {
+    return extractHtml(input.path);
+  }
+  if (isTextLikeMimeType(mimeType) || fileName.endsWith(".txt") || fileName.endsWith(".md") || fileName.endsWith(".markdown") || fileName.endsWith(".csv") || fileName.endsWith(".json") || fileName.endsWith(".xml") || fileName.endsWith(".log")) {
+    return extractTextLikeFile(input.path);
+  }
+  return null;
+}
+
+// src/messaging/btw-deliver.ts
+var MAX_QUESTION_LENGTH = 80;
+var LEADING_MENTIONS_RE = /^(?:@\S+\s+)*/u;
+function stripLeadingMentions(text) {
+  return text.replace(LEADING_MENTIONS_RE, "");
+}
+function buildBtwBlockquote(senderName, rawQuestion) {
+  const stripped = stripLeadingMentions(rawQuestion);
+  const codePoints = Array.from(stripped);
+  const truncated = codePoints.length > MAX_QUESTION_LENGTH ? `${codePoints.slice(0, MAX_QUESTION_LENGTH).join("")}\u2026` : stripped;
+  const senderPrefix = senderName ? `${senderName}: ` : "";
+  return `> ${senderPrefix}${truncated}
+
+`;
+}
+async function deliverBtwReply(args) {
+  const blockquote = buildBtwBlockquote(args.senderName, args.rawQuestion);
+  const fullText = `${blockquote}${args.replyText}`;
+  try {
+    const result = await sendMessage(args.config, args.to, fullText, {
+      log: args.log,
+      accountId: args.accountId,
+      storePath: args.storePath,
+      conversationId: args.conversationId,
+      sessionWebhook: args.sessionWebhook,
+      forceMarkdown: true
+    });
+    if (!result.ok) {
+      args.log?.warn?.(
+        `[DingTalk] BTW reply delivery returned not-ok: ${result.error ?? "unknown"}`
+      );
+    }
+    return { ok: result.ok, error: result.error };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    args.log?.warn?.(`[DingTalk] BTW reply delivery threw: ${error}`);
+    return { ok: false, error };
+  }
+}
+
+// src/messaging/quoted-ref.ts
+function firstTrimmedString3(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return void 0;
+}
+function firstFiniteNumber(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function buildInboundQuotedRef(data, content) {
+  const repliedMsg = data.text?.repliedMsg;
+  const repliedMsgId = firstTrimmedString3(repliedMsg?.msgId, data.originalMsgId, content.quoted?.msgId);
+  const fallbackCreatedAt = firstFiniteNumber(
+    repliedMsg?.createdAt,
+    content.quoted?.cardCreatedAt,
+    content.quoted?.fileCreatedAt
   );
   const isOutboundQuoted = firstTrimmedString3(data.originalProcessQueryKey) !== void 0 || repliedMsg?.senderId === data.chatbotUserId || content.quoted?.isQuotedCard === true;
   if (isOutboundQuoted) {
@@ -7622,6 +8027,47 @@ async function resolveQuotedFile(config, params, log) {
   }
 }
 
+// src/gateway/reply-session-conflict.ts
+var REPLY_SESSION_CONFLICT_PATTERN = /reply session initialization conflicted/i;
+function readErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    const msg = error.message;
+    return typeof msg === "string" ? msg : "";
+  }
+  return "";
+}
+function isReplySessionConflictError(error) {
+  return REPLY_SESSION_CONFLICT_PATTERN.test(readErrorMessage(error));
+}
+var sleep = (ms) => new Promise((resolve3) => {
+  setTimeout(resolve3, ms);
+});
+async function withReplySessionConflictRetry(fn, options = {}) {
+  const maxRetries = options.maxRetries ?? 3;
+  const baseDelayMs = options.baseDelayMs ?? 1500;
+  const sessionLabel = options.sessionKey ?? "?";
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (!isReplySessionConflictError(error) || attempt >= maxRetries) {
+        throw error;
+      }
+      const delay = baseDelayMs * (attempt + 1);
+      options.log?.warn?.(
+        `[DingTalk] Reply session initialization conflicted for session=${sessionLabel}; active run still draining. Retry ${attempt + 1}/${maxRetries} after ${delay}ms.`
+      );
+      await sleep(delay);
+    }
+  }
+}
+
 // src/card/reasoning-answer-split.ts
 var THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
 function isWrappedReasoningLine(line) {
@@ -9789,10 +10235,62 @@ async function dispatchSubAgents(params) {
     dingtalkConfig,
     sessionWebhook,
     extractedContent,
+    sessionPeer,
+    onRoutesResolved,
     handleMessage,
     downloadMedia: download,
-    log
+    log,
+    inboundQueueEligible
   } = params;
+  let helperMissingWarningSent = false;
+  const sendHelperMissingWarning = async () => {
+    if (helperMissingWarningSent) {
+      return;
+    }
+    helperMissingWarningSent = true;
+    try {
+      const isGroup = data.conversationType !== "1";
+      const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
+      await sendBySession(
+        dingtalkConfig,
+        sessionWebhook,
+        "\u26A0\uFE0F \u5F53\u524D\u5BBF\u4E3B\u7248\u672C\u4E0D\u652F\u6301 DingTalk \u5B50\u52A9\u624B\u8DEF\u7531\u6240\u9700\u7684 session helper\uFF0C\u8BF7\u5347\u7EA7 OpenClaw \u540E\u91CD\u8BD5\u3002",
+        sendOptions
+      );
+    } catch (notifyError) {
+      log?.debug?.(
+        `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`
+      );
+    }
+  };
+  let resolvedTargets;
+  try {
+    const rt = getDingTalkRuntime();
+    resolvedTargets = matchedAgents.map((agent) => ({
+      agent,
+      route: {
+        agentId: agent.agentId,
+        sessionKey: buildAgentSessionKey({
+          rt,
+          cfg,
+          accountId,
+          agentId: agent.agentId,
+          peerKind: sessionPeer.kind,
+          peerId: sessionPeer.peerId
+        }),
+        mainSessionKey: ""
+      }
+    }));
+  } catch (error) {
+    const message = getErrorMessage(error);
+    log?.error?.(`[DingTalk] Failed to resolve sub-agent routes: ${message}`);
+    if (error instanceof HostRoutingHelperUnavailableError) {
+      await sendHelperMissingWarning();
+      return;
+    }
+    throw error;
+  }
+  onRoutesResolved?.(resolvedTargets);
   let preDownloadedMedia;
   const robotCode = resolveRobotCode(dingtalkConfig);
   if (robotCode) {
@@ -9815,8 +10313,8 @@ async function dispatchSubAgents(params) {
       };
     }
   }
-  let helperMissingWarningSent = false;
-  for (const agentMatch of matchedAgents) {
+  for (const target of resolvedTargets) {
+    const agentMatch = target.agent;
     try {
       await handleMessage({
         cfg,
@@ -9825,6 +10323,7 @@ async function dispatchSubAgents(params) {
         sessionWebhook,
         log,
         dingtalkConfig,
+        routeOverride: target.route,
         subAgentOptions: {
           agentId: agentMatch.agentId,
           responsePrefix: commandText ? "" : `> \u{1F916} **${sanitizeAgentName(agentMatch.matchedName)}**:
@@ -9833,27 +10332,20 @@ async function dispatchSubAgents(params) {
           matchedName: agentMatch.matchedName,
           commandText
         },
-        preDownloadedMedia
+        preDownloadedMedia,
+        // Propagate queue eligibility so each recursive sub-agent handler
+        // enters the handler-owned queue on its own `target.route.sessionKey`
+        // instead of bypassing it (which previously left @子Agent messages
+        // exposed to reply-session conflicts when the sub-agent session was
+        // already busy). Synthetic callers without this flag keep the legacy
+        // direct-dispatch behavior.
+        inboundQueueEligible
       });
     } catch (error) {
       const message = getErrorMessage(error);
       log?.error?.(`[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${message}`);
-      if (error instanceof HostRoutingHelperUnavailableError && !helperMissingWarningSent) {
-        helperMissingWarningSent = true;
-        try {
-          const isGroup = data.conversationType !== "1";
-          const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
-          await sendBySession(
-            dingtalkConfig,
-            sessionWebhook,
-            "\u26A0\uFE0F \u5F53\u524D\u5BBF\u4E3B\u7248\u672C\u4E0D\u652F\u6301 DingTalk \u5B50\u52A9\u624B\u8DEF\u7531\u6240\u9700\u7684 session helper\uFF0C\u8BF7\u5347\u7EA7 OpenClaw \u540E\u91CD\u8BD5\u3002",
-            sendOptions
-          );
-        } catch (notifyError) {
-          log?.debug?.(
-            `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`
-          );
-        }
+      if (error instanceof HostRoutingHelperUnavailableError) {
+        await sendHelperMissingWarning();
       }
     }
   }
@@ -10555,6 +11047,8 @@ async function handleDingTalkMessageInner(params) {
     sessionWebhook,
     log,
     dingtalkConfig,
+    inboundOrigin = "stream",
+    routeOverride,
     subAgentOptions,
     preDownloadedMedia
   } = params;
@@ -10749,32 +11243,42 @@ async function handleDingTalkMessageInner(params) {
     config: dingtalkConfig
   });
   const messageTarget = subAgentOptions ? null : resolveMessageTarget({ extractedContent, cfg, isGroup });
-  let route;
-  if (subAgentOptions) {
-    route = {
-      agentId: subAgentOptions.agentId,
-      sessionKey: buildAgentSessionKey({
-        rt,
-        cfg,
-        accountId,
-        agentId: subAgentOptions.agentId,
-        peerKind: sessionPeer.kind,
-        peerId: sessionPeer.peerId
-      }),
-      mainSessionKey: ""
-    };
-  } else {
-    route = rt.channel.routing.resolveAgentRoute({
-      cfg,
-      channel: "dingtalk",
-      accountId,
-      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId }
+  const invalidateQuestionRoutes = (routes) => {
+    if (inboundOrigin === "ask-user") {
+      return;
+    }
+    const scopeKeys = new Set(
+      routes.map((resolvedRoute) => `${accountId}:${resolvedRoute.sessionKey}:${senderId}`)
+    );
+    const invalidatedRecords = [];
+    for (const questionScopeKey of scopeKeys) {
+      try {
+        invalidatedRecords.push(
+          ...invalidateAskUserQuestionsForScope({
+            storePath: accountStorePath,
+            accountId,
+            questionScopeKey,
+            reason: "superseded_by_message",
+            log
+          })
+        );
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Failed to invalidate pending cards before inbound dispatch scope=${questionScopeKey}: ${String(err)}`
+        );
+      }
+    }
+    if (invalidatedRecords.length === 0) {
+      return;
+    }
+    void syncInvalidatedAskUserQuestionCards({
+      records: invalidatedRecords,
+      config: dingtalkConfig,
+      log
+    }).catch((err) => {
+      log?.warn?.(`[DingTalk][AskUser] Card invalidation sync failed: ${String(err)}`);
     });
-  }
-  const questionContext = getDingTalkQuestionContext();
-  if (questionContext) {
-    questionContext.questionScopeKey = `${accountId}:${route.sessionKey}:${senderId}`;
-  }
+  };
   if (messageTarget && messageTarget.kind !== "default") {
     if (messageTarget.kind === "subagent-command") {
       await dispatchSubAgents({
@@ -10786,9 +11290,12 @@ async function handleDingTalkMessageInner(params) {
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) => invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
-        log
+        log,
+        inboundQueueEligible: params.inboundQueueEligible
       });
       return;
     }
@@ -10814,13 +11321,54 @@ async function handleDingTalkMessageInner(params) {
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) => invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
-        log
+        log,
+        inboundQueueEligible: params.inboundQueueEligible
       });
       return;
     }
   }
+  let route;
+  if (routeOverride) {
+    route = routeOverride;
+  } else if (subAgentOptions) {
+    route = {
+      agentId: subAgentOptions.agentId,
+      sessionKey: buildAgentSessionKey({
+        rt,
+        cfg,
+        accountId,
+        agentId: subAgentOptions.agentId,
+        peerKind: sessionPeer.kind,
+        peerId: sessionPeer.peerId
+      }),
+      mainSessionKey: ""
+    };
+  } else {
+    route = rt.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dingtalk",
+      accountId,
+      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId }
+    });
+  }
+  const questionContext = getDingTalkQuestionContext();
+  if (questionContext) {
+    questionContext.resolvedRoute = route;
+    questionContext.questionScopeKey = `${accountId}:${route.sessionKey}:${senderId}`;
+    questionContext.storePath = accountStorePath;
+    questionContext.continuationSubAgentOptions = subAgentOptions ? {
+      agentId: subAgentOptions.agentId,
+      responsePrefix: subAgentOptions.responsePrefix,
+      matchedName: subAgentOptions.matchedName
+    } : void 0;
+  }
+  if (!subAgentOptions) {
+    invalidateQuestionRoutes([route]);
+  }
   const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
     agentId: route.agentId
   });
@@ -10856,7 +11404,29 @@ async function handleDingTalkMessageInner(params) {
   const quotedRef = buildInboundQuotedRef(data, extractedContent);
   const replyQuotedRef = createReplyQuotedRef(data.msgId);
   const content = extractedContent;
-  const isBtwBypass = isBtwRequestText(stripLeadingMentions(content.text).trim());
+  const controlText = stripLeadingMentions(content.text).trim();
+  const isBtwBypass = isBtwRequestText(controlText);
+  const isAbortBypass = isAbortRequestText(controlText);
+  if (params.inboundQueueEligible && !params.inboundQueueHandled && inboundOrigin !== "ask-user" && !isBtwBypass && !isAbortBypass) {
+    await dispatchInboundViaSessionQueue(
+      {
+        accountId,
+        data,
+        dingtalkConfig,
+        sessionKey: route.sessionKey,
+        to,
+        storePath: accountStorePath,
+        quoteContent: rawInboundText.slice(0, 200),
+        log
+      },
+      (preCreatedCard) => handleDingTalkMessage({
+        ...params,
+        preCreatedCard,
+        inboundQueueHandled: true
+      })
+    );
+    return;
+  }
   const taskInfoConversationId = groupId || to;
   const agentDisplayName = getAgentDisplayName({
     subAgentOptions,
@@ -10887,7 +11457,6 @@ async function handleDingTalkMessageInner(params) {
   let cardFlightKey;
   if (questionContext) {
     questionContext.onQuestionCardSent = async ({ questionId, outTrackId }) => {
-      questionCardTookOver = true;
       if (cardFlightKey) {
         cardCreationInFlight.delete(cardFlightKey);
         cardFlightKey = void 0;
@@ -10908,26 +11477,37 @@ async function handleDingTalkMessageInner(params) {
         log?.warn?.(
           `[DingTalk][AskUser] Question card sent, but targeted stop failed question=${questionId} outTrackId=${outTrackId} targetSessionKey=${route.sessionKey}: ${err instanceof Error ? err.message : String(err)}`
         );
+        return false;
       }
+      questionCardTookOver = true;
       if (!currentAICard) {
-        return;
+        return true;
       }
       if (isCardInTerminalState(currentAICard.state)) {
-        return;
+        return true;
+      }
+      let recalled = false;
+      try {
+        recalled = await recallAICardMessage(currentAICard, log);
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Question card took over, but AI card recall errored question=${questionId} outTrackId=${outTrackId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return true;
       }
-      const recalled = await recallAICardMessage(currentAICard, log);
       if (!recalled) {
         log?.warn?.(
           `[DingTalk][AskUser] Question card sent, but AI card recall failed; normal replies remain suppressed question=${questionId} outTrackId=${outTrackId}`
         );
-        return;
+        return true;
       }
       log?.info?.(
         `[DingTalk][AskUser] Recalled empty AI card after question card sent question=${questionId} outTrackId=${outTrackId}`
       );
+      return true;
     };
   }
-  if (useCardMode && !isBtwBypass) {
+  if (useCardMode && !isBtwBypass && !params.preCreatedCard) {
     const key = `${accountId}:${to}`;
     if (cardCreationInFlight.has(key)) {
       useCardMode = false;
@@ -10945,7 +11525,7 @@ async function handleDingTalkMessageInner(params) {
         `[DingTalk][AICard] conversationType=${data.conversationType}, conversationId=${to}`
       );
       const inboundQuoteText = rawInboundText.slice(0, 200);
-      const aiCard = await createAICard(dingtalkConfig, to, log, {
+      const aiCard = params.preCreatedCard ?? await createAICard(dingtalkConfig, to, log, {
         accountId,
         storePath: accountStorePath,
         contextConversationId: groupId,
@@ -11609,8 +12189,7 @@ ${attachmentExtractedText}` : inboundBody;
       }
     });
     log?.info?.(`[DingTalk] Inbound: from=${senderName} text="${content.text.slice(0, 50)}..."`);
-    const textForAbortCheck = stripLeadingMentions(inboundText).trim();
-    if (isAbortRequestText(textForAbortCheck)) {
+    if (isAbortBypass) {
       log?.info?.(
         `[DingTalk] Abort request detected, bypassing session lock for session=${route.sessionKey}`
       );
@@ -11871,53 +12450,57 @@ ${attachmentExtractedText}` : inboundBody;
         inboundText: rawInboundText,
         taskMeta
       });
-      try {
-        let deliveredFinalCount = 0;
-        const dispatchResult = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-          ctx,
-          cfg,
-          dispatcherOptions: {
-            responsePrefix: subAgentOptions?.responsePrefix || "",
-            deliver: async (payload, info) => {
-              if (isCurrentCardStopRequested()) {
-                log?.debug?.(
-                  "[DingTalk][CardStop] Ignoring reply delivery because stop was already requested"
+      let deliveredFinalCount = 0;
+      const runDispatch = () => rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx,
+        cfg,
+        dispatcherOptions: {
+          responsePrefix: subAgentOptions?.responsePrefix || "",
+          deliver: async (payload, info) => {
+            if (isCurrentCardStopRequested()) {
+              log?.debug?.(
+                "[DingTalk][CardStop] Ignoring reply delivery because stop was already requested"
+              );
+              return;
+            }
+            try {
+              if (info?.kind === "final") {
+                deliveredFinalCount += 1;
+              }
+              const inlineReplyPayload = parseInlineReplyPayloadText(payload.text);
+              const mediaUrls = extractMediaUrls(payload, inlineReplyPayload);
+              const richPayload = payload;
+              const replyKind = info?.kind || "block";
+              if (questionCardTookOver) {
+                log?.info?.(
+                  `[DingTalk][AskUser] Suppressed ${replyKind} reply after question card took over`
                 );
                 return;
               }
-              try {
-                if (info?.kind === "final") {
-                  deliveredFinalCount += 1;
-                }
-                const inlineReplyPayload = parseInlineReplyPayloadText(payload.text);
-                const mediaUrls = extractMediaUrls(payload, inlineReplyPayload);
-                const richPayload = payload;
-                const replyKind = info?.kind || "block";
-                if (questionCardTookOver) {
-                  log?.info?.(
-                    `[DingTalk][AskUser] Suppressed ${replyKind} reply after question card took over`
-                  );
-                  return;
-                }
-                await strategy.deliver({
-                  text: inlineReplyPayload.text,
-                  mediaUrls,
-                  audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
-                  kind: replyKind,
-                  isError: payload.isError === true,
-                  isReasoning: richPayload.isReasoning === true
-                });
-              } catch (err) {
-                log?.error?.(`[DingTalk] Reply failed: ${getErrorMessage(err)}`);
-                const responseData = getErrorResponseData(err);
-                if (responseData !== void 0) {
-                  log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", responseData));
-                }
-                throw err;
+              await strategy.deliver({
+                text: inlineReplyPayload.text,
+                mediaUrls,
+                audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
+                kind: replyKind,
+                isError: payload.isError === true,
+                isReasoning: richPayload.isReasoning === true
+              });
+            } catch (err) {
+              log?.error?.(`[DingTalk] Reply failed: ${getErrorMessage(err)}`);
+              const responseData = getErrorResponseData(err);
+              if (responseData !== void 0) {
+                log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", responseData));
               }
+              throw err;
             }
-          },
-          replyOptions: strategy.getReplyOptions()
+          }
+        },
+        replyOptions: strategy.getReplyOptions()
+      });
+      try {
+        const dispatchResult = await withReplySessionConflictRetry(runDispatch, {
+          log,
+          sessionKey: route.sessionKey
         });
         const bufferedFinal = dispatchResult && typeof dispatchResult === "object" && "queuedFinal" in dispatchResult ? dispatchResult.queuedFinal : void 0;
         const finalCount = dispatchResult && typeof dispatchResult === "object" && "counts" in dispatchResult ? dispatchResult.counts?.final : void 0;
@@ -11947,6 +12530,51 @@ ${attachmentExtractedText}` : inboundBody;
         }
       } catch (dispatchErr) {
         const error = dispatchErr instanceof Error ? dispatchErr : new Error(getErrorMessage(dispatchErr));
+        if (isReplySessionConflictError(error)) {
+          log?.warn?.(
+            `[DingTalk] Reply session still conflicted after retries for session=${route.sessionKey}; sending "processing" acknowledgement instead of dropping the message.`
+          );
+          const ackText = "\u6536\u5230\uFF0C\u4E0A\u4E00\u8F6E\u8FD8\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7A0D\u5019\u518D\u8BD5\u3002";
+          if (replyMode === "card") {
+            try {
+              await strategy.deliver({
+                text: ackText,
+                mediaUrls: [],
+                kind: "final",
+                isReasoning: false
+              });
+              await strategy.finalize();
+              return;
+            } catch (cardAckErr) {
+              log?.warn?.(
+                `[DingTalk] Processing acknowledgement card finalize failed: ${getErrorMessage(cardAckErr)}`
+              );
+              return;
+            }
+          }
+          try {
+            if (sessionWebhook) {
+              await sendBySession(dingtalkConfig, sessionWebhook, ackText, {
+                log,
+                accountId,
+                storePath: accountStorePath
+              });
+            } else {
+              await sendMessage(dingtalkConfig, to, ackText, {
+                log,
+                accountId,
+                storePath: accountStorePath,
+                conversationId: groupId
+              });
+            }
+          } catch (ackErr) {
+            log?.warn?.(
+              `[DingTalk] Processing acknowledgement delivery failed: ${getErrorMessage(ackErr)}`
+            );
+          }
+          await strategy.abort(error);
+          return;
+        }
         await strategy.abort(error);
         throw dispatchErr;
       }
@@ -11975,6 +12603,194 @@ ${attachmentExtractedText}` : inboundBody;
   }
 }
 
+// src/card/ask-user-question-store.ts
+var ASK_USER_LIFECYCLE_NAMESPACE = "cards.ask-user.lifecycle";
+var ACTIVE_TTL_MS = 5 * 60 * 1e3;
+var TOMBSTONE_TTL_MS = 30 * 60 * 1e3;
+function now(options) {
+  return options.now?.() ?? Date.now();
+}
+function emptyState(timestamp) {
+  return { version: 1, updatedAt: timestamp, records: [] };
+}
+function isActiveState(state) {
+  return state === "reserved" || state === "pending" || state === "dispatching";
+}
+function isAnswerableState(state) {
+  return state === "reserved" || state === "pending";
+}
+function loadState2(options) {
+  const timestamp = now(options);
+  const state = readNamespaceJson(ASK_USER_LIFECYCLE_NAMESPACE, {
+    storePath: options.storePath,
+    scope: { accountId: options.accountId },
+    fallback: emptyState(timestamp),
+    log: options.log
+  });
+  if (state.version !== 1 || !Array.isArray(state.records)) {
+    return emptyState(timestamp);
+  }
+  return state;
+}
+function persistState(options, state) {
+  state.updatedAt = now(options);
+  writeNamespaceJsonAtomic(ASK_USER_LIFECYCLE_NAMESPACE, {
+    storePath: options.storePath,
+    scope: { accountId: options.accountId },
+    data: state,
+    log: options.log
+  });
+}
+function toTerminal(record, reason, timestamp) {
+  record.state = "terminal";
+  record.terminalReason = reason;
+  record.updatedAt = timestamp;
+  record.expiresAt = timestamp + TOMBSTONE_TTL_MS;
+  return record;
+}
+function cleanupState(state, timestamp) {
+  let changed = false;
+  for (const record of state.records) {
+    if (isAnswerableState(record.state) && record.expiresAt <= timestamp) {
+      toTerminal(record, "expired", timestamp);
+      changed = true;
+    }
+  }
+  const retained = state.records.filter(
+    (record) => record.state !== "terminal" || record.expiresAt > timestamp
+  );
+  if (retained.length !== state.records.length) {
+    state.records = retained;
+    changed = true;
+  }
+  return changed;
+}
+function readCleanState(options) {
+  const state = loadState2(options);
+  if (cleanupState(state, now(options))) {
+    persistState(options, state);
+  }
+  return state;
+}
+function findRecord(state, identifier) {
+  if (identifier.outTrackId) {
+    const byTrackId = state.records.find((record) => record.outTrackId === identifier.outTrackId);
+    if (byTrackId) {
+      return byTrackId;
+    }
+  }
+  if (identifier.questionId) {
+    return state.records.find((record) => record.questionId === identifier.questionId);
+  }
+  return void 0;
+}
+function reserveAskUserQuestion(options, input) {
+  const timestamp = now(options);
+  const state = readCleanState(options);
+  const record = {
+    questionId: input.questionId,
+    accountId: options.accountId,
+    questionScopeKey: input.questionScopeKey,
+    outTrackId: input.outTrackId,
+    title: input.title,
+    state: "reserved",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    expiresAt: timestamp + ACTIVE_TTL_MS
+  };
+  state.records = state.records.filter(
+    (item) => item.questionId !== input.questionId && item.outTrackId !== input.outTrackId
+  );
+  state.records.push(record);
+  persistState(options, state);
+  return { ...record };
+}
+function activateAskUserQuestion(options, questionId) {
+  const timestamp = now(options);
+  const state = readCleanState(options);
+  const record = findRecord(state, { questionId });
+  if (!record || record.state !== "reserved") {
+    return { record: record ? { ...record } : void 0, superseded: [] };
+  }
+  const superseded = [];
+  for (const candidate of state.records) {
+    if (candidate !== record && isAnswerableState(candidate.state) && candidate.questionScopeKey === record.questionScopeKey) {
+      toTerminal(candidate, "superseded_by_question", timestamp);
+      superseded.push({ ...candidate });
+    }
+  }
+  record.state = "pending";
+  record.updatedAt = timestamp;
+  record.expiresAt = timestamp + ACTIVE_TTL_MS;
+  persistState(options, state);
+  return { record: { ...record }, superseded };
+}
+function claimAskUserQuestion(options, identifier) {
+  const timestamp = now(options);
+  const state = readCleanState(options);
+  const record = findRecord(state, identifier);
+  if (!record || record.state !== "pending") {
+    return void 0;
+  }
+  record.state = "dispatching";
+  record.updatedAt = timestamp;
+  record.expiresAt = timestamp + ACTIVE_TTL_MS;
+  persistState(options, state);
+  return { ...record };
+}
+function terminateAskUserQuestion(options, questionId, reason) {
+  const timestamp = now(options);
+  const state = readCleanState(options);
+  const record = findRecord(state, { questionId });
+  if (!record || !isActiveState(record.state)) {
+    return void 0;
+  }
+  toTerminal(record, reason, timestamp);
+  persistState(options, state);
+  return { ...record };
+}
+function invalidateAskUserQuestionsInScope(options, questionScopeKey, reason) {
+  const timestamp = now(options);
+  const state = readCleanState(options);
+  const invalidated = [];
+  for (const record of state.records) {
+    if (isAnswerableState(record.state) && record.questionScopeKey === questionScopeKey) {
+      toTerminal(record, reason, timestamp);
+      invalidated.push({ ...record });
+    }
+  }
+  if (invalidated.length > 0) {
+    persistState(options, state);
+  }
+  return invalidated;
+}
+function resolveAskUserQuestion(options, identifier) {
+  const record = findRecord(readCleanState(options), identifier);
+  return record ? { ...record } : void 0;
+}
+function recoverAskUserQuestionsAfterRestart(options) {
+  const timestamp = now(options);
+  const state = loadState2(options);
+  const retained = state.records.filter(
+    (record) => record.state !== "terminal" || record.expiresAt > timestamp
+  );
+  const removedExpiredTombstones = retained.length !== state.records.length;
+  state.records = retained;
+  const recovered = [];
+  for (const record of state.records) {
+    if (!isActiveState(record.state)) {
+      continue;
+    }
+    const reason = record.state === "dispatching" ? "restart_during_dispatch" : "restart_invalidated";
+    toTerminal(record, reason, timestamp);
+    recovered.push({ ...record });
+  }
+  if (recovered.length > 0 || removedExpiredTombstones) {
+    persistState(options, state);
+  }
+  return recovered;
+}
+
 // src/card/ask-user-question.ts
 var DINGTALK_API4 = "https://api.dingtalk.com";
 var PENDING_QUESTION_TTL_MS = 5 * 60 * 1e3;
@@ -12244,9 +13060,11 @@ function supersedePendingQuestionsInScope(ctx) {
     });
   }
 }
-function storePendingQuestion(ctx) {
+function storePendingQuestion(ctx, options = {}) {
   ctx.ownerUserId = resolvePendingQuestionOwner(ctx);
-  supersedePendingQuestionsInScope(ctx);
+  if (options.supersedeExisting !== false) {
+    supersedePendingQuestionsInScope(ctx);
+  }
   pendingQuestionsByTrackId.set(ctx.outTrackId, ctx);
   pendingQuestionsByQuestionId.set(ctx.questionId, ctx);
   addScopeIndex(ctx);
@@ -12254,7 +13072,9 @@ function storePendingQuestion(ctx) {
     if (!pendingQuestionsByTrackId.has(ctx.outTrackId) || ctx.submitted) {
       return;
     }
-    ctx.submitted = true;
+    if (!claimPendingQuestionForDispatch(ctx)) {
+      return;
+    }
     consumePendingQuestion(ctx);
     addHandledQuestionTombstone(ctx, "expired");
     void updateQuestionCardBestEffort(ctx, {
@@ -12262,14 +13082,12 @@ function storePendingQuestion(ctx) {
       question_desc: "\u95EE\u9898\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002",
       form_btn_text: "\u5DF2\u5931\u6548"
     });
-    setImmediate(() => {
-      void injectAnswerSyntheticMessage(ctx, buildExpiredAnswerMessage(ctx), "expired").catch(
-        (err) => {
-          ctx.log?.error?.(
-            `[DingTalk][AskUser] Failed to inject expired answer message: ${String(err)}`
-          );
-        }
-      );
+    dispatchSyntheticAnswer({
+      ctx,
+      text: buildExpiredAnswerMessage(ctx),
+      suffix: "expired",
+      successReason: "expired",
+      log: ctx.log
     });
   }, PENDING_QUESTION_TTL_MS);
 }
@@ -12294,6 +13112,123 @@ async function updateQuestionCardBestEffort(ctx, variables) {
     );
   }
 }
+function getAskUserStoreOptions(params) {
+  if (!params.storePath) {
+    return void 0;
+  }
+  return {
+    storePath: params.storePath,
+    accountId: params.accountId,
+    log: params.log
+  };
+}
+function terminalCardVariables(reason) {
+  const descriptions = {
+    delivery_failed: "\u95EE\u9898\u5361\u7247\u53D1\u9001\u5931\u8D25\u3002",
+    superseded_by_question: "\u5DF2\u6709\u65B0\u7684\u95EE\u9898\u5361\u7247\uFF0C\u8BF7\u56DE\u7B54\u6700\u65B0\u5361\u7247\u3002",
+    superseded_by_message: "\u4F60\u5728\u95EE\u9898\u5361\u7247\u53D1\u51FA\u540E\u53D1\u9001\u4E86\u65B0\u6D88\u606F\uFF0C\u6B64\u5361\u5DF2\u5931\u6548\u3002\u8BF7\u91CD\u65B0\u53D1\u8D77\u9700\u8981\u586B\u5199\u7684\u95EE\u9898\u3002",
+    expired: "\u95EE\u9898\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002",
+    cancelled: "\u5DF2\u53D6\u6D88\u3002",
+    empty: "\u5DF2\u63D0\u4EA4\uFF0C\u672A\u586B\u5199\u4EFB\u4F55\u5185\u5BB9\u3002",
+    submitted: "\u5DF2\u63D0\u4EA4\u3002",
+    pause_failed: "\u5F53\u524D\u4EFB\u52A1\u672A\u80FD\u6682\u505C\uFF0C\u6B64\u5361\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002",
+    restart_invalidated: "\u670D\u52A1\u5DF2\u91CD\u542F\uFF0C\u539F\u95EE\u9898\u4E0A\u4E0B\u6587\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002",
+    restart_during_dispatch: "\u670D\u52A1\u5728\u5904\u7406\u56DE\u7B54\u671F\u95F4\u91CD\u542F\uFF0C\u672C\u6B21\u5904\u7406\u7ED3\u679C\u53EF\u80FD\u672A\u5B8C\u6210\uFF0C\u8BF7\u53D1\u9001\u65B0\u6D88\u606F\u7EE7\u7EED\u3002",
+    dispatch_failed: "\u56DE\u7B54\u5DF2\u6536\u5230\uFF0C\u4F46\u672A\u80FD\u7EE7\u7EED\u4F1A\u8BDD\uFF0C\u8BF7\u53D1\u9001\u4E00\u6761\u666E\u901A\u6D88\u606F\u7EE7\u7EED\u3002"
+  };
+  return {
+    card_status: reason === "cancelled" ? "cancelled" : reason === "submitted" || reason === "empty" ? "submitted" : "expired",
+    question_desc: descriptions[reason],
+    form_btn_text: reason === "cancelled" ? "\u5DF2\u53D6\u6D88" : reason === "submitted" || reason === "empty" ? "\u5DF2\u63D0\u4EA4" : "\u5DF2\u5931\u6548"
+  };
+}
+async function updateLifecycleRecordCardBestEffort(params) {
+  const reason = params.record.terminalReason;
+  if (!reason || reason === "delivery_failed") {
+    return;
+  }
+  try {
+    const token = await getAccessToken(params.config, params.log);
+    await updateCardVariables(
+      params.record.outTrackId,
+      terminalCardVariables(reason),
+      token,
+      params.config
+    );
+  } catch (err) {
+    params.log?.warn?.(
+      `[DingTalk][AskUser] Failed to update lifecycle card ${params.record.questionId}: ${String(err)}`
+    );
+  }
+}
+function consumeLifecyclePendingContext(record) {
+  const ctx = pendingQuestionsByQuestionId.get(record.questionId) ?? pendingQuestionsByTrackId.get(record.outTrackId);
+  if (!ctx) {
+    return void 0;
+  }
+  ctx.submitted = true;
+  consumePendingQuestion(ctx);
+  addHandledQuestionTombstone(ctx, record.terminalReason === "expired" ? "expired" : "superseded");
+  return ctx;
+}
+function invalidateAskUserQuestionsForScope(params) {
+  const invalidated = invalidateAskUserQuestionsInScope(
+    {
+      storePath: params.storePath,
+      accountId: params.accountId,
+      log: params.log
+    },
+    params.questionScopeKey,
+    params.reason
+  );
+  for (const record of invalidated) {
+    consumeLifecyclePendingContext(record);
+  }
+  return invalidated;
+}
+async function syncInvalidatedAskUserQuestionCards(params) {
+  await Promise.allSettled(
+    params.records.map(
+      (record) => updateLifecycleRecordCardBestEffort({
+        record,
+        config: params.config,
+        log: params.log
+      })
+    )
+  );
+}
+async function recoverAskUserQuestionsForAccount(params) {
+  if (!params.storePath) {
+    return 0;
+  }
+  const recovered = recoverAskUserQuestionsAfterRestart({
+    storePath: params.storePath,
+    accountId: params.accountId,
+    log: params.log
+  });
+  for (const record of recovered) {
+    consumeLifecyclePendingContext(record);
+    await updateLifecycleRecordCardBestEffort({
+      record,
+      config: params.config,
+      log: params.log
+    });
+  }
+  return recovered.length;
+}
+async function terminatePendingQuestion(params) {
+  const storeOptions = getAskUserStoreOptions(params.ctx);
+  if (storeOptions) {
+    terminateAskUserQuestion(storeOptions, params.ctx.questionId, params.reason);
+  }
+  params.ctx.submitted = true;
+  consumePendingQuestion(params.ctx);
+  addHandledQuestionTombstone(
+    params.ctx,
+    params.reason === "cancelled" ? "cancelled" : params.reason === "empty" ? "empty" : params.reason === "submitted" ? "submitted" : params.reason === "expired" ? "expired" : "superseded"
+  );
+  await updateQuestionCardBestEffort(params.ctx, terminalCardVariables(params.reason));
+}
 function parseEmbeddedJson2(value) {
   if (typeof value !== "string") {
     return value;
@@ -12413,7 +13348,42 @@ async function injectAnswerSyntheticMessage(ctx, text, suffix) {
     data: syntheticData,
     sessionWebhook: ctx.sessionWebhook,
     log: ctx.log,
-    dingtalkConfig: ctx.dingtalkConfig
+    dingtalkConfig: ctx.dingtalkConfig,
+    inboundOrigin: "ask-user",
+    routeOverride: ctx.resolvedRoute,
+    subAgentOptions: ctx.continuationSubAgentOptions
+  });
+}
+function claimPendingQuestionForDispatch(ctx) {
+  const storeOptions = getAskUserStoreOptions(ctx);
+  if (storeOptions) {
+    return Boolean(
+      claimAskUserQuestion(storeOptions, {
+        questionId: ctx.questionId,
+        outTrackId: ctx.outTrackId
+      })
+    );
+  }
+  if (ctx.submitted) {
+    return false;
+  }
+  ctx.submitted = true;
+  return true;
+}
+function dispatchSyntheticAnswer(params) {
+  const storeOptions = getAskUserStoreOptions(params.ctx);
+  void injectAnswerSyntheticMessage(params.ctx, params.text, params.suffix).then(() => {
+    if (storeOptions) {
+      terminateAskUserQuestion(storeOptions, params.ctx.questionId, params.successReason);
+    }
+  }).catch((err) => {
+    if (storeOptions) {
+      terminateAskUserQuestion(storeOptions, params.ctx.questionId, "dispatch_failed");
+    }
+    void updateQuestionCardBestEffort(params.ctx, terminalCardVariables("dispatch_failed"));
+    params.log?.error?.(
+      `[DingTalk][AskUser] Failed to inject ${params.suffix} answer message: ${String(err)}`
+    );
   });
 }
 async function handleDingTalkAskUserCardCallback(params) {
@@ -12425,8 +13395,43 @@ async function handleDingTalkAskUserCardCallback(params) {
     );
     return { handled: true };
   }
+  const storeOptions = params.storePath ? {
+    storePath: params.storePath,
+    accountId: params.accountId,
+    log: params.log
+  } : void 0;
+  const lifecycleRecord = storeOptions ? resolveAskUserQuestion(storeOptions, {
+    questionId: parsed.actionId,
+    outTrackId: parsed.outTrackId
+  }) : void 0;
+  if (lifecycleRecord?.state === "terminal") {
+    params.log?.debug?.(
+      `[DingTalk][AskUser] Ignoring terminal callback question=${lifecycleRecord.questionId} reason=${lifecycleRecord.terminalReason ?? "unknown"}`
+    );
+    await updateLifecycleRecordCardBestEffort({
+      record: lifecycleRecord,
+      config: params.config,
+      log: params.log
+    });
+    return { handled: true };
+  }
   const ctx = (parsed.outTrackId ? pendingQuestionsByTrackId.get(parsed.outTrackId) : void 0) ?? (parsed.actionId ? pendingQuestionsByQuestionId.get(parsed.actionId) : void 0);
   if (!ctx) {
+    if (lifecycleRecord && storeOptions) {
+      const recovered = terminateAskUserQuestion(
+        storeOptions,
+        lifecycleRecord.questionId,
+        lifecycleRecord.state === "dispatching" ? "restart_during_dispatch" : "restart_invalidated"
+      );
+      if (recovered) {
+        await updateLifecycleRecordCardBestEffort({
+          record: recovered,
+          config: params.config,
+          log: params.log
+        });
+      }
+      return { handled: true };
+    }
     return { handled: false };
   }
   if (!isOwnerClick(ctx, params.clickerUserId)) {
@@ -12441,13 +13446,15 @@ async function handleDingTalkAskUserCardCallback(params) {
     );
     return { handled: true };
   }
-  if (ctx.submitted) {
+  if (ctx.submitted || lifecycleRecord?.state === "dispatching") {
     params.log?.debug?.(`[DingTalk][AskUser] Duplicate submit ignored question=${ctx.questionId}`);
     return { handled: true };
   }
   const isCancel = parseBooleanLike(parsed.params.user_cancel) === true;
-  ctx.submitted = true;
   if (isCancel) {
+    if (!claimPendingQuestionForDispatch(ctx)) {
+      return { handled: true };
+    }
     await updateQuestionCardBestEffort(ctx, {
       card_status: "cancelled",
       question_desc: "\u5DF2\u53D6\u6D88\u3002",
@@ -12455,25 +13462,25 @@ async function handleDingTalkAskUserCardCallback(params) {
     });
     consumePendingQuestion(ctx);
     addHandledQuestionTombstone(ctx, "cancelled");
-    setImmediate(() => {
-      void injectAnswerSyntheticMessage(ctx, buildCancelledAnswerMessage(ctx), "cancelled").catch(
-        (err) => {
-          params.log?.error?.(
-            `[DingTalk][AskUser] Failed to inject cancelled answer message: ${String(err)}`
-          );
-        }
-      );
+    dispatchSyntheticAnswer({
+      ctx,
+      text: buildCancelledAnswerMessage(ctx),
+      suffix: "cancelled",
+      successReason: "cancelled",
+      log: params.log
     });
     return { handled: true };
   }
   const form = asRecord5(parsed.params.form);
   if (!form) {
-    ctx.submitted = false;
     params.log?.warn?.(
       `[DingTalk][AskUser] Missing form payload question=${ctx.questionId} params=${JSON.stringify(parsed.params)}`
     );
     return { handled: true };
   }
+  if (!claimPendingQuestionForDispatch(ctx)) {
+    return { handled: true };
+  }
   const answers = [];
   const selectedValues = [];
   for (const question of ctx.questions) {
@@ -12497,12 +13504,12 @@ async function handleDingTalkAskUserCardCallback(params) {
     });
     consumePendingQuestion(ctx);
     addHandledQuestionTombstone(ctx, "empty");
-    setImmediate(() => {
-      void injectAnswerSyntheticMessage(ctx, buildEmptyAnswerMessage(ctx), "empty").catch((err) => {
-        params.log?.error?.(
-          `[DingTalk][AskUser] Failed to inject empty answer message: ${String(err)}`
-        );
-      });
+    dispatchSyntheticAnswer({
+      ctx,
+      text: buildEmptyAnswerMessage(ctx),
+      suffix: "empty",
+      successReason: "empty",
+      log: params.log
     });
     return { handled: true };
   }
@@ -12517,10 +13524,12 @@ async function handleDingTalkAskUserCardCallback(params) {
   consumePendingQuestion(ctx);
   addHandledQuestionTombstone(ctx, "submitted");
   const message = buildAnswerMessage(ctx, answers);
-  setImmediate(() => {
-    void injectAnswerSyntheticMessage(ctx, message, "submitted").catch((err) => {
-      params.log?.error?.(`[DingTalk][AskUser] Failed to inject answer message: ${String(err)}`);
-    });
+  dispatchSyntheticAnswer({
+    ctx,
+    text: message,
+    suffix: "submitted",
+    successReason: "submitted",
+    log: params.log
   });
   return { handled: true };
 }
@@ -12647,13 +13656,12 @@ function registerDingTalkAskUserQuestionTool(api) {
     api.logger?.warn?.(`${TOOL_NAME}: registerTool unavailable, skipping tool registration`);
     return;
   }
-  registerTool.call(api, {
+  const createTool = (context) => ({
     name: TOOL_NAME,
     label: "Ask User Question",
     description: "Ask the user a blocking question or collect structured input via an interactive DingTalk form card when the current task cannot continue without the user's answer. Returns immediately after sending the card. The user's answer will arrive as a new message in the conversation. Do NOT poll or re-call this tool \u2014 just wait for the response message. Use questions only for simple confirmation, single-select, multi-select, or simple free-text prompts. For simple selection questions, provide options; for simple free-text input, set options to an empty array. When collecting multiple missing values, when the user asks for a form, or when you would otherwise list required parameters for the user to fill, call this tool with top-level fields instead of replying with a markdown checklist. Do not call this tool for normal explanations, why/how questions, capability introductions, or cases where you can answer directly.",
     parameters: AskUserQuestionSchema,
     async execute(_toolCallId, params) {
-      const context = getDingTalkQuestionContext();
       if (!context) {
         return jsonToolResult({
           status: "failed",
@@ -12687,6 +13695,16 @@ function registerDingTalkAskUserQuestionTool(api) {
         selected_values: "[]",
         form: { fields }
       };
+      const storeOptions = getAskUserStoreOptions(context);
+      const canPersistLifecycle = Boolean(storeOptions && context.questionScopeKey);
+      if (storeOptions && context.questionScopeKey) {
+        reserveAskUserQuestion(storeOptions, {
+          questionId,
+          questionScopeKey: context.questionScopeKey,
+          outTrackId,
+          title
+        });
+      }
       try {
         await createAndDeliverQuestionCard({
           config: context.dingtalkConfig,
@@ -12698,6 +13716,9 @@ function registerDingTalkAskUserQuestionTool(api) {
           log: context.log
         });
       } catch (err) {
+        if (storeOptions && canPersistLifecycle) {
+          terminateAskUserQuestion(storeOptions, questionId, "delivery_failed");
+        }
         const detail = formatDingTalkErrorPayloadLog("ask_user_create", err, "[DingTalk]");
         return jsonToolResult({
           status: "failed",
@@ -12708,20 +13729,75 @@ function registerDingTalkAskUserQuestionTool(api) {
         ...context,
         onQuestionCardSent: void 0
       };
-      storePendingQuestion({
+      const pendingQuestion = {
         ...pendingContext,
         questionId,
         outTrackId,
         title,
         questions: parsed,
         submitted: false
+      };
+      storePendingQuestion(pendingQuestion, {
+        supersedeExisting: !canPersistLifecycle
       });
+      if (storeOptions && canPersistLifecycle) {
+        const activation = activateAskUserQuestion(storeOptions, questionId);
+        if (activation.record?.state !== "pending") {
+          const terminalReason = activation.record?.terminalReason ?? "superseded_by_message";
+          if (activation.record) {
+            consumeLifecyclePendingContext(activation.record);
+          } else {
+            pendingQuestion.submitted = true;
+            consumePendingQuestion(pendingQuestion);
+            addHandledQuestionTombstone(pendingQuestion, "superseded");
+          }
+          await updateQuestionCardBestEffort(
+            pendingQuestion,
+            terminalCardVariables(terminalReason)
+          );
+          return jsonToolResult({
+            status: "failed",
+            questionId,
+            outTrackId,
+            error: "\u95EE\u9898\u5361\u7247\u5728\u53D1\u9001\u671F\u95F4\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002"
+          });
+        }
+        for (const superseded of activation.superseded) {
+          const supersededContext = consumeLifecyclePendingContext(superseded);
+          if (supersededContext) {
+            void updateQuestionCardBestEffort(
+              supersededContext,
+              terminalCardVariables("superseded_by_question")
+            );
+          } else {
+            void updateLifecycleRecordCardBestEffort({
+              record: superseded,
+              config: context.dingtalkConfig,
+              log: context.log
+            });
+          }
+        }
+      }
+      let takeoverSucceeded = void 0;
       try {
-        await context.onQuestionCardSent?.({ questionId, outTrackId });
+        takeoverSucceeded = await context.onQuestionCardSent?.({ questionId, outTrackId });
       } catch (err) {
         context.log?.warn?.(
           `[DingTalk][AskUser] onQuestionCardSent hook failed: ${err instanceof Error ? err.message : String(err)}`
         );
+        takeoverSucceeded = false;
+      }
+      if (takeoverSucceeded === false) {
+        await terminatePendingQuestion({
+          ctx: pendingQuestion,
+          reason: "pause_failed"
+        });
+        return jsonToolResult({
+          status: "failed",
+          questionId,
+          outTrackId,
+          error: "\u5F53\u524D\u4EFB\u52A1\u672A\u80FD\u6682\u505C\uFF0C\u6B64\u5361\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002"
+        });
       }
       context.log?.info?.(
         `[DingTalk][AskUser] question card sent question=${questionId} outTrackId=${outTrackId}`
@@ -12734,6 +13810,18 @@ function registerDingTalkAskUserQuestionTool(api) {
       });
     }
   });
+  registerTool.call(
+    api,
+    (toolContext) => {
+      const context = getDingTalkQuestionContext();
+      const runtimeSessionKey = toolContext.sessionKey?.trim();
+      const contextSessionKey = context?.resolvedRoute?.sessionKey.trim();
+      return createTool(
+        context && (!runtimeSessionKey || contextSessionKey === runtimeSessionKey) ? context : void 0
+      );
+    },
+    { name: TOOL_NAME }
+  );
   api.logger?.debug?.(`${TOOL_NAME}: registered tool`);
 }
 
@@ -12926,6 +14014,7 @@ async function handleCardAction(params) {
     payload: params.payload,
     cfg: params.cfg,
     accountId: params.accountId,
+    storePath: params.storePath,
     config: params.config,
     clickerUserId: params.analysis.userId,
     log: params.log
@@ -13066,8 +14155,8 @@ var ConnectionManager = class _ConnectionManager {
       `[${this.accountId}] Runtime counters (${reason}): healthUnhealthyChecks=${c.healthUnhealthyChecks}, healthTriggeredReconnects=${c.healthTriggeredReconnects}, heartbeatMisses=${c.heartbeatMisses}, heartbeatTriggeredReconnects=${c.heartbeatTriggeredReconnects}, serverDisconnectMessages=${c.serverDisconnectMessages}, socketCloseEvents=${c.socketCloseEvents}, runtimeDisconnects=${c.runtimeDisconnects}, reconnectAttempts=${c.reconnectAttempts}, reconnectSuccess=${c.reconnectSuccess}, reconnectFailures=${c.reconnectFailures}`
     );
   }
-  recordSocketActivity(now = Date.now()) {
-    this.lastSocketActivityAt = now;
+  recordSocketActivity(now2 = Date.now()) {
+    this.lastSocketActivityAt = now2;
     this.consecutiveHeartbeatMisses = 0;
   }
   setupHeartbeat(socket) {
@@ -13079,13 +14168,13 @@ var ConnectionManager = class _ConnectionManager {
       if (socket.readyState !== 1) {
         return;
       }
-      const now = Date.now();
-      const idleMs = this.lastSocketActivityAt !== void 0 ? now - this.lastSocketActivityAt : _ConnectionManager.HEARTBEAT_INTERVAL_MS;
+      const now2 = Date.now();
+      const idleMs = this.lastSocketActivityAt !== void 0 ? now2 - this.lastSocketActivityAt : _ConnectionManager.HEARTBEAT_INTERVAL_MS;
       if (idleMs >= _ConnectionManager.HEARTBEAT_INTERVAL_MS) {
         this.consecutiveHeartbeatMisses += 1;
         this.runtimeCounters.heartbeatMisses += 1;
         if (this.consecutiveHeartbeatMisses >= _ConnectionManager.HEARTBEAT_MISS_THRESHOLD) {
-          const lastPingAgoMs = this.lastHeartbeatPingAt !== void 0 ? now - this.lastHeartbeatPingAt : void 0;
+          const lastPingAgoMs = this.lastHeartbeatPingAt !== void 0 ? now2 - this.lastHeartbeatPingAt : void 0;
           this.log?.warn?.(
             `[${this.accountId}] Connection heartbeat missed ${this.consecutiveHeartbeatMisses}/${_ConnectionManager.HEARTBEAT_MISS_THRESHOLD} checks, triggering reconnection (lastPingAgoMs=${lastPingAgoMs ?? "n/a"})`
           );
@@ -13099,7 +14188,7 @@ var ConnectionManager = class _ConnectionManager {
           `[${this.accountId}] Connection heartbeat missed (${this.consecutiveHeartbeatMisses}/${_ConnectionManager.HEARTBEAT_MISS_THRESHOLD})`
         );
       }
-      this.lastHeartbeatPingAt = now;
+      this.lastHeartbeatPingAt = now2;
       try {
         socket.ping("", true);
       } catch (err) {
@@ -13340,8 +14429,8 @@ var ConnectionManager = class _ConnectionManager {
         this.consecutiveUnhealthyChecks = 0;
         return;
       }
-      const now = Date.now();
-      const withinGraceWindow = this.connectedAt !== void 0 && now - this.connectedAt < _ConnectionManager.HEALTH_CHECK_GRACE_MS;
+      const now2 = Date.now();
+      const withinGraceWindow = this.connectedAt !== void 0 && now2 - this.connectedAt < _ConnectionManager.HEALTH_CHECK_GRACE_MS;
       if (withinGraceWindow) {
         this.consecutiveUnhealthyChecks = 0;
         return;
@@ -13699,12 +14788,12 @@ var MESSAGE_DEDUP_TTL = 6e4;
 var MESSAGE_DEDUP_MAX_SIZE = 1e3;
 var messageCounter = 0;
 function isMessageProcessed(dedupKey) {
-  const now = Date.now();
+  const now2 = Date.now();
   const expiresAt = processedMessages.get(dedupKey);
   if (expiresAt === void 0) {
     return false;
   }
-  if (now >= expiresAt) {
+  if (now2 >= expiresAt) {
     processedMessages.delete(dedupKey);
     return false;
   }
@@ -13714,9 +14803,9 @@ function markMessageProcessed(dedupKey) {
   const expiresAt = Date.now() + MESSAGE_DEDUP_TTL;
   processedMessages.set(dedupKey, expiresAt);
   if (processedMessages.size > MESSAGE_DEDUP_MAX_SIZE) {
-    const now = Date.now();
+    const now2 = Date.now();
     for (const [key, expiry] of processedMessages.entries()) {
-      if (now >= expiry) {
+      if (now2 >= expiry) {
         processedMessages.delete(key);
       }
     }
@@ -13735,9 +14824,9 @@ function markMessageProcessed(dedupKey) {
   messageCounter++;
   if (messageCounter >= 10) {
     messageCounter = 0;
-    const now = Date.now();
+    const now2 = Date.now();
     for (const [key, expiry] of processedMessages.entries()) {
-      if (now >= expiry) {
+      if (now2 >= expiry) {
         processedMessages.delete(key);
       }
     }
@@ -13794,7 +14883,6 @@ function instrumentConnectionStages(client) {
     }
   };
 }
-var INFLIGHT_TTL_MS = 5 * 60 * 1e3;
 var processingDedupKeys = /* @__PURE__ */ new Map();
 var inboundCountersByAccount = /* @__PURE__ */ new Map();
 var INBOUND_COUNTER_LOG_EVERY = 10;
@@ -13864,6 +14952,23 @@ function createDingTalkGateway() {
           `[${account.accountId}] Failed to recover unfinished cards: ${err.message}`
         );
       }
+      try {
+        const recoveredQuestions = await recoverAskUserQuestionsForAccount({
+          storePath: accountStorePath,
+          accountId: account.accountId,
+          config,
+          log: pluginLog
+        });
+        if (recoveredQuestions > 0) {
+          pluginLog?.info?.(
+            `[${account.accountId}] Invalidated ${recoveredQuestions} unfinished Ask User card(s) from previous runtime`
+          );
+        }
+      } catch (err) {
+        pluginLog?.warn?.(
+          `[${account.accountId}] Failed to recover Ask User cards: ${err.message}`
+        );
+      }
       const useConnectionManager = config.useConnectionManager ?? true;
       const applyStatusPatch = (patch) => {
         ctx.setStatus({
@@ -13921,7 +15026,9 @@ function createDingTalkGateway() {
                 data,
                 sessionWebhook: data.sessionWebhook,
                 log: pluginLog,
-                dingtalkConfig: config
+                dingtalkConfig: config,
+                inboundOrigin: "stream",
+                inboundQueueEligible: true
               });
               stats.processed += 1;
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
@@ -13936,22 +15043,14 @@ function createDingTalkGateway() {
               logInboundCounters(pluginLog, account.accountId, "dedup-skipped");
               return;
             }
-            const inflightSince = processingDedupKeys.get(dedupKey);
-            if (inflightSince !== void 0) {
-              if (Date.now() - inflightSince > INFLIGHT_TTL_MS) {
-                pluginLog?.warn?.(
-                  `[${account.accountId}] Releasing stale in-flight lock for ${dedupKey} (held ${Date.now() - inflightSince}ms > TTL ${INFLIGHT_TTL_MS}ms)`
-                );
-                processingDedupKeys.delete(dedupKey);
-              } else {
-                pluginLog?.debug?.(
-                  `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`
-                );
-                stats.inflightSkipped += 1;
-                acknowledge();
-                logInboundCounters(pluginLog, account.accountId, "inflight-skipped");
-                return;
-              }
+            if (processingDedupKeys.has(dedupKey)) {
+              pluginLog?.debug?.(
+                `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`
+              );
+              stats.inflightSkipped += 1;
+              acknowledge();
+              logInboundCounters(pluginLog, account.accountId, "inflight-skipped");
+              return;
             }
             acknowledge();
             processingDedupKeys.set(dedupKey, Date.now());
@@ -13962,7 +15061,9 @@ function createDingTalkGateway() {
                 data,
                 sessionWebhook: data.sessionWebhook,
                 log: pluginLog,
-                dingtalkConfig: config
+                dingtalkConfig: config,
+                inboundOrigin: "stream",
+                inboundQueueEligible: true
               });
               stats.processed += 1;
               markMessageProcessed(dedupKey);
@@ -14034,6 +15135,7 @@ function createDingTalkGateway() {
               analysis,
               cfg,
               accountId: account.accountId,
+              storePath: accountStorePath,
               config,
               log: pluginLog
             });
@@ -14185,19 +15287,6 @@ function createDingTalkGateway() {
               lastError: null
             });
           } else if (state === "FAILED" /* FAILED */ || state === "DISCONNECTED" /* DISCONNECTED */) {
-            const robotKey = resolveRobotCode(config) || account.accountId;
-            let cleared = 0;
-            for (const key of processingDedupKeys.keys()) {
-              if (key.startsWith(`${robotKey}:`)) {
-                processingDedupKeys.delete(key);
-                cleared++;
-              }
-            }
-            if (cleared > 0) {
-              pluginLog?.info?.(
-                `[${account.accountId}] Cleared ${cleared} stale in-flight lock(s) on disconnect`
-              );
-            }
             applyStatusPatch({
               running: false,
               connected: false,
@@ -14338,13 +15427,13 @@ async function beginDeviceRegistration() {
     }) : null;
     abortPromise?.catch(() => {
     });
-    const sleep = () => new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
+    const sleep2 = () => new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
     try {
       while (Date.now() < deadline) {
         if (signal?.aborted) {
           throw new RegistrationError("registration cancelled");
         }
-        await (abortPromise ? Promise.race([sleep(), abortPromise]) : sleep());
+        await (abortPromise ? Promise.race([sleep2(), abortPromise]) : sleep2());
         if (signal?.aborted) {
           throw new RegistrationError("registration cancelled");
         }
@@ -14704,9 +15793,9 @@ async function configureDingTalkAccount(params) {
       let lastWaitingNote = 0;
       const result = await session.waitForResult({
         onWaiting: () => {
-          const now = Date.now();
-          if (now - lastWaitingNote >= 15e3) {
-            lastWaitingNote = now;
+          const now2 = Date.now();
+          if (now2 - lastWaitingNote >= 15e3) {
+            lastWaitingNote = now2;
             prompter.note("Waiting for authorization. Please finish the scan in DingTalk...", "Polling").catch(() => {
             });
           }