@soimy/dingtalk 3.6.9 → 3.6.11

package/dist/src/types.d.ts

@@ -8,7 +8,7 @@
  * - Media files and streams
  * - Session and token management
  */
-import type { ChannelAccountSnapshot as SDKChannelAccountSnapshot, ChannelGatewayContext as SDKChannelGatewayContext, ChannelLogSink as SDKChannelLogSink } from "openclaw/plugin-sdk/channel-runtime";
+import type { ChannelAccountSnapshot as SDKChannelAccountSnapshot, ChannelGatewayContext as SDKChannelGatewayContext, ChannelLogSink as SDKChannelLogSink } from "openclaw/plugin-sdk/channel-contract";
 import type { ChannelPlugin as SDKChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
 import type { SecretInput } from "./secret-input";
@@ -769,4 +769,3 @@ export type CardBlock = {
     mediaId: string;
     text?: string;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/src/utils.d.ts

@@ -51,4 +51,3 @@ export declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: Retr
  */
 export declare function getCurrentTimestamp(): number;
 export {};
-//# sourceMappingURL=utils.d.ts.map

package/index.ts

@@ -1,4 +1,8 @@
-import { defineChannelPluginEntry, type OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import {
+  defineChannelPluginEntry,
+  type OpenClawPluginApi,
+  type OpenClawPluginDefinition,
+} from "openclaw/plugin-sdk/core";
 import { readStringParam } from "openclaw/plugin-sdk/param-readers";
 import { getAccessToken } from "./src/auth";
 import { registerDingTalkAskUserQuestionTool } from "./src/card/ask-user-question";
@@ -311,7 +315,7 @@ const dingtalkEntry = defineChannelPluginEntry({
   },
 });
 
-export default {
+const pluginDefinition: OpenClawPluginDefinition = {
   ...dingtalkEntry,
   register(api: OpenClawPluginApi) {
     const registrationMode = api.registrationMode as string | undefined;
@@ -325,3 +329,5 @@ export default {
     dingtalkEntry.register(api);
   },
 };
+
+export default pluginDefinition;

package/openclaw.plugin.json

@@ -1,5 +1,6 @@
 {
   "id": "dingtalk",
+  "name": "DingTalk",
   "channels": ["dingtalk"],
   "contracts": {
     "tools": ["dingtalk_ask_user_question"]
@@ -62,7 +63,7 @@
                 }
               }
             ],
-            "description": "DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. Supports SecretInput references such as env/file. Security boundary: file reads the configured local path; use file only with trusted plugin configuration."
+            "description": "DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. Supports env/file SecretInput references resolved by configured OpenClaw secret providers."
           },
           "dmPolicy": {
             "type": "string",
@@ -368,7 +369,7 @@
                       }
                     }
                   ],
-                  "description": "DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. Supports SecretInput references such as env/file. Security boundary: file reads the configured local path; use file only with trusted plugin configuration."
+                  "description": "DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. Supports env/file SecretInput references resolved by configured OpenClaw secret providers."
                 },
                 "dmPolicy": {
                   "type": "string",
@@ -654,7 +655,7 @@
         },
         "clientSecret": {
           "label": "DingTalk Client Secret",
-          "help": "App Secret used to obtain DingTalk access tokens. SecretInput file references are for trusted plugin configuration because file reads a local path.",
+          "help": "App Secret used to obtain DingTalk access tokens. SecretInput references are resolved by configured OpenClaw secret providers.",
           "sensitive": true
         },
         "dmPolicy": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.6.9",
+  "version": "3.6.11",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -20,9 +20,7 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/**/*.js.map",
     "dist/**/*.d.ts",
-    "dist/**/*.d.ts.map",
     "index.ts",
     "src/**/*.ts",
     "docs/assets/dingtalk-ask-user-card-template.json",
@@ -31,6 +29,9 @@
     "LICENSE"
   ],
   "type": "module",
+  "engines": {
+    "node": ">=22.22.3 <23 || >=24.15.0 <25 || >=25.9.0"
+  },
   "packageManager": "pnpm@10.33.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -69,12 +70,13 @@
     "form-data": "^4.0.0",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^25.2.0",
     "@vitest/coverage-v8": "^3.2.4",
     "esbuild": "^0.27.3",
+    "openclaw": "2026.7.1-2",
     "oxfmt": "0.34.0",
     "oxlint": "1.49.0",
     "oxlint-tsgolint": "0.18.1",
@@ -83,7 +85,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.3.28"
+    "openclaw": ">=2026.7.1-2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -92,10 +94,10 @@
   },
   "openclaw": {
     "compat": {
-      "pluginApi": ">=2026.3.28"
+      "pluginApi": ">=2026.7.1-2"
     },
     "build": {
-      "openclawVersion": "2026.3.28"
+      "openclawVersion": "2026.7.1-2"
     },
     "extensions": [
       "./index.ts"
@@ -121,7 +123,7 @@
       ]
     },
     "install": {
-      "minHostVersion": ">=2026.3.28",
+      "minHostVersion": ">=2026.7.1-2",
       "npmSpec": "@soimy/dingtalk",
       "localPath": ".",
       "defaultChoice": "npm"

package/src/channel.ts

@@ -1,6 +1,7 @@
-import { buildChannelConfigSchema, type OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { buildJsonChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import pluginManifest from "../openclaw.plugin.json";
 import { getConfig, isConfigured, mergeAccountWithDefaults, resolveGroupConfig } from "./config";
-import { DingTalkConfigSchema } from "./config-schema.js";
 import {
   CHANNEL_INFLIGHT_NAMESPACE_POLICY,
   createDingTalkGateway,
@@ -29,7 +30,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     blurb: "钉钉企业内部机器人，使用 Stream 模式，无需公网 IP。",
     aliases: ["dd", "ding"],
   },
-  configSchema: buildChannelConfigSchema(DingTalkConfigSchema),
+  configSchema: buildJsonChannelConfigSchema(pluginManifest.channelConfigs.dingtalk.schema),
   setup: dingtalkSetupAdapter,
   setupWizard: dingtalkSetupWizard,
   capabilities: {

package/src/gateway/channel-gateway.ts

@@ -1,4 +1,5 @@
 import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
+import { listAgentIds } from "openclaw/plugin-sdk/agent-runtime";
 import { analyzeCardCallback } from "../card-callback-service";
 import { finalizeActiveCardsForAccount, recoverPendingCardsForAccount } from "../card-service";
 import { recoverAskUserQuestionsForAccount } from "../card/ask-user-question";
@@ -13,9 +14,14 @@ import {
 } from "../feedback-learning-service";
 import { handleDingTalkMessage } from "../inbound-handler";
 import { setCurrentLogger } from "../logger-context";
-import { preloadPeerIdsFromSessions } from "../peer-id-registry";
+import { registerPeerId } from "../peer-id-registry";
 import { getDingTalkRuntime } from "../runtime";
 import { sendProactiveTextOrMarkdown } from "../send-service";
+import {
+  listKnownGroupTargets,
+  listKnownUserTargets,
+  upsertObservedGroupTarget,
+} from "../targeting/target-directory-store";
 import type {
   ConnectionManagerConfig,
   DingTalkChannelPlugin,
@@ -180,6 +186,66 @@ export function createDingTalkGateway(): NonNullable<DingTalkChannelPlugin["gate
         debug: config.debug,
         baseLog: ctx.log,
       });
+      try {
+        const knownGroupIds = new Set<string>();
+        for (const group of listKnownGroupTargets({
+          storePath: accountStorePath,
+          accountId: account.accountId,
+        })) {
+          registerPeerId(group.conversationId);
+          knownGroupIds.add(group.conversationId.toLowerCase());
+        }
+        const runtime = getDingTalkRuntime();
+        for (const agentId of listAgentIds(cfg)) {
+          const sessionStorePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
+            agentId,
+          });
+          for (const { entry } of runtime.agent.session.listSessionEntries({
+            agentId,
+            storePath: sessionStorePath,
+            readConsistency: "latest",
+          })) {
+            const isDingTalkSession = [
+              entry.lastChannel,
+              entry.channel,
+              entry.origin?.provider,
+              entry.origin?.surface,
+            ].some((value) => value === "dingtalk");
+            const sessionAccountId = entry.lastAccountId || entry.origin?.accountId;
+            if (!isDingTalkSession || sessionAccountId !== account.accountId) {
+              continue;
+            }
+            for (const peerId of [entry.lastTo, entry.origin?.from, entry.origin?.to]) {
+              if (typeof peerId !== "string" || !peerId.startsWith("cid")) {
+                continue;
+              }
+              registerPeerId(peerId);
+              const normalizedPeerId = peerId.toLowerCase();
+              if (!knownGroupIds.has(normalizedPeerId)) {
+                upsertObservedGroupTarget({
+                  storePath: accountStorePath,
+                  accountId: account.accountId,
+                  conversationId: peerId,
+                  seenAt: entry.updatedAt,
+                });
+                knownGroupIds.add(normalizedPeerId);
+              }
+            }
+          }
+        }
+        for (const user of listKnownUserTargets({
+          storePath: accountStorePath,
+          accountId: account.accountId,
+        })) {
+          registerPeerId(user.canonicalUserId);
+          registerPeerId(user.staffId || "");
+          registerPeerId(user.senderId);
+        }
+      } catch (err: unknown) {
+        pluginLog?.warn?.(
+          `[${account.accountId}] Failed to restore peer IDs: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
       // Stream credentials are resolved once per account start. If a file
       // SecretInput rotates, restart the gateway/account so reconnects use the
       // new secret.
@@ -188,9 +254,6 @@ export function createDingTalkGateway(): NonNullable<DingTalkChannelPlugin["gate
 
       pluginLog?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
 
-      preloadPeerIdsFromSessions();
-      pluginLog?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
-
       cleanupOrphanedTempFiles(pluginLog);
       try {
         const recovered = await recoverPendingCardsForAccount(

package/src/inbound-handler.ts

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import * as path from "node:path";
+import { formatInboundEnvelope } from "openclaw/plugin-sdk/channel-inbound";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
-import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
+import { parseInlineDirectives } from "./messaging/inline-directives";
 import { normalizeAllowFrom, isSenderAllowed, resolveGroupAccess } from "./access-control";
 import { classifyAckReactionEmoji } from "./ack-reaction-classifier";
 import { attachNativeAckReaction } from "./ack-reaction-service";
@@ -1792,7 +1793,10 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     const groupMembers = !isDirect ? formatGroupMembers(storePath, groupId) : undefined;
 
     const fromLabel = isDirect ? `${senderName} (${senderId})` : `${groupName} - ${senderName}`;
-    const body = rt.channel.reply.formatInboundEnvelope({
+    // `rt.channel.reply.formatInboundEnvelope` was removed from the runtime
+    // facade in OpenClaw 2026.8.x; the helper is still exported from the
+    // `channel-inbound` SDK subpath.
+    const body = formatInboundEnvelope({
       channel: "DingTalk",
       from: fromLabel,
       timestamp: data.createAt,

package/src/messaging/channel-actions.ts

@@ -55,12 +55,9 @@ function describeDingTalkMessageTool(cfg: OpenClawConfig) {
   if (!configured && !(config.accounts && Object.keys(config.accounts).length > 0)) {
     return { actions: [], capabilities: [], schema: null };
   }
-  const hasCardMode =
-    config.messageType === "card" ||
-    (config.accounts && Object.values(config.accounts).some((account) => account?.messageType === "card"));
   return {
     actions: ["send"] as const,
-    capabilities: hasCardMode ? (["cards"] as const) : [],
+    capabilities: [],
     schema: null,
   };
 }

package/src/messaging/inline-directives.ts

@@ -0,0 +1,342 @@
+/**
+ * Inline directive parsing (local implementation).
+ *
+ * OpenClaw retired the `openclaw/plugin-sdk/text-runtime` subpath in
+ * 2026.8.x (docs/plugins/sdk-migration.md: "The August 15 compatibility
+ * subpaths ... `text-runtime` ... were retired early"). Its replacement
+ * `openclaw/plugin-sdk/text-chunking` only re-exports the directive-tag
+ * *stripping* helpers and the `InlineDirectiveParseResult` type - not
+ * `parseInlineDirectives` itself.
+ *
+ * This module reproduces the previous host behaviour inside the plugin so no
+ * removed SDK internals are imported. Code-region awareness (fenced,
+ * indented, and inline code) is sourced from the public SDK helpers
+ * `findCodeRegions` / `isInsideCode` (available since 2026.7.1-2), plus a
+ * lenient indented-block fallback matching the host whitespace normalizer so
+ * directives inside code are never treated as real voice/reply commands.
+ *
+ * The shipped 2026.7.1-2 SDK `findCodeRegions` is a simplified heuristic: it
+ * pairs backtick runs of different lengths, lets shorter fences close longer
+ * ones, treats escaped backticks as real delimiters, and pairs backticks
+ * inside indented code with prose. `findDelimiterCodeRegions` therefore layers
+ * a CommonMark-style fence/inline-code supplement over the SDK regions (union,
+ * conservative: in doubt the text stays literal) so protection holds on every
+ * supported host. Ponytail: remove the supplement once the minimum host is
+ * 2026.8+ and its SDK regions are verified to cover these cases.
+ */
+
+import { findCodeRegions, isInsideCode, type CodeRegion } from "openclaw/plugin-sdk/text-chunking";
+
+const AUDIO_TAG_RE = /\[\[\s*audio_as_voice\s*\]\]/gi;
+const REPLY_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+const MAX_REPLY_DIRECTIVE_ID_LENGTH = 256;
+const BLOCK_SENTINEL_SEED = "\uE000";
+/** Lenient indented-code-block lines (4 spaces or tab), same rule as the host whitespace normalizer. */
+const INDENTED_CODE_LINE_RE = /(?:^|\n)((?: {4}|\t)[^\n]*)(?:\n(?: {4}|\t)[^\n]*)*/g;
+
+export type ParseInlineDirectivesOptions = {
+  currentMessageId?: string;
+  stripAudioTag?: boolean;
+  stripReplyTags?: boolean;
+};
+
+export type InlineDirectiveParseResult = {
+  text: string;
+  audioAsVoice: boolean;
+  replyToId?: string;
+  replyToExplicitId?: string;
+  replyToCurrent: boolean;
+  hasAudioTag: boolean;
+  hasReplyTag: boolean;
+};
+
+function normalizeOptionalString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+/**
+ * CommonMark code regions (fenced / indented / inline) from the SDK, extended
+ * with a lenient indented-block fallback for lines indented by 4 spaces or a
+ * tab that follow a paragraph without a blank separator (the host normalizer
+ * protects those too).
+ */
+function resolveCodeRegions(text: string): CodeRegion[] {
+  const indentedRegions: CodeRegion[] = [];
+  const indentRe = new RegExp(INDENTED_CODE_LINE_RE.source, "g");
+  let match: RegExpExecArray | null;
+  while ((match = indentRe.exec(text)) !== null) {
+    const start = match.index + (match[0].charCodeAt(0) === 10 ? 1 : 0);
+    indentedRegions.push({ start, end: match.index + match[0].length });
+  }
+  const sdkRegions = findCodeRegions(text).filter(
+    (region) =>
+      (text[region.start] !== "`" || !isEscaped(text, region.start)) &&
+      !indentedRegions.some(
+        (indented) => region.start >= indented.start && region.start < indented.end,
+      ),
+  );
+  const knownRegions = mergeCodeRegions([...sdkRegions, ...indentedRegions]);
+  return mergeCodeRegions([...knownRegions, ...findDelimiterCodeRegions(text, knownRegions)]);
+}
+
+function isEscaped(text: string, offset: number): boolean {
+  let slashes = 0;
+  for (let index = offset - 1; text[index] === "\\"; index--) {
+    slashes++;
+  }
+  return slashes % 2 === 1;
+}
+
+function isStrictlyInsideCode(offset: number, regions: CodeRegion[]): boolean {
+  return regions.some((region) => offset > region.start && offset < region.end);
+}
+
+// ponytail: small 2026.7.x delimiter supplement; delete when the minimum host is 2026.8+.
+function findDelimiterCodeRegions(text: string, knownRegions: CodeRegion[]): CodeRegion[] {
+  const regions: CodeRegion[] = [];
+  let match: RegExpExecArray | null;
+  const fences = /^( {0,3})(`{3,}|~{3,})[^\n]*(?:\n|$)/gm;
+  let open: { char: string; length: number; start: number } | undefined;
+  while ((match = fences.exec(text)) !== null) {
+    const delimiter = match[2];
+    if (!open) {
+      const suffix = match[0].slice(match[1].length + delimiter.length).trim();
+      if (
+        isStrictlyInsideCode(match.index, knownRegions) ||
+        (delimiter[0] === "`" && suffix.includes("`"))
+      ) {
+        continue;
+      }
+      open = { char: delimiter[0], length: delimiter.length, start: match.index };
+    } else if (
+      delimiter[0] === open.char &&
+      delimiter.length >= open.length &&
+      match[0].slice(match[1].length + delimiter.length).trim() === ""
+    ) {
+      regions.push({ start: open.start, end: fences.lastIndex });
+      open = undefined;
+    }
+  }
+  if (open) {
+    regions.push({ start: open.start, end: text.length });
+  }
+
+  const fencedRegions = [...regions];
+  const pendingTicks = new Map<number, number>();
+  const ticks = /`+/g;
+  while ((match = ticks.exec(text)) !== null) {
+    const length = match[0].length;
+    if (
+      isEscaped(text, match.index) ||
+      isInsideCode(match.index, fencedRegions) ||
+      (pendingTicks.get(length) === undefined && isStrictlyInsideCode(match.index, knownRegions))
+    ) {
+      continue;
+    }
+    const start = pendingTicks.get(length);
+    if (start === undefined) {
+      pendingTicks.set(length, match.index);
+      continue;
+    }
+    regions.push({ start, end: ticks.lastIndex });
+    for (const [pendingLength, pendingStart] of pendingTicks) {
+      if (pendingStart >= start) {
+        pendingTicks.delete(pendingLength);
+      }
+    }
+  }
+  return regions;
+}
+
+function mergeCodeRegions(regions: CodeRegion[]): CodeRegion[] {
+  if (regions.length <= 1) {
+    return regions;
+  }
+  const sorted = [...regions].toSorted((a, b) => a.start - b.start || a.end - b.end);
+  const merged: CodeRegion[] = [];
+  for (const region of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && region.start <= last.end) {
+      last.end = Math.max(last.end, region.end);
+    } else {
+      merged.push({ start: region.start, end: region.end });
+    }
+  }
+  return merged;
+}
+
+function createBlockSentinel(text: string): string {
+  let sentinel = BLOCK_SENTINEL_SEED;
+  while (text.includes(sentinel)) {
+    sentinel += BLOCK_SENTINEL_SEED;
+  }
+  return sentinel;
+}
+
+function normalizeDirectiveWhitespace(text: string, codeRegions: CodeRegion[] = []): string {
+  const blockSentinel = createBlockSentinel(text);
+  const blockPlaceholderRe = new RegExp(`${blockSentinel}(\\d+)${blockSentinel}`, "g");
+  const blocks: string[] = [];
+
+  let masked = "";
+  let cursor = 0;
+  for (const region of codeRegions) {
+    if (region.start < cursor) {
+      continue;
+    }
+    blocks.push(text.slice(region.start, region.end));
+    masked += `${text.slice(cursor, region.start)}${blockSentinel}${blocks.length - 1}${blockSentinel}`;
+    cursor = region.end;
+  }
+  masked += text.slice(cursor);
+
+  return masked
+    .replace(/\r\n/g, "\n")
+    .replace(/([^\s])[ \t]{2,}([^\s])/g, "$1 $2")
+    .replace(/^\n+/, "")
+    .replace(/^[ \t](?=\S)/, "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trimEnd()
+    .replace(blockPlaceholderRe, (_full, index: string) => blocks[Number(index)] ?? "");
+}
+
+function replacementPreservesWordBoundary(source: string, offset: number, length: number): string {
+  const before = source[offset - 1];
+  const after = source[offset + length];
+  return before && after && !/\s/u.test(before) && !/\s/u.test(after) ? " " : "";
+}
+
+function stripUnsafeReplyDirectiveChars(value: string): string {
+  const chars: string[] = [];
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    if (
+      (code >= 0 && code <= 31) ||
+      code === 127 ||
+      (code >= 128 && code <= 159) ||
+      ch === "[" ||
+      ch === "]"
+    ) {
+      continue;
+    }
+    chars.push(ch);
+  }
+  return chars.join("");
+}
+
+export function sanitizeReplyDirectiveId(rawReplyToId: string | undefined): string | undefined {
+  const trimmed = rawReplyToId?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const sanitized = stripUnsafeReplyDirectiveChars(trimmed).trim();
+  if (!sanitized) {
+    return undefined;
+  }
+  const chars = Array.from(sanitized);
+  if (chars.length > MAX_REPLY_DIRECTIVE_ID_LENGTH) {
+    return chars.slice(0, MAX_REPLY_DIRECTIVE_ID_LENGTH).join("");
+  }
+  return sanitized;
+}
+
+export function parseInlineDirectives(
+  text: string | undefined,
+  options: ParseInlineDirectivesOptions = {},
+): InlineDirectiveParseResult {
+  const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
+
+  if (!text) {
+    return {
+      text: "",
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false,
+    };
+  }
+
+  if (!text.includes("[[")) {
+    return {
+      text: normalizeDirectiveWhitespace(text, resolveCodeRegions(text)),
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false,
+    };
+  }
+
+  // Directives inside code regions are literal text: never voice/reply semantics.
+  // Stripping a tag shortens the string, so every pass re-derives regions from
+  // the text it actually runs against; offsets from an earlier pass are stale
+  // once a preceding tag has been removed.
+  const codeRegions = resolveCodeRegions(text);
+  let cleaned = text;
+  let audioAsVoice = false;
+  let hasAudioTag = false;
+  let hasReplyTag = false;
+  let sawCurrent = false;
+  let lastExplicitId: string | undefined;
+
+  cleaned = cleaned.replace(AUDIO_TAG_RE, (match: string, offset: number, source: string) => {
+    if (isInsideCode(offset, codeRegions)) {
+      return match;
+    }
+    audioAsVoice = true;
+    hasAudioTag = true;
+    return stripAudioTag ? replacementPreservesWordBoundary(source, offset, match.length) : match;
+  });
+  const codeRegionsAfterAudioStrip = resolveCodeRegions(cleaned);
+
+  cleaned = cleaned.replace(
+    REPLY_TAG_RE,
+    (match: string, idRaw: string | undefined, offset: number, source: string) => {
+      if (isInsideCode(offset, codeRegionsAfterAudioStrip)) {
+        return match;
+      }
+      hasReplyTag = true;
+      if (idRaw === undefined) {
+        sawCurrent = true;
+      } else {
+        const id = sanitizeReplyDirectiveId(idRaw);
+        if (id) {
+          lastExplicitId = id;
+        }
+      }
+      return stripReplyTags
+        ? replacementPreservesWordBoundary(source, offset, match.length)
+        : match;
+    },
+  );
+
+  // Early return when `[[...]]` matched no known directive: keep the original
+  // text untouched instead of running whitespace normalization.
+  if (!hasAudioTag && !hasReplyTag) {
+    return {
+      text,
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false,
+    };
+  }
+
+  cleaned = normalizeDirectiveWhitespace(cleaned, resolveCodeRegions(cleaned));
+  const replyToId =
+    lastExplicitId ?? (sawCurrent ? normalizeOptionalString(currentMessageId) : undefined);
+
+  return {
+    text: cleaned,
+    audioAsVoice,
+    replyToId,
+    replyToExplicitId: lastExplicitId,
+    replyToCurrent: sawCurrent,
+    hasAudioTag,
+    hasReplyTag,
+  };
+}