@openclaw/feishu 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/{monitor.account-F99J862T.js → monitor.account-Blbf2T6J.js}

@@ -1,16 +1,16 @@
 import { _ as normalizeCommentFileType, c as encodeQuery, d as isRecord$1, f as normalizeString, g as buildFeishuCommentTarget, h as requestFeishuApi, l as extractReplyText, m as readString, o as resolveFeishuAccount, p as parseCommentContentElements, s as resolveFeishuRuntimeAccount } from "./accounts-BDoGHJDk.js";
 import { i as resolveReceiveIdType } from "./targets-BUjQ1TcA.js";
-import { C as resolveFeishuGroupConfig, D as resolveFeishuReplyPolicy, M as createFeishuCardInteractionEnvelope, N as decodeFeishuCardAction, O as normalizeFeishuChatType$2, S as resolveFeishuDmIngressAccess, T as resolveFeishuGroupSenderActivationIngressAccess, b as hasExplicitFeishuGroupConfig, d as chunkFeishuPostMarkdown, f as materializeFeishuPostMarkdownSoftBreaks, j as buildFeishuCardActionTextFallback, k as resolveFeishuChatType, o as resolveFeishuCardTemplate, w as resolveFeishuGroupConversationIngressAccess, x as normalizeFeishuAllowEntry } from "./send-result-CPS7AozW.js";
+import { A as resolveFeishuChatType, C as resolveFeishuDmIngressAccess, E as resolveFeishuGroupSenderActivationIngressAccess, M as buildFeishuCardActionTextFallback, N as createFeishuCardInteractionEnvelope, O as resolveFeishuReplyPolicy, P as decodeFeishuCardAction, S as normalizeFeishuAllowEntry, T as resolveFeishuGroupConversationIngressAccess, d as chunkFeishuPostMarkdown, f as materializeFeishuPostMarkdownSoftBreaks, k as normalizeFeishuChatType$2, o as resolveFeishuCardTemplate, w as resolveFeishuGroupConfig, x as hasExplicitFeishuGroupConfig } from "./send-result-DfE5Fhz6.js";
 import { o as resolveConfiguredFeishuGroupSessionScope, t as buildFeishuConversationId } from "./conversation-id-BeJL-wq7.js";
+import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-87BmeMpj.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-BUC-R2Wi.js";
-import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-Bpe8ONK_.js";
+import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-BHv8WW9i.js";
 import { t as createFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
 import { createReplyPrefixContext, evaluateSupplementalContextVisibility, getSessionEntry, normalizeAgentId as normalizeAgentId$2, resolveChannelContextVisibilityMode } from "./runtime-api.js";
 import { t as readFeishuJsonResponse } from "./json-response-CheljwGr.js";
-import { _ as resolveFeishuIdentityEmoji, c as parsePostContent, d as isMentionForwardRequest, f as isFeishuGroupChatType, g as normalizeFeishuExternalKey, h as shouldSuppressFeishuTextForVoiceMedia, i as sendCardFeishu, l as extractMentionTargets, m as sendMediaFeishu, n as getMessageFeishu, o as sendMessageFeishu, p as saveMessageResourceFeishu, r as listFeishuThreadMessages, s as sendStructuredCardFeishu, u as isFeishuBroadcastMention } from "./send-CpnLYueT.js";
-import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-CAloGqgG.js";
-import { t as fetchBotIdentityForMonitor } from "./monitor.startup-DpZzunQn.js";
+import { _ as buildFeishuMediaFallbackText, c as parsePostContent, d as isMentionForwardRequest, f as isFeishuGroupChatType, g as normalizeFeishuExternalKey, h as shouldSuppressFeishuTextForVoiceMedia, i as sendCardFeishu, l as extractMentionTargets, m as sendMediaFeishu, n as getMessageFeishu, o as sendMessageFeishu, p as saveMessageResourceFeishu, r as listFeishuThreadMessages, s as sendStructuredCardFeishu, u as isFeishuBroadcastMention, v as resolveFeishuIdentityEmoji } from "./send-DcrXbqqA.js";
+import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-BgboTHIn.js";
+import { t as fetchBotIdentityForMonitor } from "./monitor.startup-Cy8NPGAX.js";
 import { createChannelMessageReplyPipeline, formatChannelProgressDraftLineForEntry, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelPreviewStreamMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingController, createChannelPairingController as createChannelPairingController$1 } from "openclaw/plugin-sdk/channel-pairing";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
@@ -22,20 +22,22 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { normalizeAccountId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
+import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import * as Lark from "@larksuiteoapi/node-sdk";
 import { WEBHOOK_ANOMALY_COUNTER_DEFAULTS, WEBHOOK_RATE_LIMIT_DEFAULTS, applyBasicWebhookRequestGuards, createFixedWindowRateLimiter, createWebhookAnomalyTracker, resolveRequestClientIp } from "openclaw/plugin-sdk/webhook-ingress";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
-import { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
+import { getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts, resolveTextChunksWithFallback, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
 import { resolvePinnedMainDmOwnerFromAllowlist, safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import * as crypto$1 from "node:crypto";
 import crypto, { createHash } from "node:crypto";
-import { buildChannelInboundEventContext, formatInboundMediaUnavailableText, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, formatAgentEnvelope, formatInboundMediaUnavailableText, recordChannelBotPairLoopAndCheckSuppression, resolveEnvelopeFormatOptions, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { createChannelReplayGuard } from "openclaw/plugin-sdk/persistent-dedupe";
 import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
-import { formatReasoningMessage } from "openclaw/plugin-sdk/agent-runtime";
+import { formatReasoningMessage, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
 import * as http from "node:http";
 import { installRequestBodyLimitGuard, readWebhookBodyOrReject } from "openclaw/plugin-sdk/webhook-request-guards";
@@ -478,10 +480,150 @@ async function resolveGroupName(params) {
 	return resolvedName;
 }
 //#endregion
+//#region extensions/feishu/src/bot-name.ts
+const POSITIVE_TTL_MS = 10 * 6e4;
+const NEGATIVE_TTL_MS = 6e4;
+const MAX_CACHE_ENTRIES = 5e3;
+const BREAKER_FAILURE_THRESHOLD = 10;
+const BREAKER_OPEN_MS = 60 * 6e4;
+const PERMISSION_BACKOFF_MS = 6e4;
+const REQUEST_TIMEOUT_MS = 1500;
+const cache = /* @__PURE__ */ new Map();
+const breakerByAccount = /* @__PURE__ */ new Map();
+const permissionBackoffUntilByAccount = /* @__PURE__ */ new Map();
+const inflight = /* @__PURE__ */ new Map();
+function resolveCacheKey(accountId, openId) {
+	return `${accountId}::${openId}`;
+}
+function readCache(key) {
+	const entry = cache.get(key);
+	if (!entry) return;
+	if (entry.expiresAt <= Date.now()) {
+		cache.delete(key);
+		return;
+	}
+	cache.delete(key);
+	cache.set(key, entry);
+	return entry;
+}
+function writeCache(key, entry) {
+	cache.delete(key);
+	cache.set(key, entry);
+	pruneMapToMaxSize(cache, MAX_CACHE_ENTRIES);
+}
+function isBreakerOpen(accountId) {
+	const state = breakerByAccount.get(accountId);
+	if (!state) return false;
+	if (state.openUntil > Date.now()) return true;
+	if (state.openUntil > 0) breakerByAccount.delete(accountId);
+	return false;
+}
+function recordFailure(accountId) {
+	const state = breakerByAccount.get(accountId) ?? {
+		failures: 0,
+		openUntil: 0
+	};
+	state.failures += 1;
+	if (state.failures >= BREAKER_FAILURE_THRESHOLD) {
+		state.failures = 0;
+		state.openUntil = Date.now() + BREAKER_OPEN_MS;
+	}
+	breakerByAccount.set(accountId, state);
+}
+function recordSuccess(accountId) {
+	breakerByAccount.delete(accountId);
+}
+function readFeishuErrorCode(error) {
+	if (!error || typeof error !== "object") return;
+	const data = error.response?.data;
+	if (!data || typeof data !== "object") return;
+	const code = data.code;
+	return typeof code === "number" ? code : void 0;
+}
+async function requestBotName(params) {
+	const { account, openId, log } = params;
+	const query = new URLSearchParams({ bot_ids: openId });
+	try {
+		const response = await createFeishuClient(account).request({
+			method: "GET",
+			url: `/open-apis/bot/v3/bots/basic_batch?${query.toString()}`,
+			timeout: REQUEST_TIMEOUT_MS
+		});
+		const code = response.code ?? 0;
+		if (code === 0) return response;
+		if (code === 99991672) {
+			log(`feishu[${account.accountId}]: bot.basic_info scope not granted`);
+			return "permission";
+		}
+		log(`feishu[${account.accountId}]: bot name lookup failed (code=${code})`);
+		return "failure";
+	} catch (error) {
+		if (readFeishuErrorCode(error) === 99991672) {
+			log(`feishu[${account.accountId}]: bot.basic_info scope not granted`);
+			return "permission";
+		}
+		log(`feishu[${account.accountId}]: bot name lookup failed: ${String(error)}`);
+		return "failure";
+	}
+}
+async function resolveUncachedBotName(params) {
+	const { account, openId, cacheKey, log } = params;
+	if (isBreakerOpen(account.accountId)) {
+		log(`feishu[${account.accountId}]: bot name lookup skipped (breaker open)`);
+		return;
+	}
+	const result = await requestBotName({
+		account,
+		openId,
+		log
+	});
+	if (result === "permission") {
+		permissionBackoffUntilByAccount.set(account.accountId, Date.now() + PERMISSION_BACKOFF_MS);
+		return;
+	}
+	if (result === "failure") {
+		recordFailure(account.accountId);
+		return;
+	}
+	recordSuccess(account.accountId);
+	const name = result.data?.bots?.[openId]?.name?.trim();
+	writeCache(cacheKey, {
+		...name ? { name } : {},
+		expiresAt: Date.now() + (name ? POSITIVE_TTL_MS : NEGATIVE_TTL_MS)
+	});
+	return name;
+}
+async function resolveFeishuBotName(params) {
+	const openId = params.openId.trim();
+	if (!params.account.configured || !openId) return;
+	const permissionBackoffUntil = permissionBackoffUntilByAccount.get(params.account.accountId);
+	if (permissionBackoffUntil !== void 0) {
+		if (permissionBackoffUntil > Date.now()) return;
+		permissionBackoffUntilByAccount.delete(params.account.accountId);
+	}
+	const key = resolveCacheKey(params.account.accountId, openId);
+	const cached = readCache(key);
+	if (cached) return cached.name;
+	const pending = inflight.get(key);
+	if (pending) return pending;
+	const lookup = resolveUncachedBotName({
+		...params,
+		openId,
+		cacheKey: key
+	});
+	inflight.set(key, lookup);
+	try {
+		return await lookup;
+	} finally {
+		inflight.delete(key);
+	}
+}
+//#endregion
 //#region extensions/feishu/src/bot-sender-name.ts
 const IGNORED_PERMISSION_SCOPE_TOKENS = ["contact:contact.base:readonly"];
 const FEISHU_SCOPE_CORRECTIONS = { "contact:contact.base:readonly": "contact:user.base:readonly" };
 const SENDER_NAME_TTL_MS = 600 * 1e3;
+const SENDER_NAME_CACHE_MAX_SIZE = 500;
 const senderNameCache = /* @__PURE__ */ new Map();
 function correctFeishuScopeInUrl(url) {
 	let corrected = url;
@@ -535,10 +677,13 @@ async function resolveFeishuSenderName(params) {
 		const name = user?.name ?? user?.nickname ?? user?.en_name;
 		if (name) {
 			const expireAt = resolveExpiresAtMsFromDurationMs(SENDER_NAME_TTL_MS);
-			if (expireAt !== void 0) senderNameCache.set(normalizedSenderId, {
-				name,
-				expireAt
-			});
+			if (expireAt !== void 0) {
+				senderNameCache.set(normalizedSenderId, {
+					name,
+					expireAt
+				});
+				pruneMapToMaxSize(senderNameCache, SENDER_NAME_CACHE_MAX_SIZE);
+			}
 			return { name };
 		}
 		return {};
@@ -563,12 +708,15 @@ const DEDUP_TTL_MS = 1440 * 60 * 1e3;
 const MEMORY_MAX_SIZE = 1e3;
 const STORE_MAX_ENTRIES = 1e4;
 function createFeishuDedupeGuard() {
-	return createClaimableDedupe({
-		pluginId: "feishu",
-		namespacePrefix: DEDUPE_NAMESPACE_PREFIX,
-		ttlMs: DEDUP_TTL_MS,
-		memoryMaxSize: MEMORY_MAX_SIZE,
-		stateMaxEntries: STORE_MAX_ENTRIES
+	return createChannelReplayGuard({
+		dedupe: {
+			pluginId: "feishu",
+			namespacePrefix: DEDUPE_NAMESPACE_PREFIX,
+			ttlMs: DEDUP_TTL_MS,
+			memoryMaxSize: MEMORY_MAX_SIZE,
+			stateMaxEntries: STORE_MAX_ENTRIES
+		},
+		buildReplayKey: (messageId) => messageId
 	});
 }
 const feishuDedupeState = {
@@ -590,18 +738,13 @@ function dedupeOptions(namespace, log) {
 }
 /**
 * Claims a dedupe key for exclusive handling. Duplicate (already committed)
-* and in-flight keys are reported; blank keys fail open as claimed so an
+* and in-flight keys are reported; blank keys fail open as invalid so an
 * unidentifiable event is never suppressed.
 */
 async function claimUnprocessedFeishuMessage(params) {
-	const key = dedupeKey(params.messageId);
-	if (!key) return "claimed";
-	return (await feishuDedupeState.guard.claim(key, dedupeOptions(params.namespace, params.log))).kind;
-}
-/** Drops an uncommitted claim so a failed handler can retry the message. */
-function releaseFeishuMessageProcessing(messageId, namespace = "global") {
-	const key = dedupeKey(messageId);
-	if (key) feishuDedupeState.guard.release(key, { namespace });
+	const claim = await feishuDedupeState.guard.claim(params.messageId, dedupeOptions(params.namespace, params.log));
+	if (claim.kind === "inflight") return { kind: "inflight" };
+	return claim;
 }
 /**
 * Claims (unless the caller already holds the claim) and commits a message.
@@ -612,26 +755,22 @@ async function finalizeFeishuMessageProcessing(params) {
 	const key = dedupeKey(params.messageId);
 	if (!key) return false;
 	const options = dedupeOptions(params.namespace, params.log);
-	if (!params.claimHeld && (await feishuDedupeState.guard.claim(key, options)).kind !== "claimed") return false;
-	return await feishuDedupeState.guard.commit(key, options);
+	const claim = params.processingClaim ?? await feishuDedupeState.guard.claim(key, options);
+	if ("kind" in claim && claim.kind !== "claimed") return false;
+	return await ("kind" in claim ? claim.handle : claim).commit();
 }
 /** Records a handled message so restart/replay cannot dispatch it again; false when already recorded. */
 async function recordProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const key = dedupeKey(messageId);
-	if (!key) return false;
-	return await feishuDedupeState.guard.commit(key, dedupeOptions(namespace, log));
+	const claim = await feishuDedupeState.guard.claim(messageId, dedupeOptions(namespace, log));
+	return claim.kind === "claimed" ? await claim.handle.commit() : false;
 }
 /** Forgets a recorded message so a retryable synthetic event can be handled on redelivery. */
 async function forgetProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const key = dedupeKey(messageId);
-	if (!key) return false;
-	return await feishuDedupeState.guard.forget(key, dedupeOptions(namespace, log));
+	return await feishuDedupeState.guard.forget(messageId, dedupeOptions(namespace, log));
 }
 /** Checks recency without claiming or recording. */
 async function hasProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const key = dedupeKey(messageId);
-	if (!key) return false;
-	return await feishuDedupeState.guard.hasRecent(key, dedupeOptions(namespace, log));
+	return await feishuDedupeState.guard.hasRecent(messageId, dedupeOptions(namespace, log));
 }
 /** Loads recent persisted entries into memory at account start; returns the loaded count. */
 async function warmupDedupFromPluginState(namespace, log) {
@@ -1495,11 +1634,6 @@ function rememberStreamingStartFailure(accountId, now = Date.now()) {
 	streamingStartBackoffUntilByAccount.set(accountId, backoffUntil);
 	return backoffUntil;
 }
-function formatMediaFallbackText(text, mediaUrl) {
-	const trimmedText = text?.trim() ?? "";
-	const attachmentText = `📎 ${mediaUrl}`;
-	return trimmedText ? `${trimmedText}\n\n${attachmentText}` : attachmentText;
-}
 function normalizeEpochMs(timestamp) {
 	if (!Number.isFinite(timestamp) || timestamp === void 0 || timestamp <= 0) return;
 	return timestamp < MS_EPOCH_MIN ? timestamp * 1e3 : timestamp;
@@ -1524,7 +1658,7 @@ function resolveCardNote(agentId, identity, prefixCtx) {
 }
 function createFeishuReplyDispatcher(params) {
 	const core = getFeishuRuntime();
-	const { cfg, agentId, chatId, sendTarget, replyToMessageId, typingTargetMessageId: explicitTypingTargetMessageId, skipReplyToInMessages, replyInThread, threadReply, rootId, accountId, identity, mentionTargets } = params;
+	const { cfg, agentId, chatId, sendTarget, replyToMessageId, typingTargetMessageId: explicitTypingTargetMessageId, skipReplyToInMessages, replyInThread, threadReply, rootId, accountId, identity, mentionTargets, requiredMentionTargets } = params;
 	const sendReplyToMessageId = skipReplyToInMessages ? void 0 : replyToMessageId;
 	const typingTargetMessageId = explicitTypingTargetMessageId?.trim() || replyToMessageId;
 	const threadReplyMode = threadReply === true;
@@ -1589,7 +1723,7 @@ function createFeishuReplyDispatcher(params) {
 		channel: "feishu"
 	});
 	const renderMode = account.config?.renderMode ?? "auto";
-	const streamingEnabled = resolveChannelPreviewStreamMode(account.config, "partial") !== "off" && renderMode !== "raw";
+	const streamingEnabled = !requiredMentionTargets?.length && resolveChannelPreviewStreamMode(account.config, "partial") !== "off" && renderMode !== "raw";
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
 	const coreBlockStreamingEnabled = blockStreamingEnabled === true;
 	const reasoningPreviewEnabled = streamingEnabled && params.allowReasoningPreview === true;
@@ -1737,12 +1871,15 @@ function createFeishuReplyDispatcher(params) {
 			limit: textChunkLimit,
 			mode: chunkMode,
 			firstChunkMentions: paramsLocal.firstChunkMentions,
+			chunkMentions: paramsLocal.chunkMentions,
 			initialChunks
 		}));
 		for (const [index, chunk] of chunks.entries()) {
+			const mentions = [...paramsLocal.chunkMentions ?? [], ...index === 0 ? paramsLocal.firstChunkMentions ?? [] : []];
 			await paramsLocal.sendChunk({
 				chunk,
-				isFirst: index === 0
+				isFirst: index === 0,
+				mentions: mentions.length > 0 ? mentions : void 0
 			});
 			markVisibleReplySent();
 		}
@@ -1771,7 +1908,8 @@ function createFeishuReplyDispatcher(params) {
 						text: options.fallbackText,
 						useCard: false,
 						infoKind: "final",
-						sendChunk: async ({ chunk }) => {
+						chunkMentions: requiredMentionTargets,
+						sendChunk: async ({ chunk, mentions }) => {
 							await sendMessageFeishu({
 								cfg,
 								to: sendTarget,
@@ -1779,20 +1917,25 @@ function createFeishuReplyDispatcher(params) {
 								replyToMessageId: sendReplyToMessageId,
 								replyInThread: effectiveReplyInThread,
 								allowTopLevelReplyFallback,
-								accountId
+								accountId,
+								...mentions ? { mentions } : {}
 							});
 						}
 					});
 				}
 			},
 			onError: options?.fallbackText === void 0 ? void 0 : async ({ mediaUrl }) => {
-				const fallbackText = formatMediaFallbackText(sentFallbackText ? void 0 : options.fallbackText, mediaUrl);
+				const fallbackText = await buildFeishuMediaFallbackText({
+					text: sentFallbackText ? void 0 : options.fallbackText,
+					mediaUrl
+				});
 				sentFallbackText = true;
 				await sendChunkedTextReply({
 					text: fallbackText,
 					useCard: false,
 					infoKind: "final",
-					sendChunk: async ({ chunk }) => {
+					chunkMentions: requiredMentionTargets,
+					sendChunk: async ({ chunk, mentions }) => {
 						await sendMessageFeishu({
 							cfg,
 							to: sendTarget,
@@ -1800,7 +1943,8 @@ function createFeishuReplyDispatcher(params) {
 							replyToMessageId: sendReplyToMessageId,
 							replyInThread: effectiveReplyInThread,
 							allowTopLevelReplyFallback,
-							accountId
+							accountId,
+							...mentions ? { mentions } : {}
 						});
 					}
 				});
@@ -1821,7 +1965,8 @@ function createFeishuReplyDispatcher(params) {
 			replyToMessageId: sendReplyToMessageId,
 			replyInThread: effectiveReplyInThread,
 			allowTopLevelReplyFallback,
-			accountId
+			accountId,
+			...requiredMentionTargets?.length ? { mentions: requiredMentionTargets } : {}
 		});
 		markVisibleReplySent();
 		params.runtime.error?.(`feishu[${account.accountId}]: sent no-visible-reply fallback (${reason})`);
@@ -1835,10 +1980,10 @@ function createFeishuReplyDispatcher(params) {
 		idleSideEffectsPromise = nextIdleSideEffects.catch(() => {});
 		return nextIdleSideEffects;
 	};
-	const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+	const dispatcherOptions = {
 		responsePrefix: prefixContext.responsePrefix,
 		responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-		humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+		humanDelay: resolveHumanDelayConfig(cfg, agentId),
 		silentReplyContext: {
 			cfg,
 			sessionKey: params.sessionKey,
@@ -1861,142 +2006,151 @@ function createFeishuReplyDispatcher(params) {
 			if (streamingEnabled && renderMode === "card") startStreaming();
 			await Promise.resolve(typingCallbacks?.onReplyStart?.());
 		},
-		deliver: async (payload, info) => {
-			if (info?.kind === "final") skippedFinalReason = null;
-			const payloadText = payload.isReasoning && payload.text ? formatReasoningMessage(payload.text) : payload.text;
-			const reply = resolveSendableOutboundReplyParts({
-				...payload,
-				text: payloadText
-			});
-			const text = info?.kind === "final" ? mergeStreamingFinalText(streamText, reply.text, payload.isError === true && hasStreamingFinalText) : reply.text;
-			const hasText = reply.hasText;
-			const hasMedia = reply.hasMedia;
-			const hasVoiceMedia = hasMedia && reply.mediaUrls.some((mediaUrl) => shouldSuppressFeishuTextForVoiceMedia({
-				mediaUrl,
-				...payload.audioAsVoice === true ? { audioAsVoice: true } : {}
-			}));
-			const finalTextExceedsStreamingLimit = info?.kind === "final" && hasText && text.length > textChunkLimit;
-			const useStaticCard = hasText && (renderMode === "card" || info?.kind === "block" && coreBlockStreamingEnabled && renderMode !== "raw" || renderMode === "auto" && shouldUseCard(text));
-			const useStreamingCard = hasText && streamingEnabled && !finalTextExceedsStreamingLimit && (info?.kind === "final" || useStaticCard);
-			const finalTextWouldUseStreamingCard = info?.kind === "final" && hasText && streamingEnabled;
-			const useCard = useStaticCard || useStreamingCard;
-			const skipTextForDuplicateFinal = info?.kind === "final" && hasText && deliveredFinalTexts.has(text);
-			const skipTextForClosedStreamingFinal = info?.kind === "final" && hasText && streamingClosedForReply && !streamingCloseErroredForReply && finalTextWouldUseStreamingCard;
-			const shouldDeliverText = hasText && !hasVoiceMedia && !skipTextForDuplicateFinal && !skipTextForClosedStreamingFinal;
-			const shouldDiscardStreamingPreview = info?.kind === "final" && (finalTextExceedsStreamingLimit || hasMedia && (hasVoiceMedia && !shouldDeliverText || skipTextForDuplicateFinal));
-			if (!shouldDeliverText && !hasMedia) return;
-			if (shouldDiscardStreamingPreview) await discardStreamingPreview();
-			if (shouldDeliverText) {
-				if (info?.kind === "block") {
-					if (!useStreamingCard) {
-						if (coreBlockStreamingEnabled) {
-							const firstChunkMentions = !sentIndependentBlockText && mentionTargets?.length ? mentionTargets : void 0;
-							await sendChunkedTextReply({
-								text,
-								useCard: false,
-								infoKind: "block",
-								firstChunkMentions,
-								sendChunk: async ({ chunk, isFirst }) => {
-									await sendMessageFeishu({
-										cfg,
-										to: sendTarget,
-										text: chunk,
-										replyToMessageId: sendReplyToMessageId,
-										replyInThread: effectiveReplyInThread,
-										allowTopLevelReplyFallback,
-										accountId,
-										...isFirst && firstChunkMentions ? { mentions: firstChunkMentions } : {}
-									});
-								}
-							});
-							sentIndependentBlockText = true;
-							if (hasMedia) await sendMediaReplies(payload);
+		onIdle: () => queueIdleSideEffects(),
+		onCleanup: () => {
+			typingCallbacks?.onCleanup?.();
+		}
+	};
+	const handleDeliveryError = async (error, info) => {
+		streamingCloseErroredForReply = true;
+		streamingClosedForReply = false;
+		params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
+		await queueIdleSideEffects({ markClosedForReply: false }).catch((cleanupError) => params.runtime.error?.(`feishu[${account.accountId}] reply error cleanup failed: ${String(cleanupError)}`));
+	};
+	return {
+		dispatcherOptions,
+		delivery: {
+			deliver: async (payload, info) => {
+				if (info?.kind === "final") skippedFinalReason = null;
+				const payloadText = payload.isReasoning && payload.text ? formatReasoningMessage(payload.text) : payload.text;
+				const reply = resolveSendableOutboundReplyParts({
+					...payload,
+					text: payloadText
+				});
+				const text = info?.kind === "final" ? mergeStreamingFinalText(streamText, reply.text, payload.isError === true && hasStreamingFinalText) : reply.text;
+				const hasText = reply.hasText;
+				const hasMedia = reply.hasMedia;
+				const ttsSupplement = getReplyPayloadTtsSupplement(payload);
+				const ttsTextAlreadyVisible = ttsSupplement?.visibleTextAlreadyDelivered === true;
+				const hasVoiceMedia = hasMedia && reply.mediaUrls.some((mediaUrl) => shouldSuppressFeishuTextForVoiceMedia({
+					mediaUrl,
+					...payload.audioAsVoice === true ? { audioAsVoice: true } : {},
+					ttsSupplement
+				}));
+				const finalTextExceedsStreamingLimit = info?.kind === "final" && hasText && text.length > textChunkLimit;
+				const useStaticCard = hasText && (renderMode === "card" || info?.kind === "block" && coreBlockStreamingEnabled && renderMode !== "raw" || renderMode === "auto" && shouldUseCard(text));
+				const useStreamingCard = hasText && streamingEnabled && !finalTextExceedsStreamingLimit && (info?.kind === "final" || useStaticCard);
+				const finalTextWouldUseStreamingCard = info?.kind === "final" && hasText && streamingEnabled;
+				const useCard = useStaticCard || useStreamingCard;
+				const skipTextForDuplicateFinal = info?.kind === "final" && hasText && deliveredFinalTexts.has(text);
+				const skipTextForClosedStreamingFinal = info?.kind === "final" && hasText && streamingClosedForReply && !streamingCloseErroredForReply && finalTextWouldUseStreamingCard;
+				const shouldDeliverText = hasText && !hasVoiceMedia && !skipTextForDuplicateFinal && !skipTextForClosedStreamingFinal;
+				const shouldDiscardStreamingPreview = info?.kind === "final" && (finalTextExceedsStreamingLimit || hasMedia && (hasVoiceMedia && !shouldDeliverText && !ttsTextAlreadyVisible || skipTextForDuplicateFinal));
+				if (!shouldDeliverText && !hasMedia) return;
+				if (shouldDiscardStreamingPreview) await discardStreamingPreview();
+				if (shouldDeliverText) {
+					if (info?.kind === "block") {
+						if (!useStreamingCard) {
+							if (coreBlockStreamingEnabled) {
+								const firstChunkMentions = !sentIndependentBlockText && mentionTargets?.length ? mentionTargets : void 0;
+								await sendChunkedTextReply({
+									text,
+									useCard: false,
+									infoKind: "block",
+									firstChunkMentions,
+									chunkMentions: requiredMentionTargets,
+									sendChunk: async ({ chunk, mentions }) => {
+										await sendMessageFeishu({
+											cfg,
+											to: sendTarget,
+											text: chunk,
+											replyToMessageId: sendReplyToMessageId,
+											replyInThread: effectiveReplyInThread,
+											allowTopLevelReplyFallback,
+											accountId,
+											...mentions ? { mentions } : {}
+										});
+									}
+								});
+								sentIndependentBlockText = true;
+								if (hasMedia) await sendMediaReplies(payload);
+							}
+							return;
 						}
-						return;
+						startStreaming();
+						if (streamingStartPromise) await streamingStartPromise;
 					}
-					startStreaming();
-					if (streamingStartPromise) await streamingStartPromise;
-				}
-				if (info?.kind === "final" && useStreamingCard) {
-					startStreaming();
-					if (streamingStartPromise) await streamingStartPromise;
-				}
-				const shouldStreamText = info?.kind === "block" || info?.kind === "final";
-				if (streaming?.isActive() && shouldStreamText) {
-					if (info?.kind === "block") queueStreamingUpdate(text, {
-						mode: "delta",
-						dedupeWithLastPartial: true
-					});
-					if (info?.kind === "final") {
-						streamText = text;
-						hasStreamingFinalText = true;
-						snapshotBaseText = "";
-						lastSnapshotTextLength = text.length;
-						flushStreamingCardUpdate(buildCombinedStreamText(reasoningText, streamText));
+					if (info?.kind === "final" && useStreamingCard) {
+						startStreaming();
+						if (streamingStartPromise) await streamingStartPromise;
 					}
-					if (hasMedia) await sendMediaReplies(payload);
-					return;
-				}
-				if (useCard) {
-					const cardHeader = resolveCardHeader(agentId, identity);
-					const cardNote = resolveCardNote(agentId, identity, prefixContext.prefixContext);
-					await sendChunkedTextReply({
-						text,
-						useCard: true,
-						infoKind: info?.kind,
-						sendChunk: async ({ chunk }) => {
-							await sendStructuredCardFeishu({
-								cfg,
-								to: sendTarget,
-								text: chunk,
-								replyToMessageId: sendReplyToMessageId,
-								replyInThread: effectiveReplyInThread,
-								allowTopLevelReplyFallback,
-								accountId,
-								header: cardHeader,
-								note: cardNote
-							});
-						}
-					});
-				} else {
-					const firstChunkMentions = info?.kind === "final" && mentionTargets?.length ? mentionTargets : void 0;
-					await sendChunkedTextReply({
-						text,
-						useCard: false,
-						infoKind: info?.kind,
-						firstChunkMentions,
-						sendChunk: async ({ chunk, isFirst }) => {
-							await sendMessageFeishu({
-								cfg,
-								to: sendTarget,
-								text: chunk,
-								replyToMessageId: sendReplyToMessageId,
-								replyInThread: effectiveReplyInThread,
-								allowTopLevelReplyFallback,
-								accountId,
-								...isFirst && firstChunkMentions ? { mentions: firstChunkMentions } : {}
-							});
+					const shouldStreamText = info?.kind === "block" || info?.kind === "final";
+					if (streaming?.isActive() && shouldStreamText) {
+						if (info?.kind === "block") queueStreamingUpdate(text, {
+							mode: "delta",
+							dedupeWithLastPartial: true
+						});
+						if (info?.kind === "final") {
+							streamText = text;
+							hasStreamingFinalText = true;
+							snapshotBaseText = "";
+							lastSnapshotTextLength = text.length;
+							flushStreamingCardUpdate(buildCombinedStreamText(reasoningText, streamText));
 						}
-					});
+						if (hasMedia) await sendMediaReplies(payload);
+						return;
+					}
+					if (useCard) {
+						const cardHeader = resolveCardHeader(agentId, identity);
+						const cardNote = resolveCardNote(agentId, identity, prefixContext.prefixContext);
+						await sendChunkedTextReply({
+							text,
+							useCard: true,
+							infoKind: info?.kind,
+							chunkMentions: requiredMentionTargets,
+							sendChunk: async ({ chunk, mentions }) => {
+								await sendStructuredCardFeishu({
+									cfg,
+									to: sendTarget,
+									text: chunk,
+									replyToMessageId: sendReplyToMessageId,
+									replyInThread: effectiveReplyInThread,
+									allowTopLevelReplyFallback,
+									accountId,
+									header: cardHeader,
+									note: cardNote,
+									...mentions ? { mentions } : {}
+								});
+							}
+						});
+					} else {
+						const firstChunkMentions = info?.kind === "final" && mentionTargets?.length ? mentionTargets : void 0;
+						await sendChunkedTextReply({
+							text,
+							useCard: false,
+							infoKind: info?.kind,
+							firstChunkMentions,
+							chunkMentions: requiredMentionTargets,
+							sendChunk: async ({ chunk, mentions }) => {
+								await sendMessageFeishu({
+									cfg,
+									to: sendTarget,
+									text: chunk,
+									replyToMessageId: sendReplyToMessageId,
+									replyInThread: effectiveReplyInThread,
+									allowTopLevelReplyFallback,
+									accountId,
+									...mentions ? { mentions } : {}
+								});
+							}
+						});
+					}
 				}
-			}
-			if (hasMedia) await sendMediaReplies(payload, hasVoiceMedia && hasText ? { fallbackText: text } : void 0);
-		},
-		onError: async (error, info) => {
-			streamingCloseErroredForReply = true;
-			streamingClosedForReply = false;
-			params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
-			await queueIdleSideEffects({ markClosedForReply: false });
+				if (hasMedia) await sendMediaReplies(payload, hasVoiceMedia && hasText ? { fallbackText: text } : void 0);
+			},
+			onError: handleDeliveryError
 		},
-		onIdle: () => queueIdleSideEffects(),
-		onCleanup: () => {
-			typingCallbacks?.onCleanup?.();
-		}
-	});
-	return {
-		dispatcher,
 		replyOptions: {
-			...replyOptions,
 			onModelSelected: prefixContext.onModelSelected,
 			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : true,
 			onPartialReply: streamingEnabled ? (payload) => {
@@ -2038,7 +2192,6 @@ function createFeishuReplyDispatcher(params) {
 				updateStreamingStatusLine("");
 			} : void 0
 		},
-		markDispatchIdle,
 		ensureNoVisibleReplyFallback,
 		getVisibleReplyState: () => ({
 			visibleReplySent,
@@ -2047,6 +2200,17 @@ function createFeishuReplyDispatcher(params) {
 	};
 }
 //#endregion
+//#region extensions/feishu/src/synthetic-event-target.ts
+const directPreDispatchTargets = /* @__PURE__ */ new WeakMap();
+/** Keep synthetic-only routing metadata outside the public Feishu event shape. */
+function setFeishuSyntheticDirectPreDispatchTarget(event, target) {
+	directPreDispatchTargets.set(event, target);
+	return event;
+}
+function getFeishuSyntheticDirectPreDispatchTarget(event) {
+	return directPreDispatchTargets.get(event);
+}
+//#endregion
 //#region extensions/feishu/src/bot.ts
 const permissionErrorNotifiedAt = /* @__PURE__ */ new Map();
 const PERMISSION_ERROR_COOLDOWN_MS = 300 * 1e3;
@@ -2099,6 +2263,7 @@ function parseFeishuMessageEvent(event, botOpenId, _botName) {
 		suppressReplyTarget: event.message.suppress_reply_target === true,
 		senderId: senderUserId || senderOpenId || "",
 		senderOpenId: senderFallbackId,
+		senderType: event.sender.sender_type === "bot" ? "bot" : "user",
 		chatType: event.message.chat_type,
 		mentionedBot,
 		hasAnyMention,
@@ -2148,7 +2313,7 @@ async function filterFetchedGroupContextMessages(messages, params) {
 	}) ? message : void 0))).filter((message) => message !== void 0);
 }
 async function handleFeishuMessage(params) {
-	const { cfg, event, botOpenId, botName, runtime, channelRuntime, chatHistories, accountId, processingClaimHeld = false, messageDedupeKey: messageDedupeKeyOverride } = params;
+	const { cfg, event, botOpenId, botName, runtime, channelRuntime, chatHistories, accountId, processingClaim, messageDedupeKey: messageDedupeKeyOverride } = params;
 	const account = resolveFeishuRuntimeAccount({
 		cfg,
 		accountId
@@ -2162,7 +2327,7 @@ async function handleFeishuMessage(params) {
 		messageId: messageDedupeKey,
 		namespace: account.accountId,
 		log,
-		claimHeld: processingClaimHeld
+		processingClaim
 	})) {
 		log(`feishu: skipping duplicate message ${messageId}`);
 		return;
@@ -2170,7 +2335,62 @@ async function handleFeishuMessage(params) {
 	let ctx = parseFeishuMessageEvent(event, botOpenId, botName);
 	const isGroup = isFeishuGroupChatType(ctx.chatType);
 	const isDirect = !isGroup;
+	const directPreDispatchTarget = isDirect ? getFeishuSyntheticDirectPreDispatchTarget(event) : void 0;
 	const senderUserId = normalizeOptionalString(event.sender.sender_id.user_id);
+	const localBotOpenId = botOpenId?.trim();
+	if (ctx.senderType === "bot") {
+		if (!localBotOpenId) {
+			log(`feishu[${account.accountId}]: dropping bot message ${ctx.messageId} (local bot identity unavailable)`);
+			return;
+		}
+		if (ctx.senderOpenId === localBotOpenId) {
+			log(`feishu[${account.accountId}]: dropping self-authored bot message ${ctx.messageId}`);
+			return;
+		}
+		if (feishuCfg?.allowBots !== true) {
+			log(`feishu[${account.accountId}]: dropping bot message ${ctx.messageId} (allowBots=false)`);
+			return;
+		}
+		if (isGroup && !ctx.mentionedBot) {
+			let verifiedEvent;
+			try {
+				const response = await createFeishuClient(account).im.message.get({
+					params: { user_id_type: "open_id" },
+					path: { message_id: ctx.messageId }
+				});
+				const verifiedKey = (response.data?.items?.[0]?.mentions?.find((mention) => mention.id_type === "open_id" && mention.id === localBotOpenId && Boolean(mention.key?.trim())))?.key?.trim();
+				if (response.code === 0 && verifiedKey) {
+					const eventMention = event.message.mentions?.find((mention) => mention.key === verifiedKey && !isFeishuBroadcastMention(mention));
+					if (eventMention) verifiedEvent = {
+						...event,
+						message: {
+							...event.message,
+							mentions: event.message.mentions?.map((mention) => mention === eventMention ? {
+								...mention,
+								id: {
+									...mention.id,
+									open_id: localBotOpenId
+								}
+							} : mention)
+						}
+					};
+				}
+			} catch (err) {
+				log(`feishu[${account.accountId}]: failed to verify bot mention for ${ctx.messageId}: ${String(err)}`);
+			}
+			if (!verifiedEvent) {
+				log(`feishu[${account.accountId}]: dropping bot message ${ctx.messageId} (local mention not verifiable)`);
+				return;
+			}
+			const deliveredCtx = parseFeishuMessageEvent(verifiedEvent, localBotOpenId, botName);
+			ctx = {
+				...deliveredCtx,
+				mentionedBot: true,
+				content: normalizeFeishuCommandProbeBody(deliveredCtx.content),
+				mentionTargets: void 0
+			};
+		}
+	}
 	if (event.message.message_type === "merge_forward") {
 		log(`feishu[${account.accountId}]: processing merge_forward message, fetching full content via API`);
 		try {
@@ -2201,7 +2421,17 @@ async function handleFeishuMessage(params) {
 		}
 	}
 	let permissionErrorForAgent;
-	if (feishuCfg?.resolveSenderNames ?? true) {
+	if (feishuCfg?.resolveSenderNames ?? true) if (ctx.senderType === "bot") {
+		const senderName = await resolveFeishuBotName({
+			account,
+			openId: ctx.senderOpenId,
+			log
+		});
+		if (senderName) ctx = {
+			...ctx,
+			senderName
+		};
+	} else {
 		const senderResult = await resolveFeishuSenderName({
 			account,
 			senderId: ctx.senderOpenId,
@@ -2338,6 +2568,23 @@ async function handleFeishuMessage(params) {
 			});
 			return;
 		}
+		if (ctx.senderType === "bot") {
+			if (!localBotOpenId || !ctx.senderOpenId) {
+				log(`feishu[${account.accountId}]: dropping bot message ${ctx.messageId} (loop identity unavailable)`);
+				return;
+			}
+			if (recordChannelBotPairLoopAndCheckSuppression({
+				scopeId: account.accountId,
+				conversationId: ctx.chatId,
+				senderId: ctx.senderOpenId,
+				receiverId: localBotOpenId,
+				defaultsConfig: cfg.channels?.defaults?.botLoopProtection,
+				defaultEnabled: true
+			}).suppressed) {
+				log(`feishu[${account.accountId}]: bot-pair loop suppressed for ${ctx.senderOpenId} in ${ctx.chatId}`);
+				return;
+			}
+		}
 	}
 	try {
 		const core = { channel: channelRuntime?.inbound ? channelRuntime : getFeishuRuntime().channel };
@@ -2385,7 +2632,7 @@ async function handleFeishuMessage(params) {
 				sendPairingReply: async (text) => {
 					await sendMessageFeishu({
 						cfg: authorization.cfg,
-						to: `chat:${ctx.chatId}`,
+						to: directPreDispatchTarget ?? `chat:${ctx.chatId}`,
 						text,
 						accountId: account.accountId
 					});
@@ -2520,7 +2767,7 @@ async function handleFeishuMessage(params) {
 				const replyTargetMessageId = directThreadReply ? directThreadReplyTargetMessageId : acpTopicReply ? ctx.rootId ?? ctx.messageId : ctx.messageId;
 				await sendMessageFeishu({
 					cfg: effectiveCfg,
-					to: `chat:${ctx.chatId}`,
+					to: directPreDispatchTarget ?? `chat:${ctx.chatId}`,
 					text: `⚠️ Failed to initialize the configured ACP session for this Feishu conversation: ${ensured.error}`,
 					replyToMessageId: replyTargetMessageId,
 					replyInThread,
@@ -2594,6 +2841,11 @@ async function handleFeishuMessage(params) {
 		});
 		const preflightAudioIndex = audioTranscript === void 0 ? -1 : mediaList.findIndex((media) => media.contentType?.startsWith("audio/"));
 		const inboundMedia = toInboundMediaFacts(mediaList, { transcribed: (_media, index) => index === preflightAudioIndex });
+		const requiredMentionTargets = isGroup && ctx.senderType === "bot" && ctx.senderOpenId ? [{
+			openId: ctx.senderOpenId,
+			name: ctx.senderName ?? ctx.senderOpenId,
+			key: ""
+		}] : void 0;
 		const agentFacingContent = audioTranscript ?? mediaFailureContent;
 		const commandFacingContent = audioTranscript ?? ctx.content;
 		const agentFacingCtx = agentFacingContent === ctx.content ? ctx : {
@@ -2624,7 +2876,7 @@ async function handleFeishuMessage(params) {
 			command: { hasControlCommand: true }
 		})).commandAccess.authorized : void 0;
 		const isTopicSessionForThread = isGroup && (groupSession?.groupSessionScope === "group_topic" || groupSession?.groupSessionScope === "group_topic_sender");
-		const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+		const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
 		const messageBody = buildFeishuAgentBody({
 			ctx: agentFacingCtx,
 			quotedContent,
@@ -2633,7 +2885,7 @@ async function handleFeishuMessage(params) {
 		});
 		const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderOpenId}` : ctx.senderOpenId;
 		if (permissionErrorForAgent) log(`feishu[${account.accountId}]: appending permission error notice to message body`);
-		let combinedBody = core.channel.reply.formatAgentEnvelope({
+		let combinedBody = formatAgentEnvelope({
 			channel: "Feishu",
 			from: envelopeFrom,
 			timestamp: /* @__PURE__ */ new Date(),
@@ -2645,7 +2897,7 @@ async function handleFeishuMessage(params) {
 			historyKey,
 			limit: historyLimit,
 			currentMessage: combinedBody,
-			formatEntry: (entry) => core.channel.reply.formatAgentEnvelope({
+			formatEntry: (entry) => formatAgentEnvelope({
 				channel: "Feishu",
 				from: `${ctx.chatId}:${entry.sender}`,
 				timestamp: entry.timestamp,
@@ -2712,7 +2964,7 @@ async function handleFeishuMessage(params) {
 				threadContextBySessionKey.set(agentSessionKey, threadContext);
 				return threadContext;
 			}
-			const storePath = core.channel.session.resolveStorePath(cfg.session?.store, { agentId });
+			const storePath = resolveStorePath(cfg.session?.store, { agentId });
 			if (core.channel.session.readSessionUpdatedAt({
 				storePath,
 				sessionKey: agentSessionKey
@@ -2754,7 +3006,7 @@ async function handleFeishuMessage(params) {
 				const historyMessages = Boolean(rootMsg?.content || ctx.rootId) ? relevantMessages : relevantMessages.slice(1);
 				const historyParts = historyMessages.map((msg) => {
 					const role = msg.senderType === "app" ? "assistant" : "user";
-					return core.channel.reply.formatAgentEnvelope({
+					return formatAgentEnvelope({
 						channel: "Feishu",
 						from: `${msg.senderId ?? "Unknown"} (${role})`,
 						timestamp: msg.createTime,
@@ -2776,7 +3028,6 @@ async function handleFeishuMessage(params) {
 			const threadContext = await resolveThreadContextForAgent(agentId, agentSessionKey, groupName);
 			return buildChannelInboundEventContext({
 				channel: "feishu",
-				finalize: core.channel.reply.finalizeInboundContext,
 				supplemental: {
 					quote: quotedContent ? {
 						id: ctx.parentId,
@@ -2795,7 +3046,8 @@ async function handleFeishuMessage(params) {
 				from: feishuFrom,
 				sender: {
 					id: ctx.senderOpenId,
-					name: ctx.senderName ?? ctx.senderOpenId
+					name: ctx.senderName ?? ctx.senderOpenId,
+					isBot: ctx.senderType === "bot"
 				},
 				conversation: {
 					kind: isGroup ? "group" : "direct",
@@ -2806,6 +3058,7 @@ async function handleFeishuMessage(params) {
 				},
 				route: {
 					agentId,
+					dmScope: route.dmScope,
 					accountId: agentAccountId,
 					routeSessionKey: agentSessionKey
 				},
@@ -2827,7 +3080,7 @@ async function handleFeishuMessage(params) {
 						wasMentioned,
 						requireMention
 					},
-					commands: { authorized: commandAuthorized }
+					commands: { authorized: commandAuthorized === true }
 				},
 				extra: {
 					RootMessageId: ctx.rootId,
@@ -2885,7 +3138,7 @@ async function handleFeishuMessage(params) {
 					return;
 				}
 				const agentSessionKey = buildBroadcastSessionKey(route.sessionKey, route.agentId, agentId);
-				const agentStorePath = core.channel.session.resolveStorePath(cfg.session?.store, { agentId });
+				const agentStorePath = resolveStorePath(cfg.session?.store, { agentId });
 				const agentRecord = {
 					updateLastRoute: buildFeishuInboundLastRouteUpdate({
 						sessionKey: agentSessionKey,
@@ -2904,7 +3157,7 @@ async function handleFeishuMessage(params) {
 				const agentCtx = await buildCtxPayloadForAgent(agentId, agentSessionKey, route.accountId, ctx.mentionedBot && agentId === activeAgentId);
 				if (agentId === activeAgentId) {
 					const identity = resolveAgentOutboundIdentity(cfg, agentId);
-					const { dispatcher, replyOptions, markDispatchIdle, ensureNoVisibleReplyFallback } = createFeishuReplyDispatcher({
+					const { dispatcherOptions, delivery, replyOptions, ensureNoVisibleReplyFallback } = createFeishuReplyDispatcher({
 						cfg,
 						agentId,
 						runtime,
@@ -2920,6 +3173,7 @@ async function handleFeishuMessage(params) {
 						accountId: account.accountId,
 						identity,
 						mentionTargets: ctx.mentionTargets,
+						requiredMentionTargets,
 						messageCreateTimeMs,
 						sessionKey: agentSessionKey
 					});
@@ -2938,57 +3192,24 @@ async function handleFeishuMessage(params) {
 								raw: ctx
 							}),
 							resolveTurn: () => ({
+								cfg,
 								channel: "feishu",
 								accountId: route.accountId,
-								routeSessionKey: agentSessionKey,
-								storePath: agentStorePath,
+								route: {
+									agentId,
+									sessionKey: agentSessionKey
+								},
 								ctxPayload: agentCtx,
-								recordInboundSession: core.channel.session.recordInboundSession,
 								record: agentRecord,
-								onPreDispatchFailure: () => core.channel.reply.settleReplyDispatcher({
-									dispatcher,
-									onSettled: () => markDispatchIdle()
-								}),
-								runDispatch: () => core.channel.reply.withReplyDispatcher({
-									dispatcher,
-									onSettled: () => markDispatchIdle(),
-									run: () => core.channel.reply.dispatchReplyFromConfig({
-										ctx: agentCtx,
-										cfg,
-										dispatcher,
-										replyOptions
-									})
-								})
+								dispatcherOptions,
+								delivery,
+								replyOptions
 							})
 						}
 					});
-					if (turnResult.dispatched && shouldSendNoVisibleReplyFallback({
-						...turnResult.dispatchResult,
-						failedCounts: dispatcher.getFailedCounts?.() ?? {
-							tool: 0,
-							block: 0,
-							final: 0
-						}
-					})) await ensureNoVisibleReplyFallback("broadcast-dispatch-complete-no-visible-reply");
+					if (turnResult.dispatched && shouldSendNoVisibleReplyFallback(turnResult.dispatchResult)) await ensureNoVisibleReplyFallback("broadcast-dispatch-complete-no-visible-reply");
 				} else {
 					delete agentCtx.CommandAuthorized;
-					const noopDispatcher = {
-						sendToolResult: () => false,
-						sendBlockReply: () => false,
-						sendFinalReply: () => false,
-						waitForIdle: async () => {},
-						getQueuedCounts: () => ({
-							tool: 0,
-							block: 0,
-							final: 0
-						}),
-						getFailedCounts: () => ({
-							tool: 0,
-							block: 0,
-							final: 0
-						}),
-						markComplete: () => {}
-					};
 					log(`feishu[${account.accountId}]: broadcast observer dispatch agent=${agentId} (session=${agentSessionKey})`);
 					await core.channel.inbound.run({
 						channel: "feishu",
@@ -3004,21 +3225,20 @@ async function handleFeishuMessage(params) {
 								raw: ctx
 							}),
 							resolveTurn: () => ({
+								cfg,
 								channel: "feishu",
 								accountId: route.accountId,
-								routeSessionKey: agentSessionKey,
-								storePath: agentStorePath,
+								route: {
+									agentId,
+									sessionKey: agentSessionKey
+								},
 								ctxPayload: agentCtx,
-								recordInboundSession: core.channel.session.recordInboundSession,
 								record: agentRecord,
-								runDispatch: () => core.channel.reply.withReplyDispatcher({
-									dispatcher: noopDispatcher,
-									run: () => core.channel.reply.dispatchReplyFromConfig({
-										ctx: agentCtx,
-										cfg,
-										dispatcher: noopDispatcher
-									})
-								})
+								admission: {
+									kind: "observeOnly",
+									reason: "broadcast-observer"
+								},
+								delivery: { deliver: async () => ({ visibleReplySent: false }) }
 							})
 						}
 					});
@@ -3045,14 +3265,14 @@ async function handleFeishuMessage(params) {
 		} else {
 			const ctxPayload = await buildCtxPayloadForAgent(route.agentId, route.sessionKey, route.accountId, ctx.mentionedBot);
 			const identity = resolveAgentOutboundIdentity(effectiveCfg, route.agentId);
-			const storePath = core.channel.session.resolveStorePath(effectiveCfg.session?.store, { agentId: route.agentId });
+			const storePath = resolveStorePath(effectiveCfg.session?.store, { agentId: route.agentId });
 			const allowReasoningPreview = resolveFeishuReasoningPreviewEnabled({
 				cfg: effectiveCfg,
 				agentId: route.agentId,
 				storePath,
 				sessionKey: route.sessionKey
 			});
-			const { dispatcher, replyOptions, markDispatchIdle, ensureNoVisibleReplyFallback } = createFeishuReplyDispatcher({
+			const { dispatcherOptions, delivery, replyOptions, ensureNoVisibleReplyFallback } = createFeishuReplyDispatcher({
 				cfg: effectiveCfg,
 				agentId: route.agentId,
 				runtime,
@@ -3068,6 +3288,7 @@ async function handleFeishuMessage(params) {
 				accountId: account.accountId,
 				identity,
 				mentionTargets: ctx.mentionTargets,
+				requiredMentionTargets,
 				messageCreateTimeMs,
 				sessionKey: route.sessionKey
 			});
@@ -3086,12 +3307,14 @@ async function handleFeishuMessage(params) {
 						raw: ctx
 					}),
 					resolveTurn: () => ({
+						cfg: effectiveCfg,
 						channel: "feishu",
 						accountId: route.accountId,
-						routeSessionKey: route.sessionKey,
-						storePath,
+						route: {
+							agentId: route.agentId,
+							sessionKey: route.sessionKey
+						},
 						ctxPayload,
-						recordInboundSession: core.channel.session.recordInboundSession,
 						record: {
 							updateLastRoute: buildFeishuInboundLastRouteUpdate({
 								sessionKey: route.sessionKey,
@@ -3107,36 +3330,16 @@ async function handleFeishuMessage(params) {
 							historyMap: chatHistories,
 							limit: historyLimit
 						},
-						onPreDispatchFailure: () => core.channel.reply.settleReplyDispatcher({
-							dispatcher,
-							onSettled: () => markDispatchIdle()
-						}),
-						runDispatch: () => core.channel.reply.withReplyDispatcher({
-							dispatcher,
-							onSettled: () => {
-								markDispatchIdle();
-							},
-							run: () => core.channel.reply.dispatchReplyFromConfig({
-								ctx: ctxPayload,
-								cfg: effectiveCfg,
-								dispatcher,
-								replyOptions
-							})
-						})
+						dispatcherOptions,
+						delivery,
+						replyOptions
 					})
 				}
 			});
 			if (!turnResult.dispatched) return;
 			const { dispatchResult } = turnResult;
 			const { queuedFinal, counts } = dispatchResult;
-			if (shouldSendNoVisibleReplyFallback({
-				...dispatchResult,
-				failedCounts: dispatcher.getFailedCounts?.() ?? {
-					tool: 0,
-					block: 0,
-					final: 0
-				}
-			})) await ensureNoVisibleReplyFallback("dispatch-complete-no-visible-reply");
+			if (shouldSendNoVisibleReplyFallback(dispatchResult)) await ensureNoVisibleReplyFallback("dispatch-complete-no-visible-reply");
 			log(`feishu[${account.accountId}]: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
 		}
 	} catch (err) {
@@ -3256,7 +3459,7 @@ function completeFeishuCardAction(actionId, accountId, now = Date.now()) {
 		expiresAt
 	});
 }
-function buildSyntheticMessageEvent(event, content, chatType) {
+function buildSyntheticMessageEvent$1(event, content, chatType) {
 	const replyTargetMessageId = event.context.open_message_id ?? event.open_message_id;
 	const isTemporaryCardActionId = replyTargetMessageId?.startsWith("card-action-c-");
 	const validReplyTargetId = replyTargetMessageId && !isTemporaryCardActionId ? replyTargetMessageId : void 0;
@@ -3292,7 +3495,7 @@ async function dispatchSyntheticCommand(params) {
 	});
 	await handleFeishuMessage({
 		cfg: params.cfg,
-		event: buildSyntheticMessageEvent(params.event, params.command, resolvedChatType),
+		event: buildSyntheticMessageEvent$1(params.event, params.command, resolvedChatType),
 		botOpenId: params.botOpenId,
 		runtime: params.runtime,
 		channelRuntime: params.channelRuntime,
@@ -3863,11 +4066,11 @@ function createFeishuBotMenuHandler(params) {
 				namespace: accountId,
 				log
 			});
-			if (claim === "duplicate") {
+			if (claim.kind === "duplicate") {
 				log(`feishu[${accountId}]: dropping duplicate bot-menu event for ${syntheticMessageId}`);
 				return;
 			}
-			if (claim === "inflight") {
+			if (claim.kind === "inflight") {
 				log(`feishu[${accountId}]: dropping in-flight bot-menu event for ${syntheticMessageId}`);
 				return;
 			}
@@ -3880,7 +4083,7 @@ function createFeishuBotMenuHandler(params) {
 				channelRuntime: params.channelRuntime,
 				chatHistories,
 				accountId,
-				processingClaimHeld: true
+				processingClaim: claim.kind === "claimed" ? claim.handle : void 0
 			});
 			const promise = maybeHandleFeishuQuickActionMenu({
 				cfg,
@@ -3890,16 +4093,16 @@ function createFeishuBotMenuHandler(params) {
 				accountId
 			}).then(async (handledMenu) => {
 				if (handledMenu) {
-					await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+					if (claim.kind === "claimed") await claim.handle.commit();
 					return;
 				}
 				return await handleLegacyMenu();
 			}).catch(async (err) => {
-				if (isFeishuRetryableSyntheticEventError(err)) await forgetProcessedFeishuMessage(syntheticMessageId, accountId, log);
-				else await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+				if (isFeishuRetryableSyntheticEventError(err)) {
+					await forgetProcessedFeishuMessage(syntheticMessageId, accountId, log);
+					if (claim.kind === "claimed") claim.handle.release({ error: err });
+				} else if (claim.kind === "claimed") await claim.handle.commit();
 				throw err;
-			}).finally(() => {
-				releaseFeishuMessageProcessing(syntheticMessageId, accountId);
 			});
 			if (fireAndForget) {
 				promise.catch((err) => {
@@ -3937,41 +4140,39 @@ function createFeishuCommentReplyDispatcher(params) {
 		accountId: params.accountId,
 		runtime: params.runtime
 	});
-	const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
-		responsePrefix: prefixContext.responsePrefix,
-		responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-		humanDelay: core.channel.reply.resolveHumanDelayConfig(params.cfg, params.agentId),
-		onReplyStart: async () => {
-			await typingReaction.start();
-		},
-		deliver: async (payload, info) => {
-			if (info.kind !== "final") return;
-			const reply = resolveSendableOutboundReplyParts(payload);
-			if (!reply.hasText) {
-				if (reply.hasMedia) params.runtime.log?.(`feishu[${params.accountId ?? "default"}]: comment reply ignored media-only payload for comment=${params.commentId}`);
-				return;
+	return {
+		dispatcherOptions: {
+			responsePrefix: prefixContext.responsePrefix,
+			responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+			humanDelay: resolveHumanDelayConfig(params.cfg, params.agentId),
+			onReplyStart: async () => {
+				await typingReaction.start();
+			},
+			onCleanup: () => {
+				typingReaction.cleanup();
 			}
-			const chunks = core.channel.text.chunkTextWithMode(reply.text, textChunkLimit, chunkMode);
-			for (const chunk of chunks) await deliverCommentThreadText(client, {
-				file_token: params.fileToken,
-				file_type: params.fileType,
-				comment_id: params.commentId,
-				content: chunk,
-				is_whole_comment: params.isWholeComment
-			});
 		},
-		onError: (err, info) => {
-			params.runtime.error?.(`feishu[${params.accountId ?? "default"}]: comment dispatcher failed kind=${info.kind} comment=${params.commentId}: ${String(err)}`);
+		delivery: {
+			deliver: async (payload, info) => {
+				if (info.kind !== "final") return;
+				const reply = resolveSendableOutboundReplyParts(payload);
+				if (!reply.hasText) {
+					if (reply.hasMedia) params.runtime.log?.(`feishu[${params.accountId ?? "default"}]: comment reply ignored media-only payload for comment=${params.commentId}`);
+					return;
+				}
+				const chunks = core.channel.text.chunkTextWithMode(reply.text, textChunkLimit, chunkMode);
+				for (const chunk of chunks) await deliverCommentThreadText(client, {
+					file_token: params.fileToken,
+					file_type: params.fileType,
+					comment_id: params.commentId,
+					content: chunk,
+					is_whole_comment: params.isWholeComment
+				});
+			},
+			onError: (err, info) => {
+				params.runtime.error?.(`feishu[${params.accountId ?? "default"}]: comment dispatcher failed kind=${info.kind} comment=${params.commentId}: ${String(err)}`);
+			}
 		},
-		onCleanup: () => {
-			typingReaction.cleanup();
-		}
-	});
-	return {
-		dispatcher,
-		replyOptions,
-		markDispatchIdle,
-		markRunComplete,
 		startTypingReaction: typingReaction.start,
 		cleanupTypingReaction: typingReaction.cleanup
 	};
@@ -4088,11 +4289,6 @@ async function resolveParsedCommentContent(params) {
 		linkedDocuments: resolvedLinkedDocuments
 	};
 }
-async function delayMs(ms) {
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
 function buildDriveCommentTargetUrl(params) {
 	return `/open-apis/drive/v1/files/${encodeURIComponent(params.fileToken)}/comments/batch_query` + encodeQuery({
 		file_type: params.fileType,
@@ -4315,8 +4511,9 @@ async function fetchDriveCommentContext(params) {
 			fetchedMatchedReply = params.replyId ? replies.find((reply) => reply.reply_id?.trim() === params.replyId?.trim()) : void 0;
 		}
 		if (params.replyId && !embeddedTargetReply && !fetchedMatchedReply) for (let attempt = 1; attempt <= FEISHU_COMMENT_REPLY_MISS_RETRY_LIMIT; attempt += 1) {
+			if (params.abortSignal?.aborted) break;
 			params.logger?.(`feishu[${params.accountId}]: retrying comment reply lookup comment=${params.commentId} requested_reply=${params.replyId} attempt=${attempt}/${FEISHU_COMMENT_REPLY_MISS_RETRY_LIMIT} delay_ms=${FEISHU_COMMENT_REPLY_MISS_RETRY_DELAY_MS}`);
-			await params.waitMs(FEISHU_COMMENT_REPLY_MISS_RETRY_DELAY_MS);
+			if (!await waitForAbortableDelay(FEISHU_COMMENT_REPLY_MISS_RETRY_DELAY_MS, params.abortSignal)) break;
 			const retried = await fetchDriveCommentReplies(params);
 			if (retried.replies.length > 0) {
 				params.logger?.(`feishu[${params.accountId}]: fetched retried comment replies comment=${params.commentId} attempt=${attempt} count=${retried.replies.length} log_ids=${safeJsonStringify(retried.logIds)} summary=${summarizeCommentRepliesForLog(retried.replies)}`);
@@ -4464,7 +4661,7 @@ function buildDriveCommentSurfacePrompt(params) {
 	return lines.join("\n");
 }
 async function resolveDriveCommentEventCore(params) {
-	const { cfg, accountId, event, account, botOpenId, createClient, verificationTimeoutMs = FEISHU_COMMENT_VERIFY_TIMEOUT_MS, logger, waitMs = delayMs } = params;
+	const { cfg, accountId, event, account, botOpenId, createClient, verificationTimeoutMs = FEISHU_COMMENT_VERIFY_TIMEOUT_MS, logger, abortSignal } = params;
 	const eventId = event.event_id?.trim();
 	const commentId = event.comment_id?.trim();
 	const replyId = event.reply_id?.trim();
@@ -4502,7 +4699,7 @@ async function resolveDriveCommentEventCore(params) {
 		timeoutMs: verificationTimeoutMs,
 		logger,
 		accountId,
-		waitMs
+		abortSignal
 	});
 	return {
 		eventId,
@@ -4628,7 +4825,8 @@ async function handleFeishuCommentEvent(params) {
 		accountId: account.accountId,
 		event: params.event,
 		botOpenId: params.botOpenId,
-		logger: log
+		logger: log,
+		abortSignal: params.abortSignal
 	});
 	if (!turn) {
 		log(`feishu[${account.accountId}]: drive comment notice skipped event=${params.event.event_id ?? "unknown"} comment=${params.event.comment_id ?? "unknown"}`);
@@ -4753,31 +4951,51 @@ async function handleFeishuCommentEvent(params) {
 		fileToken: turn.fileToken
 	});
 	const bodyForAgent = `[message_id: ${turn.messageId}]\n${turn.prompt}`;
-	const ctxPayload = core.channel.reply.finalizeInboundContext({
-		Body: bodyForAgent,
-		BodyForAgent: bodyForAgent,
-		RawBody: turn.targetReplyText ?? turn.rootCommentText ?? turn.prompt,
-		CommandBody: turn.targetReplyText ?? turn.rootCommentText ?? turn.prompt,
-		From: `feishu:${turn.senderId}`,
-		To: commentTarget,
-		SessionKey: commentSessionKey,
-		AccountId: route.accountId,
-		ChatType: "direct",
-		ConversationLabel: turn.documentTitle ? `Feishu comment · ${turn.documentTitle}` : "Feishu comment",
-		SenderName: turn.senderId,
-		SenderId: turn.senderId,
-		Provider: "feishu",
-		Surface: "feishu-comment",
-		MessageSid: turn.messageId,
-		MessageThreadId: turn.replyId,
-		Timestamp: parseTimestampMs(turn.timestamp),
-		WasMentioned: turn.isMentioned,
-		CommandAuthorized: false,
-		OriginatingChannel: "feishu",
-		OriginatingTo: commentTarget
+	const rawBody = turn.targetReplyText ?? turn.rootCommentText ?? turn.prompt;
+	const conversationLabel = turn.documentTitle ? `Feishu comment · ${turn.documentTitle}` : "Feishu comment";
+	const ctxPayload = buildChannelInboundEventContext({
+		channel: "feishu",
+		accountId: route.accountId,
+		surface: "feishu-comment",
+		messageId: turn.messageId,
+		timestamp: parseTimestampMs(turn.timestamp),
+		from: `feishu:${turn.senderId}`,
+		sender: {
+			id: turn.senderId,
+			name: turn.senderId
+		},
+		conversation: {
+			kind: "direct",
+			id: commentTarget,
+			label: conversationLabel
+		},
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			accountId: route.accountId,
+			routeSessionKey: commentSessionKey,
+			dispatchSessionKey: commentSessionKey
+		},
+		reply: {
+			to: commentTarget,
+			originatingTo: commentTarget,
+			messageThreadId: turn.replyId
+		},
+		message: {
+			body: bodyForAgent,
+			bodyForAgent,
+			rawBody,
+			commandBody: rawBody
+		},
+		access: {
+			commands: { authorized: false },
+			mentions: {
+				canDetectMention: true,
+				wasMentioned: turn.isMentioned ?? false
+			}
+		}
 	});
-	const storePath = core.channel.session.resolveStorePath(effectiveCfg.session?.store, { agentId: route.agentId });
-	const { dispatcher, replyOptions, markDispatchIdle, markRunComplete, cleanupTypingReaction } = createFeishuCommentReplyDispatcher({
+	const { dispatcherOptions, delivery, cleanupTypingReaction } = createFeishuCommentReplyDispatcher({
 		cfg: effectiveCfg,
 		agentId: route.agentId,
 		runtime,
@@ -4788,7 +5006,6 @@ async function handleFeishuCommentEvent(params) {
 		replyId: turn.replyId,
 		isWholeComment: turn.isWholeComment
 	});
-	let dispatchSettledBeforeStart = false;
 	try {
 		log(`feishu[${account.accountId}]: dispatching drive comment to agent (session=${commentSessionKey} comment=${turn.commentId} type=${turn.noticeType})`);
 		const turnResult = await core.channel.inbound.run({
@@ -4805,34 +5022,19 @@ async function handleFeishuCommentEvent(params) {
 					raw: turn
 				}),
 				resolveTurn: () => ({
+					cfg: effectiveCfg,
 					channel: "feishu",
 					accountId: route.accountId,
-					routeSessionKey: commentSessionKey,
-					storePath,
+					route: {
+						agentId: route.agentId,
+						sessionKey: commentSessionKey
+					},
 					ctxPayload,
-					recordInboundSession: core.channel.session.recordInboundSession,
 					record: { onRecordError: (err) => {
 						error(`feishu[${account.accountId}]: failed to record comment inbound session ${commentSessionKey}: ${String(err)}`);
 					} },
-					onPreDispatchFailure: async () => {
-						dispatchSettledBeforeStart = true;
-						await core.channel.reply.settleReplyDispatcher({
-							dispatcher,
-							onSettled: () => {
-								markRunComplete();
-								markDispatchIdle();
-							}
-						});
-					},
-					runDispatch: () => core.channel.reply.withReplyDispatcher({
-						dispatcher,
-						run: () => core.channel.reply.dispatchReplyFromConfig({
-							ctx: ctxPayload,
-							cfg: effectiveCfg,
-							dispatcher,
-							replyOptions
-						})
-					})
+					dispatcherOptions,
+					delivery
 				})
 			}
 		});
@@ -4845,10 +5047,6 @@ async function handleFeishuCommentEvent(params) {
 		};
 		log(`feishu[${account.accountId}]: drive comment dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final}, session=${commentSessionKey})`);
 	} finally {
-		if (!dispatchSettledBeforeStart) {
-			markRunComplete();
-			markDispatchIdle();
-		}
 		cleanupTypingReaction();
 	}
 }
@@ -4912,7 +5110,7 @@ function buildCommentNoticeQueueKey(event) {
 	return `comment-doc:${event.notice_meta?.file_type?.trim() || "unknown"}:${event.notice_meta?.file_token?.trim() || "unknown"}`;
 }
 function createFeishuDriveCommentNoticeHandler(params) {
-	const { cfg, accountId, runtime, fireAndForget } = params;
+	const { cfg, accountId, runtime, fireAndForget, abortSignal } = params;
 	const log = runtime?.log ?? console.log;
 	const error = runtime?.error ?? console.error;
 	const enqueue = createSequentialQueue();
@@ -4932,20 +5130,22 @@ function createFeishuDriveCommentNoticeHandler(params) {
 			}
 			const eventId = event.event_id?.trim();
 			const syntheticMessageId = eventId ? `drive-comment:${eventId}` : void 0;
+			let processingClaim;
 			if (syntheticMessageId) {
 				const claim = await claimUnprocessedFeishuMessage({
 					messageId: syntheticMessageId,
 					namespace: accountId,
 					log
 				});
-				if (claim === "duplicate") {
+				if (claim.kind === "duplicate") {
 					log(`feishu[${accountId}]: dropping duplicate comment event ${syntheticMessageId}`);
 					return;
 				}
-				if (claim === "inflight") {
+				if (claim.kind === "inflight") {
 					log(`feishu[${accountId}]: dropping in-flight comment event ${syntheticMessageId}`);
 					return;
 				}
+				processingClaim = claim.kind === "claimed" ? claim.handle : void 0;
 			}
 			log(`feishu[${accountId}]: received drive comment notice event=${event.event_id ?? "unknown"} type=${event.notice_meta?.notice_type ?? "unknown"} file=${event.notice_meta?.file_type ?? "unknown"}:${event.notice_meta?.file_token ?? "unknown"} comment=${event.comment_id ?? "unknown"} reply=${event.reply_id ?? "none"} from=${event.notice_meta?.from_user_id?.open_id ?? "unknown"} mentioned=${event.is_mentioned === true ? "yes" : "no"}`);
 			try {
@@ -4955,15 +5155,15 @@ function createFeishuDriveCommentNoticeHandler(params) {
 						accountId,
 						event,
 						botOpenId: getBotOpenId(accountId),
-						runtime
+						runtime,
+						abortSignal
 					});
 				});
-				if (syntheticMessageId) await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+				await processingClaim?.commit();
 			} catch (err) {
-				if (syntheticMessageId && !isFeishuRetryableSyntheticEventError(err)) await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+				if (isFeishuRetryableSyntheticEventError(err)) processingClaim?.release({ error: err });
+				else await processingClaim?.commit();
 				throw err;
-			} finally {
-				if (syntheticMessageId) releaseFeishuMessageProcessing(syntheticMessageId, accountId);
 			}
 		});
 	};
@@ -5005,7 +5205,7 @@ function dedupeFeishuDebounceEntriesByDedupeKey(entries) {
 	const seen = /* @__PURE__ */ new Set();
 	const deduped = [];
 	for (const entry of entries) {
-		const dedupeKey = resolveFeishuMessageDedupeKey(entry);
+		const dedupeKey = resolveFeishuMessageDedupeKey(entry.event);
 		if (!dedupeKey) {
 			deduped.push(entry);
 			continue;
@@ -5027,7 +5227,7 @@ function resolveFeishuDebounceMentions(params) {
 	const botMentions = merged.filter((mention) => mention.id.open_id?.trim() === normalizedBotOpenId);
 	return botMentions.length > 0 ? botMentions : void 0;
 }
-function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, runtime, chatHistories, fireAndForget, handleMessage, resolveDebounceText: resolveText, hasProcessedMessage, recordProcessedMessage, getBotOpenId = () => void 0, getBotName = () => void 0, resolveSequentialKey = ({ accountId: accountIdLocal, event }) => `feishu:${accountIdLocal}:${event.message.chat_id?.trim() || "unknown"}`, statusSink }) {
+function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, runtime, chatHistories, fireAndForget, handleMessage, resolveDebounceText: resolveText, hasProcessedMessage, getBotOpenId = () => void 0, getBotName = () => void 0, resolveSequentialKey = ({ accountId: accountIdLocal, event }) => `feishu:${accountIdLocal}:${event.message.chat_id?.trim() || "unknown"}`, statusSink }) {
 	const inboundDebounceMs = channelRuntime.debounce.resolveInboundDebounceMs({
 		cfg,
 		channel: "feishu"
@@ -5037,7 +5237,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 	const enqueue = createSequentialQueue({ onTaskTimeout: (key, timeoutMs) => {
 		log(`feishu[${accountId}]: per-chat task exceeded ${timeoutMs}ms cap (key=${key}); evicting from queue so later same-key messages can proceed (#70133)`);
 	} });
-	const dispatchFeishuMessage = async (event, messageDedupeKey) => {
+	const dispatchFeishuMessage = async (event, messageDedupeKey, processingClaim) => {
 		const sequentialKey = resolveSequentialKey({
 			accountId,
 			event,
@@ -5053,7 +5253,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			channelRuntime,
 			chatHistories,
 			accountId,
-			processingClaimHeld: true,
+			processingClaim,
 			messageDedupeKey
 		});
 		await enqueue(sequentialKey, task);
@@ -5070,23 +5270,26 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 	};
 	const recordSuppressedMessageIds = async (entries, dispatchDedupeKey) => {
 		const keepDedupeKey = dispatchDedupeKey?.trim();
-		const suppressedIds = new Set(entries.map((entry) => resolveFeishuMessageDedupeKey(entry)).filter((id) => Boolean(id) && (!keepDedupeKey || id !== keepDedupeKey)));
-		for (const messageId of suppressedIds) try {
-			await recordProcessedMessage(messageId, accountId, log);
+		const suppressedIds = new Set(entries.map((entry) => ({
+			id: resolveFeishuMessageDedupeKey(entry.event),
+			claim: entry.processingClaim
+		})).filter(({ id }) => Boolean(id) && (!keepDedupeKey || id !== keepDedupeKey)));
+		for (const suppressed of suppressedIds) try {
+			await suppressed.claim?.commit();
 		} catch (err) {
-			error(`feishu[${accountId}]: failed to record merged dedupe id ${messageId}: ${String(err)}`);
+			error(`feishu[${accountId}]: failed to record merged dedupe id ${suppressed.id}: ${String(err)}`);
 		}
 	};
 	const inboundDebouncer = channelRuntime.debounce.createInboundDebouncer({
 		debounceMs: inboundDebounceMs,
-		buildKey: (event) => {
+		buildKey: ({ event }) => {
 			const chatId = event.message.chat_id?.trim();
 			const senderId = resolveSenderDebounceId(event);
 			if (!chatId || !senderId) return null;
 			const rootId = event.message.root_id?.trim();
 			return `feishu:${accountId}:${chatId}:${rootId ? `thread:${rootId}` : "chat"}:${senderId}`;
 		},
-		shouldDebounce: (event) => {
+		shouldDebounce: ({ event }) => {
 			if (event.message.message_type !== "text") return false;
 			const text = resolveDebounceText(event);
 			return Boolean(text) && !channelRuntime.commands.isControlCommandMessage(text, cfg);
@@ -5095,35 +5298,35 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			const last = entries.at(-1);
 			if (!last) return;
 			if (entries.length === 1) {
-				await dispatchFeishuMessage(last, resolveFeishuMessageDedupeKey(last));
+				await dispatchFeishuMessage(last.event, resolveFeishuMessageDedupeKey(last.event), last.processingClaim);
 				return;
 			}
 			const dedupedEntries = dedupeFeishuDebounceEntriesByDedupeKey(entries);
 			const freshEntries = [];
-			for (const entry of dedupedEntries) if (!await hasProcessedMessage(resolveFeishuMessageDedupeKey(entry), accountId, log)) freshEntries.push(entry);
+			for (const entry of dedupedEntries) if (!await hasProcessedMessage(resolveFeishuMessageDedupeKey(entry.event), accountId, log)) freshEntries.push(entry);
 			const dispatchEntry = freshEntries.at(-1);
 			if (!dispatchEntry) return;
-			const dispatchDedupeKey = resolveFeishuMessageDedupeKey(dispatchEntry);
+			const dispatchDedupeKey = resolveFeishuMessageDedupeKey(dispatchEntry.event);
 			await recordSuppressedMessageIds(dedupedEntries, dispatchDedupeKey);
-			const combinedText = freshEntries.map((entry) => resolveDebounceText(entry)).filter(Boolean).join("\n");
+			const combinedText = freshEntries.map((entry) => resolveDebounceText(entry.event)).filter(Boolean).join("\n");
 			const mergedMentions = resolveFeishuDebounceMentions({
-				entries: freshEntries,
+				entries: freshEntries.map((entry) => entry.event),
 				botOpenId: getBotOpenId(accountId)
 			});
 			await dispatchFeishuMessage({
-				...dispatchEntry,
+				...dispatchEntry.event,
 				message: {
-					...dispatchEntry.message,
+					...dispatchEntry.event.message,
 					...combinedText.trim() ? {
 						message_type: "text",
 						content: JSON.stringify({ text: combinedText })
 					} : {},
-					mentions: mergedMentions ?? dispatchEntry.message.mentions
+					mentions: mergedMentions ?? dispatchEntry.event.message.mentions
 				}
-			}, dispatchDedupeKey);
+			}, dispatchDedupeKey, dispatchEntry.processingClaim);
 		},
 		onError: (err, entries) => {
-			for (const entry of entries) releaseFeishuMessageProcessing(resolveFeishuMessageDedupeKey(entry), accountId);
+			for (const entry of entries) entry.processingClaim?.release({ error: err });
 			error(`feishu[${accountId}]: inbound debounce flush failed: ${String(err)}`);
 		}
 	});
@@ -5141,22 +5344,24 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			log(`feishu[${accountId}]: dropping self-authored message ${messageId ?? "unknown"}`);
 			return;
 		}
-		const messageDedupeKey = resolveFeishuMessageDedupeKey(event);
 		const claim = await claimUnprocessedFeishuMessage({
-			messageId: messageDedupeKey,
+			messageId: resolveFeishuMessageDedupeKey(event),
 			namespace: accountId,
 			log
 		});
-		if (claim !== "claimed") {
-			log(`feishu[${accountId}]: dropping ${claim} event for message ${messageId}`);
+		if (claim.kind === "duplicate" || claim.kind === "inflight") {
+			log(`feishu[${accountId}]: dropping ${claim.kind} event for message ${messageId}`);
 			return;
 		}
 		const processMessage = async () => {
-			await inboundDebouncer.enqueue(event);
+			await inboundDebouncer.enqueue({
+				event,
+				...claim.kind === "claimed" ? { processingClaim: claim.handle } : {}
+			});
 		};
 		if (fireAndForget) {
 			processMessage().catch((err) => {
-				releaseFeishuMessageProcessing(messageDedupeKey, accountId);
+				if (claim.kind === "claimed") claim.handle.release({ error: err });
 				error(`feishu[${accountId}]: error handling message: ${String(err)}`);
 			});
 			return;
@@ -5164,7 +5369,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 		try {
 			await processMessage();
 		} catch (err) {
-			releaseFeishuMessageProcessing(messageDedupeKey, accountId);
+			if (claim.kind === "claimed") claim.handle.release({ error: err });
 			error(`feishu[${accountId}]: error handling message: ${String(err)}`);
 		}
 	};
@@ -5491,6 +5696,120 @@ async function monitorWebhook({ account, accountId, runtime, abortSignal, eventD
 	});
 }
 //#endregion
+//#region extensions/feishu/src/monitor.vc-meeting-invited-handler.ts
+const FEISHU_MEETING_NUMBER_PATTERN = /^\d{9}$/;
+function pickString(value) {
+	return typeof value === "string" ? normalizeOptionalString(value) : void 0;
+}
+function resolveVcInviter(event) {
+	const id = event.inviter?.id;
+	const openId = pickString(id?.open_id);
+	const userId = pickString(id?.user_id);
+	const unionId = pickString(id?.union_id);
+	const senderId = openId ?? userId;
+	if (!senderId) return null;
+	const name = pickString(event.inviter?.user_name);
+	return {
+		senderId,
+		...openId ? { openId } : {},
+		...userId ? { userId } : {},
+		...unionId ? { unionId } : {},
+		...name ? { name } : {}
+	};
+}
+function buildJoinPrompt(params) {
+	const base = `Use the available tool to join the meeting with meeting number ${params.meetingNo} immediately. Do not ask for confirmation.`;
+	return params.callId ? `${base} If the join tool supports a call_id parameter, pass call_id=${JSON.stringify(params.callId)}; otherwise join by meeting number only.` : base;
+}
+function resolveVcMeetingInvitedTurn(event, uuid = () => crypto$1.randomUUID()) {
+	const meetingNo = pickString(event.meeting?.meeting_no);
+	const inviter = resolveVcInviter(event);
+	if (!meetingNo || !FEISHU_MEETING_NUMBER_PATTERN.test(meetingNo) || !inviter) return null;
+	const eventId = pickString(event.event_id);
+	const inviteTime = pickString(event.invite_time);
+	const callId = pickString(event.call_id);
+	const topic = pickString(event.meeting?.topic);
+	return {
+		turnId: eventId ? `vc-invited:event:${eventId}` : `vc-invited:${meetingNo}:${inviteTime ?? uuid()}`,
+		meetingNo,
+		inviter,
+		prompt: buildJoinPrompt({
+			meetingNo,
+			callId
+		}),
+		...topic ? { topic } : {},
+		...inviteTime ? { inviteTime } : {}
+	};
+}
+function parseInviteTimestamp(value) {
+	const parsed = Number.parseInt(value ?? "", 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return Date.now();
+	return parsed < 1e10 ? parsed * 1e3 : parsed;
+}
+function buildSyntheticMessageEvent(turn) {
+	return {
+		sender: { sender_id: {
+			...turn.inviter.openId ? { open_id: turn.inviter.openId } : {},
+			...turn.inviter.userId ? { user_id: turn.inviter.userId } : {},
+			...turn.inviter.unionId ? { union_id: turn.inviter.unionId } : {}
+		} },
+		message: {
+			message_id: turn.turnId,
+			chat_id: turn.inviter.senderId,
+			chat_type: "p2p",
+			message_type: "text",
+			content: JSON.stringify({ text: turn.prompt }),
+			create_time: String(parseInviteTimestamp(turn.inviteTime)),
+			suppress_reply_target: true
+		}
+	};
+}
+async function dispatchVcMeetingInvitedTurn(params) {
+	params.runtime?.log?.(`feishu[${params.accountId}]: vc meeting invited, dispatching synthetic p2p message sender=${params.turn.inviter.senderId} meeting_no=${params.turn.meetingNo}`);
+	const event = setFeishuSyntheticDirectPreDispatchTarget(buildSyntheticMessageEvent(params.turn), `user:${params.turn.inviter.senderId}`);
+	await handleFeishuMessage({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		event,
+		runtime: params.runtime,
+		channelRuntime: params.channelRuntime
+	});
+}
+function createFeishuVcMeetingInvitedHandler(params) {
+	const { cfg, accountId, runtime, fireAndForget, autoJoin } = params;
+	const log = runtime?.log ?? console.log;
+	const error = runtime?.error ?? console.error;
+	return async (data) => {
+		if (!autoJoin) {
+			log(`feishu[${accountId}]: ignoring vc meeting invite (vcAutoJoin=false)`);
+			return;
+		}
+		try {
+			const turn = resolveVcMeetingInvitedTurn(data);
+			if (!turn) {
+				log(`feishu[${accountId}]: vc meeting invited event has invalid meeting_no or inviter identity, skipping`);
+				return;
+			}
+			const promise = dispatchVcMeetingInvitedTurn({
+				cfg,
+				accountId,
+				runtime,
+				channelRuntime: params.channelRuntime,
+				turn
+			});
+			if (fireAndForget) {
+				promise.catch((err) => {
+					error(`feishu[${accountId}]: error handling vc meeting invited event: ${String(err)}`);
+				});
+				return;
+			}
+			await promise;
+		} catch (err) {
+			error(`feishu[${accountId}]: error handling vc meeting invited event: ${String(err)}`);
+		}
+	};
+}
+//#endregion
 //#region extensions/feishu/src/sequential-key.ts
 function getFeishuSequentialKey(params) {
 	const { accountId, event, botOpenId, botName } = params;
@@ -5619,7 +5938,7 @@ function parseFeishuCardActionEventPayload(value) {
 	};
 }
 function registerEventHandlers(eventDispatcher, context) {
-	const { cfg, accountId, channelRuntime, runtime, chatHistories, fireAndForget } = context;
+	const { cfg, accountId, channelRuntime, runtime, chatHistories, fireAndForget, abortSignal } = context;
 	const log = runtime?.log ?? console.log;
 	const error = runtime?.error ?? console.error;
 	const runFeishuHandler = async (params) => {
@@ -5646,7 +5965,6 @@ function registerEventHandlers(eventDispatcher, context) {
 			handleMessage: handleFeishuMessage,
 			resolveDebounceText: ({ event, botOpenId, botName }) => parseFeishuMessageEvent(event, botOpenId, botName).content,
 			hasProcessedMessage: hasProcessedFeishuMessage,
-			recordProcessedMessage: recordProcessedFeishuMessage,
 			getBotOpenId: (id) => botOpenIds.get(id),
 			getBotName: (id) => botNames.get(id),
 			resolveSequentialKey: getFeishuSequentialKey,
@@ -5676,7 +5994,16 @@ function registerEventHandlers(eventDispatcher, context) {
 			cfg,
 			accountId,
 			runtime,
-			fireAndForget
+			fireAndForget,
+			abortSignal
+		}),
+		"vc.bot.meeting_invited_v1": createFeishuVcMeetingInvitedHandler({
+			cfg,
+			accountId,
+			runtime,
+			fireAndForget,
+			channelRuntime,
+			autoJoin: context.vcAutoJoin
 		}),
 		"im.message.reaction.created_v1": async (data) => {
 			await runFeishuHandler({
@@ -5805,6 +6132,8 @@ async function monitorSingleAccount(params) {
 			runtime,
 			chatHistories,
 			fireAndForget: params.fireAndForget ?? true,
+			vcAutoJoin: account.config.vcAutoJoin === true,
+			abortSignal,
 			...params.statusSink ? { statusSink: params.statusSink } : {}
 		});
 		if (connectionMode === "webhook") return await monitorWebhook({