@soimy/dingtalk 3.6.6 → 3.6.7

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;
@@ -3365,9 +3365,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);
       }
     }
@@ -9789,10 +9789,61 @@ async function dispatchSubAgents(params) {
     dingtalkConfig,
     sessionWebhook,
     extractedContent,
+    sessionPeer,
+    onRoutesResolved,
     handleMessage,
     downloadMedia: download,
     log
   } = 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 +9866,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 +9876,7 @@ async function dispatchSubAgents(params) {
         sessionWebhook,
         log,
         dingtalkConfig,
+        routeOverride: target.route,
         subAgentOptions: {
           agentId: agentMatch.agentId,
           responsePrefix: commandText ? "" : `> \u{1F916} **${sanitizeAgentName(agentMatch.matchedName)}**:
@@ -9838,22 +9890,8 @@ async function dispatchSubAgents(params) {
     } 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 +10593,8 @@ async function handleDingTalkMessageInner(params) {
     sessionWebhook,
     log,
     dingtalkConfig,
+    inboundOrigin = "stream",
+    routeOverride,
     subAgentOptions,
     preDownloadedMedia
   } = params;
@@ -10749,32 +10789,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,6 +10836,8 @@ async function handleDingTalkMessageInner(params) {
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) => invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log
@@ -10814,6 +10866,8 @@ async function handleDingTalkMessageInner(params) {
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) => invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log
@@ -10821,6 +10875,44 @@ async function handleDingTalkMessageInner(params) {
       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
   });
@@ -10887,7 +10979,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,23 +10999,34 @@ 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) {
@@ -11975,6 +12077,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 +12534,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 +12546,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 +12556,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 +12586,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 +12822,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 +12869,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 +12920,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 +12936,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 +12978,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 +12998,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 };
 }
@@ -12687,6 +13170,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 +13191,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 +13204,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}`
@@ -12926,6 +13477,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 +13618,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 +13631,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 +13651,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 +13892,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 +14251,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 +14266,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 +14287,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);
       }
     }
@@ -13864,6 +14416,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({
@@ -14034,6 +14603,7 @@ function createDingTalkGateway() {
               analysis,
               cfg,
               accountId: account.accountId,
+              storePath: accountStorePath,
               config,
               log: pluginLog
             });
@@ -14704,9 +15274,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(() => {
             });
           }