@soimy/dingtalk 3.6.11 → 3.7.0

package/src/messaging/quoted-ref.ts

@@ -1,8 +1,5 @@
-import {
-  resolveByQuotedRef,
-  type MessageRecord,
-} from "../message-context-store";
-import type { DingTalkInboundMessage, Logger, MessageContent, QuotedRef } from "../types";
+import type { DingTalkInboundMessage, Logger, MessageContent, QuotedRef } from "../platform/types";
+import { resolveByQuotedRef, type MessageRecord } from "./message-context-store";
 
 function firstTrimmedString(...candidates: Array<string | undefined>): string | undefined {
   for (const candidate of candidates) {
@@ -27,7 +24,11 @@ export function buildInboundQuotedRef(
   content: MessageContent,
 ): QuotedRef | undefined {
   const repliedMsg = data.text?.repliedMsg;
-  const repliedMsgId = firstTrimmedString(repliedMsg?.msgId, data.originalMsgId, content.quoted?.msgId);
+  const repliedMsgId = firstTrimmedString(
+    repliedMsg?.msgId,
+    data.originalMsgId,
+    content.quoted?.msgId,
+  );
   const fallbackCreatedAt = firstFiniteNumber(
     repliedMsg?.createdAt,
     content.quoted?.cardCreatedAt,
@@ -38,7 +39,10 @@ export function buildInboundQuotedRef(
     repliedMsg?.senderId === data.chatbotUserId ||
     content.quoted?.isQuotedCard === true;
   if (isOutboundQuoted) {
-    const processQueryKey = firstTrimmedString(data.originalProcessQueryKey, content.quoted?.processQueryKey);
+    const processQueryKey = firstTrimmedString(
+      data.originalProcessQueryKey,
+      content.quoted?.processQueryKey,
+    );
     if (processQueryKey) {
       return {
         targetDirection: "outbound",

package/src/{reply-strategy-card.ts → messaging/reply-strategy-card.ts}

@@ -6,34 +6,43 @@
  * inbound-handler only coordinates — it no longer owns card state.
  */
 
+import { createCardDraftController } from "../card/card-draft-controller";
+import {
+  buildImagePlaceholderText,
+  extractMarkdownImageCandidates,
+} from "../card/card-markdown-image-reroute";
+import { attachCardRunController } from "../card/card-run-registry";
 import {
   commitAICardBlocks,
   isCardInTerminalState,
   updateAICardStatusLine,
-} from "./card-service";
-import { splitCardReasoningAnswerText } from "./card/reasoning-answer-split";
-import { createReasoningBlockAssembler } from "./card/reasoning-block-assembler";
+} from "../card/card-service";
 import {
   resolveCardStreamingMode,
   shouldWarnDeprecatedCardRealTimeStreamOnce,
-} from "./card/card-streaming-mode";
+} from "../card/card-streaming-mode";
 import {
-  buildImagePlaceholderText,
-  extractMarkdownImageCandidates,
-} from "./card/card-markdown-image-reroute";
-import { createCardDraftController } from "./card-draft-controller";
-import { attachCardRunController } from "./card/card-run-registry";
-import type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext } from "./reply-strategy-types";
-import { resolveRelativePath } from "./config";
+  createCardTaskProgressController,
+  resolveCardTaskProgressEnabled,
+} from "../card/card-task-progress";
+import { splitCardReasoningAnswerText } from "../card/reasoning-answer-split";
+import { createReasoningBlockAssembler } from "../card/reasoning-block-assembler";
+import { recordRunStart, getAggregatedUsage, clearRuns } from "../card/run-usage-store";
+import { renderStatusLine } from "../card/statusline-renderer";
+import type { StatusLineData } from "../card/statusline-renderer";
+import { resolveRelativePath } from "../platform/config";
+import { getTaskTimeSeconds, updateSessionState } from "../platform/session-state";
+import type { AICardInstance } from "../platform/types";
+import { AICardStatus } from "../platform/types";
+import { formatDingTalkErrorPayloadLog } from "../shared/utils";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
-import { getTaskTimeSeconds, updateSessionState } from "./session-state";
-import { renderStatusLine } from "./card/statusline-renderer";
-import type { StatusLineData } from "./card/statusline-renderer";
-import { recordRunStart, getAggregatedUsage, clearRuns } from "./run-usage-store";
+import type {
+  DeliverPayload,
+  ReplyOptions,
+  ReplyStrategy,
+  ReplyStrategyContext,
+} from "./reply-strategy-types";
 import { sendBySession, sendMessage, sendProactiveMedia, uploadMedia } from "./send-service";
-import type { AICardInstance } from "./types";
-import { AICardStatus } from "./types";
-import { formatDingTalkErrorPayloadLog } from "./utils";
 
 const EMPTY_FINAL_REPLY = "✅ Done";
 const DEFAULT_CARD_FAILED_MESSAGE = "回复生成失败，请重试";
@@ -73,33 +82,38 @@ export function createCardReplyStrategy(
       ? getTaskTimeSeconds(sessionTaskStateScope)
       : undefined;
     const cardElapsedMs = Math.max(0, Date.now() - card.createdAt);
-    const sessionElapsedMs = typeof sessionTaskTimeSeconds === "number"
-      ? sessionTaskTimeSeconds * 1000
-      : undefined;
-    const metaElapsedMs = typeof ctx.taskMeta.elapsedMs === "number" && ctx.taskMeta.elapsedMs > 0
-      ? ctx.taskMeta.elapsedMs
-      : undefined;
-    ctx.taskMeta.elapsedMs = Math.max(
-      cardElapsedMs,
-      sessionElapsedMs ?? 0,
-      metaElapsedMs ?? 0,
-    );
+    const sessionElapsedMs =
+      typeof sessionTaskTimeSeconds === "number" ? sessionTaskTimeSeconds * 1000 : undefined;
+    const metaElapsedMs =
+      typeof ctx.taskMeta.elapsedMs === "number" && ctx.taskMeta.elapsedMs > 0
+        ? ctx.taskMeta.elapsedMs
+        : undefined;
+    ctx.taskMeta.elapsedMs = Math.max(cardElapsedMs, sessionElapsedMs ?? 0, metaElapsedMs ?? 0);
 
     let inputTokens: number | undefined;
     let outputTokens: number | undefined;
     let cacheRead: number | undefined;
     if (ctx.taskMeta.runIds && ctx.taskMeta.runIds.size > 0) {
       const tokenUsage = getAggregatedUsage(ctx.taskMeta.runIds);
-      if (typeof tokenUsage.input === "number") { inputTokens = tokenUsage.input; }
-      if (typeof tokenUsage.output === "number") { outputTokens = tokenUsage.output; }
-      if (typeof tokenUsage.cacheRead === "number") { cacheRead = tokenUsage.cacheRead; }
+      if (typeof tokenUsage.input === "number") {
+        inputTokens = tokenUsage.input;
+      }
+      if (typeof tokenUsage.output === "number") {
+        outputTokens = tokenUsage.output;
+      }
+      if (typeof tokenUsage.cacheRead === "number") {
+        cacheRead = tokenUsage.cacheRead;
+      }
     }
 
     const statusLineData: StatusLineData = {
       model: ctx.taskMeta.model,
       effort: ctx.taskMeta.effort,
       agent: ctx.taskMeta.agent,
-      taskTime: typeof ctx.taskMeta.elapsedMs === "number" ? Math.round(ctx.taskMeta.elapsedMs / 1000) : undefined,
+      taskTime:
+        typeof ctx.taskMeta.elapsedMs === "number"
+          ? Math.round(ctx.taskMeta.elapsedMs / 1000)
+          : undefined,
       inputTokens,
       outputTokens,
       cacheRead,
@@ -131,6 +145,15 @@ export function createCardReplyStrategy(
     throttleMs: config.cardStreamInterval ?? 1000,
     getStatusLine: buildStatusLine,
   });
+  const taskProgressController = createCardTaskProgressController({
+    sessionKey: ctx.sessionKey ?? "",
+    enabled: resolveCardTaskProgressEnabled(config),
+    refresh: config.cardTaskProgressRefresh,
+    runtimeEvents: ctx.runtimeEvents,
+    updateProgress: controller.updateProgress,
+    clearProgress: controller.clearProgress,
+    log,
+  });
   const reasoningAssembler = createReasoningBlockAssembler();
   if (card.outTrackId) {
     attachCardRunController(card.outTrackId, controller);
@@ -145,7 +168,8 @@ export function createCardReplyStrategy(
   const processedMediaUrls = new Set<string>();
 
   const getRenderedTimeline = (options: { preferFinalAnswer?: boolean } = {}): string => {
-    const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
+    const fallbackAnswer =
+      finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
     return controller.getRenderedContent({
       fallbackAnswer,
       overrideAnswer: options.preferFinalAnswer ? finalTextForFallback : undefined,
@@ -183,10 +207,7 @@ export function createCardReplyStrategy(
     }
     const blocks = reasoningAssembler.ingestSnapshot(text);
     const trimmed = text.trimStart();
-    if (
-      blocks.length === 0
-      && !trimmed.startsWith("Reasoning:")
-    ) {
+    if (blocks.length === 0 && !trimmed.startsWith("Reasoning:")) {
       if (trimmed.startsWith("Reason:")) {
         latestReasoningSnapshot = "";
         return;
@@ -308,8 +329,9 @@ export function createCardReplyStrategy(
       await applyModeAwareReasoningSnapshot(normalizedSnapshot.reasoningText);
     }
 
-    const answerSnapshot = normalizedSnapshot.answerText
-      ?? (!normalizedSnapshot.reasoningText ? rewrittenSnapshot : undefined);
+    const answerSnapshot =
+      normalizedSnapshot.answerText ??
+      (!normalizedSnapshot.reasoningText ? rewrittenSnapshot : undefined);
     if (!answerSnapshot) {
       return;
     }
@@ -364,9 +386,7 @@ export function createCardReplyStrategy(
       let prepared: Awaited<ReturnType<typeof prepareMediaInput>> | undefined;
       try {
         prepared = await prepareMediaInput(candidate.url, log, config.mediaUrlAllowlist);
-        const mediaPath = prepared.cleanup
-          ? prepared.path
-          : resolveRelativePath(prepared.path);
+        const mediaPath = prepared.cleanup ? prepared.path : resolveRelativePath(prepared.path);
         const mediaType = resolveOutboundMediaType({ mediaPath, asVoice: false });
         if (mediaType !== "image") {
           continue;
@@ -379,7 +399,8 @@ export function createCardReplyStrategy(
 
         processedMediaUrls.add(candidate.url.trim());
         const placeholder = buildImagePlaceholderText({ alt: candidate.alt, url: candidate.url });
-        const blockText = candidate.alt.trim() || placeholder.replace(/^见下图/, "").trim() || "图片";
+        const blockText =
+          candidate.alt.trim() || placeholder.replace(/^见下图/, "").trim() || "图片";
         successfulReroutes.push({
           start: candidate.start,
           end: candidate.end,
@@ -427,7 +448,9 @@ export function createCardReplyStrategy(
           }
           recordRunStart(runId);
           if (ctx.taskMeta) {
-            if (!ctx.taskMeta.runIds) { ctx.taskMeta.runIds = new Set(); }
+            if (!ctx.taskMeta.runIds) {
+              ctx.taskMeta.runIds = new Set();
+            }
             ctx.taskMeta.runIds.add(runId);
           }
         },
@@ -472,7 +495,10 @@ export function createCardReplyStrategy(
       const textToSend = payload.text;
 
       // Empty-payload guard — card final is an exception (e.g. file-only response).
-      if ((typeof textToSend !== "string" || textToSend.length === 0) && payload.mediaUrls.length === 0) {
+      if (
+        (typeof textToSend !== "string" || textToSend.length === 0) &&
+        payload.mediaUrls.length === 0
+      ) {
         if (payload.kind !== "final") {
           return;
         }
@@ -482,14 +508,15 @@ export function createCardReplyStrategy(
       if (payload.kind === "final") {
         // OpenClaw can append a non-terminal tool warning after a valid final.
         // Do not let that plain-text warning replace the answer already captured by the card.
-        const hasPreservableReply = Boolean(
-          finalTextForFallback?.trim() || controller.getFinalAnswerContent().trim(),
-        ) || processedMediaUrls.size > 0 || pendingNonImageMedia.length > 0;
+        const hasPreservableReply =
+          Boolean(finalTextForFallback?.trim() || controller.getFinalAnswerContent().trim()) ||
+          processedMediaUrls.size > 0 ||
+          pendingNonImageMedia.length > 0;
         if (
-          payload.isError === true
-          && sawFinalDelivery
-          && payload.mediaUrls.length === 0
-          && hasPreservableReply
+          payload.isError === true &&
+          sawFinalDelivery &&
+          payload.mediaUrls.length === 0 &&
+          hasPreservableReply
         ) {
           log?.debug?.("[DingTalk][Finalize] Ignoring late error final after answer delivery");
           return;
@@ -502,10 +529,10 @@ export function createCardReplyStrategy(
         }
         log?.info?.(
           `[DingTalk][Finalize] deliver(final) received — cardState=${card.state} ` +
-          `textLen=${typeof textToSend === "string" ? textToSend.length : "null"} ` +
-          `mediaUrls=${payload.mediaUrls.length} ` +
-          `lastAnswer="${(controller.getLastAnswerContent() ?? "").slice(0, 80)}" ` +
-          `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
+            `textLen=${typeof textToSend === "string" ? textToSend.length : "null"} ` +
+            `mediaUrls=${payload.mediaUrls.length} ` +
+            `lastAnswer="${(controller.getLastAnswerContent() ?? "").slice(0, 80)}" ` +
+            `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
         );
         // Inline media upload → image blocks in card; defer non-image attachments
         if (payload.mediaUrls.length > 0) {
@@ -516,9 +543,14 @@ export function createCardReplyStrategy(
             }
             try {
               const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
-              const mediaType = resolveOutboundMediaType({ mediaPath: prepared.path, asVoice: false });
+              const mediaType = resolveOutboundMediaType({
+                mediaPath: prepared.path,
+                asVoice: false,
+              });
               if (mediaType !== "image") {
-                log?.debug?.(`[DingTalk][Card] Deferring non-image media (${mediaType}) for out-of-card delivery: ${url}`);
+                log?.debug?.(
+                  `[DingTalk][Card] Deferring non-image media (${mediaType}) for out-of-card delivery: ${url}`,
+                );
                 // Collect non-image attachments for later delivery
                 if (mediaType === "voice" || mediaType === "video" || mediaType === "file") {
                   pendingNonImageMedia.push({ url, type: mediaType });
@@ -548,7 +580,11 @@ export function createCardReplyStrategy(
             const normalizedFinal = await applySplitTextToTimeline(rewrittenFinalText, {
               answerHandling: "capture",
             });
-            if (isFirstFinalDelivery && !normalizedFinal.answerText && !normalizedFinal.reasoningText) {
+            if (
+              isFirstFinalDelivery &&
+              !normalizedFinal.answerText &&
+              !normalizedFinal.reasoningText
+            ) {
               finalTextForFallback = rewrittenFinalText;
             }
             await flushPendingReasoning();
@@ -560,7 +596,9 @@ export function createCardReplyStrategy(
       // ---- tool: append to card ----
       if (payload.kind === "tool") {
         if (controller.isFailed() || isCardInTerminalState(card.state)) {
-          log?.debug?.("[DingTalk] Card failed, skipping tool result (will send full reply on final)");
+          log?.debug?.(
+            "[DingTalk] Card failed, skipping tool result (will send full reply on final)",
+          );
           return;
         }
         await flushPendingReasoning();
@@ -599,9 +637,14 @@ export function createCardReplyStrategy(
           }
           try {
             const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
-            const mediaType = resolveOutboundMediaType({ mediaPath: prepared.path, asVoice: false });
+            const mediaType = resolveOutboundMediaType({
+              mediaPath: prepared.path,
+              asVoice: false,
+            });
             if (mediaType !== "image") {
-              log?.debug?.(`[DingTalk][Card] Deferring non-image media (${mediaType}) for out-of-card delivery: ${url}`);
+              log?.debug?.(
+                `[DingTalk][Card] Deferring non-image media (${mediaType}) for out-of-card delivery: ${url}`,
+              );
               pendingNonImageMedia.push({ url, type: mediaType });
               await prepared.cleanup?.();
               continue;
@@ -621,13 +664,14 @@ export function createCardReplyStrategy(
     },
 
     async finalize(): Promise<void> {
+      await taskProgressController.dispose();
       log?.info?.(
         `[DingTalk][Finalize] Step 5 entry — ` +
-        `cardState=${card.state ?? "N/A"} ` +
-        `controllerFailed=${controller.isFailed()} ` +
-        `finalTextForFallback="${(finalTextForFallback ?? "").slice(0, 80)}" ` +
-        `lastAnswer="${(controller.getLastAnswerContent() ?? "").slice(0, 80)}" ` +
-        `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
+          `cardState=${card.state ?? "N/A"} ` +
+          `controllerFailed=${controller.isFailed()} ` +
+          `finalTextForFallback="${(finalTextForFallback ?? "").slice(0, 80)}" ` +
+          `lastAnswer="${(controller.getLastAnswerContent() ?? "").slice(0, 80)}" ` +
+          `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
       );
 
       if (isStopRequested?.()) {
@@ -645,14 +689,15 @@ export function createCardReplyStrategy(
         // deliver it as a markdown fallback so the user sees the final result.
         // The user may see partial overlap with the frozen card's content, but
         // delivering the full answer is preferred over silence.
-        const recoveryText = getRenderedTimeline({ preferFinalAnswer: true })
-          || finalTextForFallback
-          || controller.getLastAnswerContent()
-          || controller.getLastContent();
+        const recoveryText =
+          getRenderedTimeline({ preferFinalAnswer: true }) ||
+          finalTextForFallback ||
+          controller.getLastAnswerContent() ||
+          controller.getLastContent();
         if (recoveryText) {
           log?.info?.(
             `[DingTalk][Finalize] Card already FINISHED — sending markdown fallback for session-recovery content ` +
-            `len=${recoveryText.length} preview="${recoveryText.slice(0, 80)}"`,
+              `len=${recoveryText.length} preview="${recoveryText.slice(0, 80)}"`,
           );
           const sendResult = await sendMessage(ctx.config, ctx.to, recoveryText, {
             sessionWebhook: ctx.sessionWebhook,
@@ -690,9 +735,10 @@ export function createCardReplyStrategy(
 
       // Card failed -> markdown fallback (bypass sendMessage to avoid duplicate card).
       if (card.state === AICardStatus.FAILED || controller.isFailed()) {
-        const fallbackText = getRenderedTimeline({ preferFinalAnswer: true })
-          || controller.getLastAnswerContent()
-          || DEFAULT_CARD_FAILED_MESSAGE;
+        const fallbackText =
+          getRenderedTimeline({ preferFinalAnswer: true }) ||
+          controller.getLastAnswerContent() ||
+          DEFAULT_CARD_FAILED_MESSAGE;
         if (fallbackText) {
           log?.debug?.("[DingTalk] Card failed during streaming, sending markdown fallback");
           const sendResult = await sendMessage(ctx.config, ctx.to, fallbackText, {
@@ -727,38 +773,48 @@ export function createCardReplyStrategy(
         await controller.waitForInFlight();
 
         // Prepare finalize options for single instances API call
-        const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
+        const fallbackAnswer =
+          finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
         const blockListJson = controller.getRenderedBlocks({
           fallbackAnswer,
           overrideAnswer: finalTextForFallback,
         });
-        const content = controller.getRenderedContent({
-          fallbackAnswer,
-          overrideAnswer: finalTextForFallback,
-        }) || fallbackAnswer || EMPTY_FINAL_REPLY;
+        const content =
+          controller.getRenderedContent({
+            fallbackAnswer,
+            overrideAnswer: finalTextForFallback,
+          }) ||
+          fallbackAnswer ||
+          EMPTY_FINAL_REPLY;
 
         controller.stop();
         log?.info?.(
           `[DingTalk][Finalize] Calling commitAICardBlocks — ` +
-          `blockListLen=${blockListJson.length} contentLen=${content.length} ` +
-          `source=${finalTextForFallback ? "final.payload" : controller.getFinalAnswerContent() ? "timeline.answer" : sawFinalDelivery ? "timeline.fileOnly" : "fallbackDone"} ` +
-          `preview="${content.slice(0, 120)}"`,
+            `blockListLen=${blockListJson.length} contentLen=${content.length} ` +
+            `source=${finalTextForFallback ? "final.payload" : controller.getFinalAnswerContent() ? "timeline.answer" : sawFinalDelivery ? "timeline.fileOnly" : "fallbackDone"} ` +
+            `preview="${content.slice(0, 120)}"`,
         );
 
         // Build statusLine for card template
         const statusLine = buildStatusLine();
 
-        await commitAICardBlocks(card, {
-          blockListJson,
-          content,
-          statusLine,
-          quotedRef: ctx.replyQuotedRef,
-        }, log);
+        await commitAICardBlocks(
+          card,
+          {
+            blockListJson,
+            content,
+            statusLine,
+            quotedRef: ctx.replyQuotedRef,
+          },
+          log,
+        );
 
         // Send deferred non-image attachments after card finalize
         // Use sessionWebhook for reply-session semantics; fallback to proactive if unavailable.
         if (pendingNonImageMedia.length > 0) {
-          log?.debug?.(`[DingTalk][Card] Sending ${pendingNonImageMedia.length} deferred non-image attachments`);
+          log?.debug?.(
+            `[DingTalk][Card] Sending ${pendingNonImageMedia.length} deferred non-image attachments`,
+          );
           for (const { url, type } of pendingNonImageMedia) {
             try {
               const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
@@ -775,7 +831,9 @@ export function createCardReplyStrategy(
                   storePath: ctx.storePath,
                 });
                 if (!sendResult.ok) {
-                  log?.warn?.(`[DingTalk][Card] Deferred media session send failed: ${sendResult.error || "unknown"}`);
+                  log?.warn?.(
+                    `[DingTalk][Card] Deferred media session send failed: ${sendResult.error || "unknown"}`,
+                  );
                 }
               } else {
                 // Fallback: proactive send when no reply session available
@@ -784,7 +842,9 @@ export function createCardReplyStrategy(
                   accountId: ctx.accountId,
                 });
                 if (!result.ok) {
-                  log?.warn?.(`[DingTalk][Card] Deferred media proactive send failed: ${result.error || "unknown"}`);
+                  log?.warn?.(
+                    `[DingTalk][Card] Deferred media proactive send failed: ${result.error || "unknown"}`,
+                  );
                 }
               }
 
@@ -832,6 +892,7 @@ export function createCardReplyStrategy(
     },
 
     async abort(_error: Error): Promise<void> {
+      await taskProgressController.dispose();
       lifecycleState = "sealed";
       if (card.accountId && card.conversationId) {
         clearRuns(ctx.taskMeta?.runIds);
@@ -842,22 +903,38 @@ export function createCardReplyStrategy(
         try {
           // For V2 template, finalize via instances API
           const errorBlockListJson = JSON.stringify([{ type: 0, markdown: "❌ 处理失败" }]);
-          await commitAICardBlocks(card, {
-            blockListJson: errorBlockListJson,
-            content: "❌ 处理失败",
-          }, log);
+          await commitAICardBlocks(
+            card,
+            {
+              blockListJson: errorBlockListJson,
+              content: "❌ 处理失败",
+            },
+            log,
+          );
         } catch (cardCloseErr: unknown) {
-          log?.debug?.(`[DingTalk] Failed to finalize card after dispatch error: ${(cardCloseErr as Error).message}`);
+          log?.debug?.(
+            `[DingTalk] Failed to finalize card after dispatch error: ${(cardCloseErr as Error).message}`,
+          );
           card.state = AICardStatus.FAILED;
           card.lastUpdated = Date.now();
         }
       }
     },
 
+    async dispose(): Promise<void> {
+      // Release the progress heartbeat/subscription even when this strategy is
+      // dropped without finalize (for example ask-user question-card takeover).
+      // This path never commits the card, so a progress-only card must also
+      // clear its remote block list instead of leaving a live-looking card.
+      await taskProgressController.dispose({ clearRemoteWhenEmpty: true });
+    },
+
     getFinalText(): string | undefined {
-      return finalTextForFallback
-        || controller.getFinalAnswerContent()
-        || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
+      return (
+        finalTextForFallback ||
+        controller.getFinalAnswerContent() ||
+        (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined)
+      );
     },
   };
 }

package/src/{reply-strategy-markdown.ts → messaging/reply-strategy-markdown.ts}

@@ -7,7 +7,7 @@
  */
 
 import path from "node:path";
-import { resolveRelativePath } from "./config";
+import { resolveRelativePath } from "../platform/config";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import type {
   DeliverPayload,
@@ -90,7 +90,9 @@ export function createMarkdownReplyStrategy(ctx: ReplyStrategyContext): ReplyStr
     sentVisibleContent = true;
   };
 
-  const prepareAnswerSuffix = (text: string | undefined): {
+  const prepareAnswerSuffix = (
+    text: string | undefined,
+  ): {
     text: string;
     markSent: () => void;
   } | null => {
@@ -272,6 +274,10 @@ export function createMarkdownReplyStrategy(ctx: ReplyStrategyContext): ReplyStr
       // Nothing to clean up.
     },
 
+    async dispose(): Promise<void> {
+      // Markdown delivery owns no timers or subscriptions.
+    },
+
     getFinalText(): string | undefined {
       return finalText || activeAnswerText || undefined;
     },

package/src/{reply-strategy-types.ts → messaging/reply-strategy-types.ts}

@@ -7,7 +7,8 @@
  */
 
 import type { GetReplyOptions } from "openclaw/plugin-sdk/reply-runtime";
-import type { DingTalkConfig, Logger, QuotedRef } from "./types";
+import type { RuntimeEventsSurface } from "../platform/runtime-events";
+import type { DingTalkConfig, Logger, QuotedRef } from "../platform/types";
 
 // ---- Internal helper type ----
 
@@ -57,6 +58,14 @@ export interface ReplyStrategy {
   /** Called when dispatch throws an error. */
   abort(error: Error): Promise<void>;
 
+  /**
+   * Release strategy-owned resources (timers, event subscriptions) without
+   * touching the delivery surface. Idempotent, and safe to call after
+   * `finalize()`/`abort()`. Callers must invoke this even on early-return
+   * paths so a strategy that never finalized cannot leak.
+   */
+  dispose(): Promise<void>;
+
   /** Last known final text (for external consumers such as logging). */
   getFinalText(): string | undefined;
 }
@@ -94,4 +103,5 @@ export interface ReplyStrategyContext {
   isStopRequested?: () => boolean;
   inboundText?: string;
   taskMeta?: TaskMeta;
+  runtimeEvents?: RuntimeEventsSurface;
 }

package/src/{reply-strategy-with-reaction.ts → messaging/reply-strategy-with-reaction.ts}

@@ -24,8 +24,8 @@
  * concurrently. The `sessionFilter` parameter is required for this reason.
  */
 
+import type { DingTalkConfig, Logger } from "../platform/types";
 import type { DeliverPayload, ReplyOptions, ReplyStrategy } from "./reply-strategy-types";
-import type { DingTalkConfig, Logger } from "./types";
 
 const TOOL_REACTION_SILENCE_MS = 55_000;
 const TOOL_HEARTBEAT_INTERVAL_MS = 60_000;
@@ -183,6 +183,11 @@ export function withDynamicReaction(
       await inner.abort(_error);
     },
 
+    async dispose(): Promise<void> {
+      await dispose();
+      await inner.dispose();
+    },
+
     getFinalText(): string | undefined {
       return inner.getFinalText();
     },

package/src/{reply-strategy.ts → messaging/reply-strategy.ts}

@@ -5,10 +5,10 @@
  * strategy implementations. Type definitions live in reply-strategy-types.ts.
  */
 
-import type { AICardInstance } from "./types";
-import type { ReplyStrategy, ReplyStrategyContext } from "./reply-strategy-types";
+import type { AICardInstance } from "../platform/types";
 import { createCardReplyStrategy } from "./reply-strategy-card";
 import { createMarkdownReplyStrategy } from "./reply-strategy-markdown";
+import type { ReplyStrategy, ReplyStrategyContext } from "./reply-strategy-types";
 
 // Re-export all types so existing consumers that import from "./reply-strategy"
 // continue to work without changes beyond the ones we explicitly migrate.