@openclaw/feishu 2026.7.1 → 2026.7.2-beta.2

package/dist/{monitor.account-Dr7do33p.js → monitor.account-BSRV2hIF.js}

@@ -1,45 +1,88 @@
-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-Bs5uJ4h0.js";
+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 normalizeFeishuAllowEntry, d as resolveFeishuGroupConversationIngressAccess, f as resolveFeishuGroupSenderActivationIngressAccess, l as resolveFeishuDmIngressAccess, p as resolveFeishuReplyPolicy, s as hasExplicitFeishuGroupConfig, u as resolveFeishuGroupConfig } from "./channel-DRQRQQQ3.js";
-import { d as decodeFeishuCardAction, l as buildFeishuCardActionTextFallback, o as resolveFeishuCardTemplate, u as createFeishuCardInteractionEnvelope } from "./send-result-BMQw-YhV.js";
-import { o as resolveConfiguredFeishuGroupSessionScope, t as buildFeishuConversationId } from "./conversation-id-CdLdoot3.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-DsqTk27v.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-B7EAV_Ss.js";
-import { i as createCommentTypingReactionLifecycle, s as getChatInfo, t as deliverCommentThreadText } from "./drive-D0lIhxqZ.js";
+import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-B4E8OXZ0.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-Be2GMA6Z.js";
-import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-Dxyo9zlw.js";
-import { a as clearFeishuBotIdentityState, c as httpServers, d as wsClients, f as fetchBotIdentityForMonitor, i as botOpenIds, l as recordWebhookStatus, n as FEISHU_WEBHOOK_MAX_BODY_BYTES, o as closeTrackedFeishuHttpServer, r as botNames, s as feishuWebhookRateLimiter, t as FEISHU_WEBHOOK_BODY_TIMEOUT_MS, u as setFeishuBotIdentityState } from "./monitor.state-DAHbcR2N.js";
-import { createChannelMessageReplyPipeline, formatChannelProgressDraftLineForEntry, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity } from "openclaw/plugin-sdk/channel-outbound";
+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-DrWM_Ilf.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";
 import { asDateTimestampMs, isFutureDateTimestampMs, parseStrictNonNegativeInteger, resolveDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveExpiresAtMsFromDurationSeconds, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { asBoolean, asNullableRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readStringValue, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
+import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 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 { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import * as Lark from "@larksuiteoapi/node-sdk";
-import * as crypto$1 from "node:crypto";
-import crypto, { createHash } from "node:crypto";
-import { applyBasicWebhookRequestGuards, resolveRequestClientIp } from "openclaw/plugin-sdk/webhook-ingress";
+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 { 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 { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
-import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-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 { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
 import * as http from "node:http";
 import { installRequestBodyLimitGuard, readWebhookBodyOrReject } from "openclaw/plugin-sdk/webhook-request-guards";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
+//#region extensions/feishu/src/bot-agent-body.ts
+const MAX_MENTION_CONTEXT_NAME_LENGTH = 80;
+function formatMentionNameForAgentContext(name) {
+	const normalized = Array.from(name, (char) => {
+		return char.charCodeAt(0) < 32 || char === "[" || char === "]" ? " " : char;
+	}).join("").replace(/\s+/g, " ").trim();
+	const bounded = normalized.length > MAX_MENTION_CONTEXT_NAME_LENGTH ? `${truncateUtf16Safe(normalized, MAX_MENTION_CONTEXT_NAME_LENGTH - 3)}...` : normalized;
+	return JSON.stringify(bounded || "unknown");
+}
+function buildFeishuAgentBody(params) {
+	const { ctx, quotedContent, permissionErrorForAgent, botOpenId } = params;
+	let messageBody = ctx.content;
+	if (quotedContent) messageBody = `[Replying to: "${quotedContent}"]\n\n${ctx.content}`;
+	messageBody = `${ctx.senderName ?? ctx.senderOpenId}: ${messageBody}`;
+	if (ctx.hasAnyMention) {
+		const botIdHint = botOpenId?.trim();
+		messageBody += "\n\n[System: The content may include mention tags in the form <at user_id=\"...\">name</at>. Treat these as real mentions of Feishu entities (users or bots).]";
+		if (botIdHint) messageBody += `\n[System: If user_id is "${botIdHint}", that mention refers to you.]`;
+	}
+	if (ctx.mentionTargets && ctx.mentionTargets.length > 0) {
+		const targetNames = ctx.mentionTargets.map((target) => formatMentionNameForAgentContext(target.name)).join(", ");
+		messageBody += `\n\n[System: Feishu users mentioned in the incoming message, for context only: ${targetNames}. Do not notify or mention these users solely because they are listed here.]`;
+	}
+	messageBody = `[message_id: ${ctx.messageId}]\n${messageBody}`;
+	if (permissionErrorForAgent) {
+		const grantUrl = permissionErrorForAgent.grantUrl ?? "";
+		messageBody += `\n\n[System: The bot encountered a Feishu API permission error. Please inform the user about this issue and provide the permission grant URL for the admin to authorize. Permission grant URL: ${grantUrl}]`;
+	}
+	return messageBody;
+}
+//#endregion
+//#region extensions/feishu/src/bot-broadcast.ts
+function resolveBroadcastAgents(cfg, peerId) {
+	const broadcast = cfg.broadcast;
+	if (!broadcast || typeof broadcast !== "object") return null;
+	const agents = broadcast[peerId];
+	return Array.isArray(agents) && agents.length > 0 ? agents : null;
+}
+function buildBroadcastSessionKey(baseSessionKey, originalAgentId, targetAgentId) {
+	const prefix = `agent:${originalAgentId}:`;
+	return baseSessionKey.startsWith(prefix) ? `agent:${targetAgentId}:${baseSessionKey.slice(prefix.length)}` : baseSessionKey;
+}
+//#endregion
 //#region extensions/feishu/src/bot-content.ts
 function resolveFeishuGroupSession(params) {
 	const { chatId, senderOpenId, messageId, rootId, threadId, chatType, groupConfig, feishuCfg } = params;
@@ -376,6 +419,65 @@ async function resolveFeishuMediaList(params) {
 	};
 }
 //#endregion
+//#region extensions/feishu/src/bot-group-name-state.ts
+const feishuGroupNameCache = /* @__PURE__ */ new Map();
+//#endregion
+//#region extensions/feishu/src/bot-group-name.ts
+const GROUP_NAME_CACHE_TTL_MS = 1800 * 1e3;
+const GROUP_NAME_CACHE_MAX_SIZE = 500;
+function evictGroupNameCache() {
+	const now = asDateTimestampMs(Date.now());
+	if (now === void 0) {
+		feishuGroupNameCache.clear();
+		return;
+	}
+	for (const [key, value] of feishuGroupNameCache) {
+		const expiresAt = asDateTimestampMs(value.expiresAt);
+		if (expiresAt === void 0 || expiresAt <= now) feishuGroupNameCache.delete(key);
+	}
+	const excess = feishuGroupNameCache.size - GROUP_NAME_CACHE_MAX_SIZE;
+	if (excess <= 0) return;
+	let removed = 0;
+	for (const key of feishuGroupNameCache.keys()) {
+		if (removed >= excess) break;
+		feishuGroupNameCache.delete(key);
+		removed++;
+	}
+}
+function setCacheEntry(key, name) {
+	const expiresAt = resolveExpiresAtMsFromDurationMs(GROUP_NAME_CACHE_TTL_MS);
+	feishuGroupNameCache.delete(key);
+	if (expiresAt !== void 0) feishuGroupNameCache.set(key, {
+		name,
+		expiresAt
+	});
+}
+async function resolveGroupName(params) {
+	const { account, chatId, log } = params;
+	if (!account.configured) return;
+	const cacheKey = `${account.accountId}:${chatId}`;
+	const cached = feishuGroupNameCache.get(cacheKey);
+	if (cached) {
+		const now = asDateTimestampMs(Date.now());
+		const expiresAt = asDateTimestampMs(cached.expiresAt);
+		if (now !== void 0 && expiresAt !== void 0 && expiresAt > now) return cached.name || void 0;
+		feishuGroupNameCache.delete(cacheKey);
+	}
+	let resolvedName;
+	try {
+		const name = (await getChatInfo(createFeishuClient(account), chatId))?.name?.trim();
+		if (name) {
+			setCacheEntry(cacheKey, name);
+			resolvedName = name;
+		} else setCacheEntry(cacheKey, "");
+	} catch (err) {
+		log(`feishu[${account.accountId}]: getChatInfo failed for ${chatId}: ${String(err)}`);
+		setCacheEntry(cacheKey, "");
+	}
+	evictGroupNameCache();
+	return resolvedName;
+}
+//#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" };
@@ -455,207 +557,79 @@ async function resolveFeishuSenderName(params) {
 	}
 }
 //#endregion
-//#region extensions/feishu/src/processing-claims.ts
-const EVENT_DEDUP_TTL_MS = 300 * 1e3;
-const EVENT_MEMORY_MAX_SIZE = 2e3;
-const processingClaims = /* @__PURE__ */ new Map();
-function resolveEventDedupeKey(namespace, messageId) {
-	const trimmed = messageId?.trim();
-	return trimmed ? `${namespace}:${trimmed}` : null;
-}
-function pruneProcessingClaims(now) {
-	const cutoff = now - EVENT_DEDUP_TTL_MS;
-	for (const [key, seenAt] of processingClaims) if (seenAt < cutoff) processingClaims.delete(key);
-	while (processingClaims.size > EVENT_MEMORY_MAX_SIZE) {
-		const oldestKey = processingClaims.keys().next().value;
-		if (!oldestKey) return;
-		processingClaims.delete(oldestKey);
-	}
-}
-function tryBeginFeishuMessageProcessing(messageId, namespace = "global") {
-	const key = resolveEventDedupeKey(namespace, messageId);
-	if (!key) return true;
-	const now = Date.now();
-	pruneProcessingClaims(now);
-	if (processingClaims.has(key)) {
-		processingClaims.delete(key);
-		processingClaims.set(key, now);
-		pruneProcessingClaims(now);
-		return false;
-	}
-	processingClaims.set(key, now);
-	pruneProcessingClaims(now);
-	return true;
-}
-function releaseFeishuMessageProcessing(messageId, namespace = "global") {
-	const key = resolveEventDedupeKey(namespace, messageId);
-	if (key) processingClaims.delete(key);
-}
-//#endregion
-//#region extensions/feishu/src/dedup.ts
+//#region extensions/feishu/src/dedup-state.ts
+const DEDUPE_NAMESPACE_PREFIX = "feishu.dedup";
 const DEDUP_TTL_MS = 1440 * 60 * 1e3;
 const MEMORY_MAX_SIZE = 1e3;
 const STORE_MAX_ENTRIES = 1e4;
-const memory = /* @__PURE__ */ new Map();
-const cachedDedupStores = /* @__PURE__ */ new Map();
-function normalizeMessageId(messageId) {
-	const trimmed = messageId?.trim();
-	return trimmed ? trimmed : null;
-}
-function normalizeNamespace(namespace) {
-	return namespace?.trim() || "global";
-}
-function pluginStateNamespace(namespace) {
-	return `dedup.${namespace.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-}
-function openDedupStore(namespace) {
-	const stateNamespace = pluginStateNamespace(namespace);
-	const cached = cachedDedupStores.get(stateNamespace);
-	if (cached) return cached;
-	const store = getFeishuRuntime().state.openSyncKeyedStore({
-		namespace: stateNamespace,
-		maxEntries: STORE_MAX_ENTRIES,
-		defaultTtlMs: DEDUP_TTL_MS
+function createFeishuDedupeGuard() {
+	return createChannelReplayGuard({
+		dedupe: {
+			pluginId: "feishu",
+			namespacePrefix: DEDUPE_NAMESPACE_PREFIX,
+			ttlMs: DEDUP_TTL_MS,
+			memoryMaxSize: MEMORY_MAX_SIZE,
+			stateMaxEntries: STORE_MAX_ENTRIES
+		},
+		buildReplayKey: (messageId) => messageId
 	});
-	cachedDedupStores.set(stateNamespace, store);
-	return store;
-}
-function dedupeStoreKey(namespace, messageId) {
-	return createHash("sha256").update(`${namespace}\0${messageId}`, "utf8").digest("hex").slice(0, 32);
-}
-function memoryKey(namespace, messageId) {
-	return `${namespace}\0${messageId}`;
-}
-function isRecent(seenAt, now = Date.now()) {
-	return typeof seenAt === "number" && Number.isFinite(seenAt) && now - seenAt < DEDUP_TTL_MS;
-}
-function pruneMemory(now = Date.now()) {
-	for (const [key, seenAt] of memory) if (!isRecent(seenAt, now)) memory.delete(key);
-	if (memory.size <= MEMORY_MAX_SIZE) return;
-	const toRemove = Array.from(memory.entries()).toSorted(([, left], [, right]) => left - right).slice(0, memory.size - MEMORY_MAX_SIZE);
-	for (const [key] of toRemove) memory.delete(key);
 }
-function remember(namespace, messageId, seenAt = Date.now()) {
-	memory.set(memoryKey(namespace, messageId), seenAt);
-	pruneMemory(seenAt);
+const feishuDedupeState = {
+	guard: createFeishuDedupeGuard(),
+	reset() {
+		this.guard = createFeishuDedupeGuard();
+	}
+};
+//#endregion
+//#region extensions/feishu/src/dedup.ts
+function dedupeKey(messageId) {
+	return messageId?.trim() ?? "";
 }
-function hasMemory(namespace, messageId, now = Date.now()) {
-	const key = memoryKey(namespace, messageId);
-	if (isRecent(memory.get(key), now)) return true;
-	memory.delete(key);
-	return false;
+function dedupeOptions(namespace, log) {
+	return {
+		...namespace ? { namespace } : {},
+		...log ? { onDiskError: (error) => log(`feishu-dedup: persistent state error: ${String(error)}`) } : {}
+	};
 }
+/**
+* Claims a dedupe key for exclusive handling. Duplicate (already committed)
+* and in-flight keys are reported; blank keys fail open as invalid so an
+* unidentifiable event is never suppressed.
+*/
 async function claimUnprocessedFeishuMessage(params) {
-	const { messageId, namespace = "global", log } = params;
-	const normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return "invalid";
-	if (await hasProcessedFeishuMessage(normalizedMessageId, namespace, log)) return "duplicate";
-	if (!tryBeginFeishuMessageProcessing(normalizedMessageId, namespace)) return "inflight";
-	return "claimed";
+	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.
+* False means another handler owns it, it was already handled, or the key is
+* blank; handlers must skip dispatch then.
+*/
 async function finalizeFeishuMessageProcessing(params) {
-	const { messageId, namespace = "global", log, claimHeld = false } = params;
-	const normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return false;
-	if (!claimHeld && !tryBeginFeishuMessageProcessing(normalizedMessageId, namespace)) return false;
-	if (!await tryRecordMessagePersistent(normalizedMessageId, namespace, log)) {
-		releaseFeishuMessageProcessing(normalizedMessageId, namespace);
-		return false;
-	}
-	return true;
-}
+	const key = dedupeKey(params.messageId);
+	if (!key) return false;
+	const options = dedupeOptions(params.namespace, params.log);
+	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 normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return false;
-	return await tryRecordMessagePersistent(normalizedMessageId, 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 normalizedNamespace = normalizeNamespace(namespace);
-	const normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return false;
-	memory.delete(memoryKey(normalizedNamespace, normalizedMessageId));
-	const key = dedupeStoreKey(normalizedNamespace, normalizedMessageId);
-	try {
-		return openDedupStore(normalizedNamespace).delete(key);
-	} catch (error) {
-		log?.(`feishu-dedup: persistent delete failed: ${String(error)}`);
-		return false;
-	}
+	return await feishuDedupeState.guard.forget(messageId, dedupeOptions(namespace, log));
 }
+/** Checks recency without claiming or recording. */
 async function hasProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return false;
-	return hasRecordedMessagePersistent(normalizedMessageId, namespace, log);
-}
-async function tryRecordMessagePersistent(messageId, namespace = "global", log) {
-	const normalizedNamespace = normalizeNamespace(namespace);
-	const normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return true;
-	const now = Date.now();
-	if (hasMemory(normalizedNamespace, normalizedMessageId, now)) return false;
-	const key = dedupeStoreKey(normalizedNamespace, normalizedMessageId);
-	try {
-		const store = openDedupStore(normalizedNamespace);
-		const existingSeenAt = store.lookup(key)?.seenAt;
-		if (isRecent(existingSeenAt, now)) {
-			remember(normalizedNamespace, normalizedMessageId, existingSeenAt);
-			return false;
-		}
-		if (!store.registerIfAbsent(key, {
-			namespace: normalizedNamespace,
-			messageId: normalizedMessageId,
-			seenAt: now
-		}, { ttlMs: DEDUP_TTL_MS })) {
-			const currentSeenAt = store.lookup(key)?.seenAt;
-			if (isRecent(currentSeenAt, now)) {
-				remember(normalizedNamespace, normalizedMessageId, currentSeenAt);
-				return false;
-			}
-			store.register(key, {
-				namespace: normalizedNamespace,
-				messageId: normalizedMessageId,
-				seenAt: now
-			}, { ttlMs: DEDUP_TTL_MS });
-		}
-		remember(normalizedNamespace, normalizedMessageId, now);
-		return true;
-	} catch (error) {
-		log?.(`feishu-dedup: persistent state error, falling back to memory: ${String(error)}`);
-		remember(normalizedNamespace, normalizedMessageId, now);
-		return true;
-	}
-}
-async function hasRecordedMessagePersistent(messageId, namespace = "global", log) {
-	const normalizedNamespace = normalizeNamespace(namespace);
-	const normalizedMessageId = normalizeMessageId(messageId);
-	if (!normalizedMessageId) return false;
-	const now = Date.now();
-	if (hasMemory(normalizedNamespace, normalizedMessageId, now)) return true;
-	try {
-		const existingSeenAt = openDedupStore(normalizedNamespace).lookup(dedupeStoreKey(normalizedNamespace, normalizedMessageId))?.seenAt;
-		if (!isRecent(existingSeenAt, now)) return false;
-		remember(normalizedNamespace, normalizedMessageId, existingSeenAt);
-		return true;
-	} catch (error) {
-		log?.(`feishu-dedup: persistent peek failed: ${String(error)}`);
-		return hasMemory(normalizedNamespace, normalizedMessageId, now);
-	}
+	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) {
-	const normalizedNamespace = normalizeNamespace(namespace);
-	try {
-		let loaded = 0;
-		const now = Date.now();
-		for (const entry of openDedupStore(normalizedNamespace).entries()) {
-			if (entry.value.namespace !== normalizedNamespace || !isRecent(entry.value.seenAt, now)) continue;
-			remember(normalizedNamespace, entry.value.messageId, entry.value.seenAt);
-			loaded++;
-		}
-		return loaded;
-	} catch (error) {
-		log?.(`feishu-dedup: warmup persistent state error: ${String(error)}`);
-		return 0;
-	}
+	return await feishuDedupeState.guard.warmup(namespace, (error) => log?.(`feishu-dedup: warmup persistent state error: ${String(error)}`));
 }
 //#endregion
 //#region extensions/feishu/src/dedupe-key.ts
@@ -902,6 +876,16 @@ function resolveFeishuReasoningPreviewEnabled(params) {
 	return configDefault === "stream";
 }
 //#endregion
+//#region extensions/feishu/src/reply-dispatcher-state.ts
+const streamingStartBackoffUntilByAccount = /* @__PURE__ */ new Map();
+//#endregion
+//#region extensions/feishu/src/streaming-card-send-mode.ts
+function resolveStreamingCardSendMode(options) {
+	if (options?.replyToMessageId) return "reply";
+	if (options?.rootId) return "root_create";
+	return "create";
+}
+//#endregion
 //#region extensions/feishu/src/streaming-card.ts
 const STREAMING_UPDATE_THROTTLE_MS = 160;
 const STREAMING_SIGNIFICANT_DELTA_CHARS = 18;
@@ -926,6 +910,11 @@ function resolveAllowedHostnames(domain) {
 	}
 	return ["open.feishu.cn"];
 }
+async function assertSuccessfulCardKitResponse(response, auditContext, action) {
+	if (!response.ok) throw new Error(`${action} failed with HTTP ${response.status}`);
+	const data = await readFeishuJsonResponse(response, auditContext);
+	if (data.code !== 0) throw new Error(`${action} failed: ${data.msg ?? "unknown error"} (code=${String(data.code)})`);
+}
 async function getToken(creds, deps) {
 	const key = `${creds.domain ?? "feishu"}|${creds.appId}`;
 	const cached = tokenCache.get(key);
@@ -993,11 +982,6 @@ function mergeStreamingText(previousText, nextText) {
 	for (let overlap = maxOverlap; overlap > 0; overlap -= 1) if (previous.slice(-overlap) === next.slice(0, overlap)) return `${previous}${next.slice(overlap)}`;
 	return `${previous}${next}`;
 }
-function resolveStreamingCardSendMode(options) {
-	if (options?.replyToMessageId) return "reply";
-	if (options?.rootId) return "root_create";
-	return "create";
-}
 /** Streaming card session manager */
 var FeishuStreamingSession = class {
 	constructor(client, creds, log, deps) {
@@ -1152,10 +1136,10 @@ var FeishuStreamingSession = class {
 				auditContext: "feishu.streaming-card.update",
 				timeoutMs: this.creds.httpTimeoutMs ?? 3e4
 			});
-			await release();
-			if (!response.ok) {
-				onError?.(/* @__PURE__ */ new Error(`Update card content failed with HTTP ${response.status}`));
-				return false;
+			try {
+				await assertSuccessfulCardKitResponse(response, "feishu.streaming-card.update", "Update card content");
+			} finally {
+				await release();
 			}
 			return true;
 		} catch (error) {
@@ -1196,10 +1180,10 @@ var FeishuStreamingSession = class {
 				auditContext: "feishu.streaming-card.replace",
 				timeoutMs: this.creds.httpTimeoutMs ?? 3e4
 			});
-			await release();
-			if (!response.ok) {
-				onError?.(/* @__PURE__ */ new Error(`Replace card content failed with HTTP ${response.status}`));
-				return false;
+			try {
+				await assertSuccessfulCardKitResponse(response, "feishu.streaming-card.replace", "Replace card content");
+			} finally {
+				await release();
 			}
 			return true;
 		} catch (error) {
@@ -1218,35 +1202,35 @@ var FeishuStreamingSession = class {
 		const delayMs = Math.max(0, this.updateThrottleMs - (Date.now() - this.lastUpdateTime));
 		this.flushTimer = setTimeout(() => {
 			this.flushTimer = null;
-			const pending = this.pendingText;
-			if (!pending || this.closed) return;
-			this.update(pending).catch((error) => this.log?.(`Scheduled flush update failed: ${String(error)}`));
+			if (!this.pendingText || this.closed) return;
+			this.lastUpdateTime = Date.now();
+			this.flushPendingUpdate().catch((error) => this.log?.(`Scheduled flush update failed: ${String(error)}`));
 		}, delayMs);
 	}
+	async flushPendingUpdate() {
+		this.queue = this.queue.then(async () => {
+			if (!this.state || this.closed) return;
+			const nextText = this.pendingText;
+			if (!nextText) return;
+			this.pendingText = null;
+			if (nextText === this.state.sentText) return;
+			if (await this.updateCardContent(nextText, (e) => this.log?.(`Update failed: ${String(e)}`)) && this.state) this.state.sentText = nextText;
+		});
+		await this.queue;
+	}
 	async update(text) {
-		if (!this.state || this.closed) return;
-		const mergedInput = mergeStreamingText(this.pendingText ?? this.state.currentText, text);
-		if (!mergedInput || mergedInput === this.state.currentText) return;
-		this.pendingText = mergedInput;
+		if (!this.state || this.closed || !text) return;
+		this.state.currentText = text;
+		this.pendingText = text;
 		this.clearFlushTimer();
-		const shouldForceUpdate = shouldPushStreamingUpdate(this.state.currentText, mergedInput);
+		const shouldForceUpdate = shouldPushStreamingUpdate(this.state.sentText, text);
 		const now = Date.now();
 		if (!shouldForceUpdate && now - this.lastUpdateTime < this.updateThrottleMs) {
 			this.schedulePendingFlush();
 			return;
 		}
 		this.lastUpdateTime = now;
-		this.queue = this.queue.then(async () => {
-			if (!this.state || this.closed) return;
-			const nextText = this.pendingText ?? mergedInput;
-			const mergedText = mergeStreamingText(this.state.currentText, nextText);
-			if (!mergedText || mergedText === this.state.currentText) return;
-			if (mergedText === this.state.sentText) return;
-			this.pendingText = null;
-			this.state.currentText = mergedText;
-			if (await this.updateCardContent(mergedText, (e) => this.log?.(`Update failed: ${String(e)}`)) && this.state) this.state.sentText = mergedText;
-		});
-		await this.queue;
+		await this.flushPendingUpdate();
 	}
 	async updateNoteContent(note) {
 		if (!this.state || !this.state.hasNote) return;
@@ -1275,8 +1259,12 @@ var FeishuStreamingSession = class {
 			policy: { allowedHostnames: resolveAllowedHostnames(this.creds.domain) },
 			auditContext: "feishu.streaming-card.note-update",
 			timeoutMs: this.creds.httpTimeoutMs ?? 3e4
-		}).then(async ({ release }) => {
-			await release();
+		}).then(async ({ response, release }) => {
+			try {
+				await assertSuccessfulCardKitResponse(response, "feishu.streaming-card.note-update", "Update card note");
+			} finally {
+				await release();
+			}
 		}).catch((e) => this.log?.(`Note update failed: ${String(e)}`));
 	}
 	async close(finalText, options) {
@@ -1284,8 +1272,7 @@ var FeishuStreamingSession = class {
 		this.closed = true;
 		this.clearFlushTimer();
 		await this.queue;
-		const pendingMerged = mergeStreamingText(this.state.currentText, this.pendingText ?? void 0);
-		const text = finalText ?? pendingMerged;
+		const text = finalText ?? this.pendingText ?? this.state.currentText;
 		const apiBase = resolveApiBase(this.creds.domain);
 		let visibleContentSent = Boolean(this.state.sentText.trim());
 		if ((text || finalText !== void 0) && text !== this.state.sentText) {
@@ -1297,6 +1284,7 @@ var FeishuStreamingSession = class {
 			}
 		}
 		if (options?.note) await this.updateNoteContent(options.note);
+		const acceptedText = this.state.sentText;
 		this.state.sequence += 1;
 		await fetchWithSsrFGuard({
 			url: `${apiBase}/cardkit/v1/cards/${this.state.cardId}/settings`,
@@ -1313,7 +1301,7 @@ var FeishuStreamingSession = class {
 				body: JSON.stringify({
 					settings: JSON.stringify({ config: {
 						streaming_mode: false,
-						summary: { content: truncateSummary(text) }
+						summary: { content: truncateSummary(acceptedText) }
 					} }),
 					sequence: this.state.sequence,
 					uuid: `c_${this.state.cardId}_${this.state.sequence}`
@@ -1324,8 +1312,12 @@ var FeishuStreamingSession = class {
 			policy: { allowedHostnames: resolveAllowedHostnames(this.creds.domain) },
 			auditContext: "feishu.streaming-card.close",
 			timeoutMs: this.creds.httpTimeoutMs ?? 3e4
-		}).then(async ({ release }) => {
-			await release();
+		}).then(async ({ response, release }) => {
+			try {
+				await assertSuccessfulCardKitResponse(response, "feishu.streaming-card.close", "Close streaming card");
+			} finally {
+				await release();
+			}
 		}).catch((e) => this.log?.(`Close failed: ${String(e)}`));
 		const finalState = this.state;
 		this.state = null;
@@ -1356,29 +1348,13 @@ var FeishuStreamingSession = class {
 	}
 };
 //#endregion
-//#region extensions/feishu/src/typing.ts
-const TYPING_EMOJI = "Typing";
-/**
-* Feishu API error codes that indicate the caller should back off.
-* These must propagate to the typing circuit breaker so the keepalive loop
-* can trip and stop retrying.
-*
-* - 99991400: Rate limit (too many requests per second)
-* - 99991403: Monthly API call quota exceeded
-* - 429: Standard HTTP 429 returned as a Feishu SDK error code
-*
-* @see https://open.feishu.cn/document/server-docs/api-call-guide/generic-error-code
-*/
+//#region extensions/feishu/src/typing-backoff.ts
+/** Feishu API codes that should trip the typing circuit breaker. */
 const FEISHU_BACKOFF_CODES = /* @__PURE__ */ new Set([
 	99991400,
 	99991403,
 	429
 ]);
-/**
-* Custom error class for Feishu backoff conditions detected from non-throwing
-* SDK responses. Carries a numeric `.code` so that `isFeishuBackoffError()`
-* recognises it when the error is caught downstream.
-*/
 var FeishuBackoffError = class extends Error {
 	constructor(code) {
 		super(`Feishu API backoff: code ${code}`);
@@ -1386,14 +1362,6 @@ var FeishuBackoffError = class extends Error {
 		this.code = code;
 	}
 };
-/**
-* Check whether an error represents a rate-limit or quota-exceeded condition
-* from the Feishu API that should stop the typing keepalive loop.
-*
-* Handles two shapes:
-* 1. AxiosError with `response.status` and `response.data.code`
-* 2. Feishu SDK error with a top-level `code` property
-*/
 function isFeishuBackoffError(err) {
 	if (typeof err !== "object" || err === null) return false;
 	const response = err.response;
@@ -1402,21 +1370,16 @@ function isFeishuBackoffError(err) {
 		if (typeof response.data?.code === "number" && FEISHU_BACKOFF_CODES.has(response.data.code)) return true;
 	}
 	const code = err.code;
-	if (typeof code === "number" && FEISHU_BACKOFF_CODES.has(code)) return true;
-	return false;
+	return typeof code === "number" && FEISHU_BACKOFF_CODES.has(code);
 }
-/**
-* Check whether a Feishu SDK response object contains a backoff error code.
-*
-* The Feishu SDK sometimes returns a normal response (no throw) with an
-* API-level error code in the response body. This must be detected so the
-* circuit breaker can trip. See codex review on #28157.
-*/
 function getBackoffCodeFromResponse(response) {
 	if (typeof response !== "object" || response === null) return;
 	const code = response.code;
-	if (typeof code === "number" && FEISHU_BACKOFF_CODES.has(code)) return code;
+	return typeof code === "number" && FEISHU_BACKOFF_CODES.has(code) ? code : void 0;
 }
+//#endregion
+//#region extensions/feishu/src/typing.ts
+const TYPING_EMOJI = "Typing";
 /**
 * Add a typing indicator (reaction) to a message.
 *
@@ -1512,7 +1475,6 @@ const TYPING_INDICATOR_MAX_AGE_MS = 2 * 6e4;
 const MS_EPOCH_MIN = 0xe8d4a51000;
 const STREAMING_START_FAILURE_BACKOFF_MS = 6e4;
 const NO_VISIBLE_REPLY_FALLBACK_TEXT = "⚠️ This reply completed without visible content. The turn may have been interrupted; please retry or ask me to recover from recent context.";
-const streamingStartBackoffUntilByAccount = /* @__PURE__ */ new Map();
 function isStreamingStartBackedOff(accountId, now = Date.now()) {
 	const backoffUntil = streamingStartBackoffUntilByAccount.get(accountId);
 	if (backoffUntil === void 0) return false;
@@ -1615,14 +1577,15 @@ function createFeishuReplyDispatcher(params) {
 		}
 	});
 	const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "feishu", accountId, { fallbackLimit: 4e3 });
-	const chunkMode = core.channel.text.resolveChunkMode(cfg, "feishu");
+	const chunkMode = core.channel.text.resolveChunkMode(cfg, "feishu", accountId);
 	const tableMode = core.channel.text.resolveMarkdownTableMode({
 		cfg,
 		channel: "feishu"
 	});
 	const renderMode = account.config?.renderMode ?? "auto";
-	const streamingEnabled = account.config?.streaming !== false && renderMode !== "raw";
-	const coreBlockStreamingEnabled = account.config?.blockStreaming === true;
+	const streamingEnabled = resolveChannelPreviewStreamMode(account.config, "partial") !== "off" && renderMode !== "raw";
+	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
+	const coreBlockStreamingEnabled = blockStreamingEnabled === true;
 	const reasoningPreviewEnabled = streamingEnabled && params.allowReasoningPreview === true;
 	let streaming = null;
 	let streamText = "";
@@ -1761,8 +1724,15 @@ function createFeishuReplyDispatcher(params) {
 		flushStreamingCardUpdate(buildCombinedStreamText(reasoningText, streamText));
 	};
 	const sendChunkedTextReply = async (paramsLocal) => {
-		const chunkSource = paramsLocal.useCard ? paramsLocal.text : core.channel.text.convertMarkdownTables(paramsLocal.text, tableMode);
-		const chunks = resolveTextChunksWithFallback(chunkSource, (paramsLocal.useCard ? core.channel.text.chunkMarkdownTextWithMode : core.channel.text.chunkTextWithMode)(chunkSource, textChunkLimit, chunkMode));
+		const chunkSource = paramsLocal.useCard ? paramsLocal.text : materializeFeishuPostMarkdownSoftBreaks(core.channel.text.convertMarkdownTables(paramsLocal.text, tableMode));
+		const initialChunks = core.channel.text.chunkMarkdownTextWithMode(chunkSource, textChunkLimit, chunkMode);
+		const chunks = resolveTextChunksWithFallback(chunkSource, paramsLocal.useCard ? initialChunks : chunkFeishuPostMarkdown({
+			text: chunkSource,
+			limit: textChunkLimit,
+			mode: chunkMode,
+			firstChunkMentions: paramsLocal.firstChunkMentions,
+			initialChunks
+		}));
 		for (const [index, chunk] of chunks.entries()) {
 			await paramsLocal.sendChunk({
 				chunk,
@@ -1914,11 +1884,12 @@ function createFeishuReplyDispatcher(params) {
 				if (info?.kind === "block") {
 					if (!useStreamingCard) {
 						if (coreBlockStreamingEnabled) {
-							const isFirstBlock = !sentIndependentBlockText;
+							const firstChunkMentions = !sentIndependentBlockText && mentionTargets?.length ? mentionTargets : void 0;
 							await sendChunkedTextReply({
 								text,
 								useCard: false,
 								infoKind: "block",
+								firstChunkMentions,
 								sendChunk: async ({ chunk, isFirst }) => {
 									await sendMessageFeishu({
 										cfg,
@@ -1928,7 +1899,7 @@ function createFeishuReplyDispatcher(params) {
 										replyInThread: effectiveReplyInThread,
 										allowTopLevelReplyFallback,
 										accountId,
-										...isFirstBlock && isFirst && mentionTargets?.length ? { mentions: mentionTargets } : {}
+										...isFirst && firstChunkMentions ? { mentions: firstChunkMentions } : {}
 									});
 								}
 							});
@@ -1981,23 +1952,27 @@ function createFeishuReplyDispatcher(params) {
 							});
 						}
 					});
-				} else await sendChunkedTextReply({
-					text,
-					useCard: false,
-					infoKind: info?.kind,
-					sendChunk: async ({ chunk, isFirst }) => {
-						await sendMessageFeishu({
-							cfg,
-							to: sendTarget,
-							text: chunk,
-							replyToMessageId: sendReplyToMessageId,
-							replyInThread: effectiveReplyInThread,
-							allowTopLevelReplyFallback,
-							accountId,
-							...info?.kind === "final" && isFirst && mentionTargets?.length ? { mentions: mentionTargets } : {}
-						});
-					}
-				});
+				} 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 } : {}
+							});
+						}
+					});
+				}
 			}
 			if (hasMedia) await sendMediaReplies(payload, hasVoiceMedia && hasText ? { fallbackText: text } : void 0);
 		},
@@ -2017,7 +1992,7 @@ function createFeishuReplyDispatcher(params) {
 		replyOptions: {
 			...replyOptions,
 			onModelSelected: prefixContext.onModelSelected,
-			disableBlockStreaming: typeof account.config?.blockStreaming === "boolean" ? !account.config.blockStreaming : true,
+			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : true,
 			onPartialReply: streamingEnabled ? (payload) => {
 				if (!payload.text) return;
 				const cleaned = stripReasoningTagsFromText(payload.text, {
@@ -2069,9 +2044,6 @@ function createFeishuReplyDispatcher(params) {
 //#region extensions/feishu/src/bot.ts
 const permissionErrorNotifiedAt = /* @__PURE__ */ new Map();
 const PERMISSION_ERROR_COOLDOWN_MS = 300 * 1e3;
-const groupNameCache = /* @__PURE__ */ new Map();
-const GROUP_NAME_CACHE_TTL_MS = 1800 * 1e3;
-const GROUP_NAME_CACHE_MAX_SIZE = 500;
 function shouldSendNoVisibleReplyFallback(dispatchResult) {
 	const finalCount = dispatchResult.counts.final ?? 0;
 	const failedFinalCount = dispatchResult.failedCounts?.final ?? 0;
@@ -2082,59 +2054,6 @@ function shouldSendNoVisibleReplyFallback(dispatchResult) {
 function isFeishuTopicSessionScope(scope) {
 	return scope === "group_topic" || scope === "group_topic_sender";
 }
-function evictGroupNameCache() {
-	const now = asDateTimestampMs(Date.now());
-	if (now === void 0) {
-		groupNameCache.clear();
-		return;
-	}
-	for (const [key, val] of groupNameCache) {
-		const expiresAt = asDateTimestampMs(val.expiresAt);
-		if (expiresAt === void 0 || expiresAt <= now) groupNameCache.delete(key);
-	}
-	if (groupNameCache.size > GROUP_NAME_CACHE_MAX_SIZE) {
-		const excess = groupNameCache.size - GROUP_NAME_CACHE_MAX_SIZE;
-		let removed = 0;
-		for (const key of groupNameCache.keys()) {
-			if (removed >= excess) break;
-			groupNameCache.delete(key);
-			removed++;
-		}
-	}
-}
-function setCacheEntry(key, name) {
-	const expiresAt = resolveExpiresAtMsFromDurationMs(GROUP_NAME_CACHE_TTL_MS);
-	groupNameCache.delete(key);
-	if (expiresAt !== void 0) groupNameCache.set(key, {
-		name,
-		expiresAt
-	});
-}
-async function resolveGroupName(params) {
-	const { account, chatId, log } = params;
-	if (!account.configured) return;
-	const cacheKey = `${account.accountId}:${chatId}`;
-	const cached = groupNameCache.get(cacheKey);
-	if (cached) {
-		const now = asDateTimestampMs(Date.now());
-		const expiresAt = asDateTimestampMs(cached.expiresAt);
-		if (now !== void 0 && expiresAt !== void 0 && expiresAt > now) return cached.name || void 0;
-		groupNameCache.delete(cacheKey);
-	}
-	let resolvedName;
-	try {
-		const name = (await getChatInfo(createFeishuClient(account), chatId))?.name?.trim();
-		if (name) {
-			setCacheEntry(cacheKey, name);
-			resolvedName = name;
-		} else setCacheEntry(cacheKey, "");
-	} catch (err) {
-		log(`feishu[${account.accountId}]: getChatInfo failed for ${chatId}: ${String(err)}`);
-		setCacheEntry(cacheKey, "");
-	}
-	evictGroupNameCache();
-	return resolvedName;
-}
 async function resolveFeishuAudioPreflightTranscript(params) {
 	if (params.content.trim() !== "<media:audio>") return;
 	const audioMedia = params.mediaList.filter((media) => media.contentType?.startsWith("audio/"));
@@ -2154,18 +2073,6 @@ async function resolveFeishuAudioPreflightTranscript(params) {
 		return;
 	}
 }
-function resolveBroadcastAgents(cfg, peerId) {
-	const broadcast = cfg.broadcast;
-	if (!broadcast || typeof broadcast !== "object") return null;
-	const agents = broadcast[peerId];
-	if (!Array.isArray(agents) || agents.length === 0) return null;
-	return agents;
-}
-function buildBroadcastSessionKey(baseSessionKey, originalAgentId, targetAgentId) {
-	const prefix = `agent:${originalAgentId}:`;
-	if (baseSessionKey.startsWith(prefix)) return `agent:${targetAgentId}:${baseSessionKey.slice(prefix.length)}`;
-	return baseSessionKey;
-}
 /**
 * Build media payload for inbound context.
 * Similar to Discord's buildDiscordMediaPayload().
@@ -2202,35 +2109,6 @@ function parseFeishuMessageEvent(event, botOpenId, _botName) {
 	}
 	return ctx;
 }
-const MAX_MENTION_CONTEXT_NAME_LENGTH = 80;
-function formatMentionNameForAgentContext(name) {
-	const normalized = Array.from(name, (char) => {
-		return char.charCodeAt(0) < 32 || char === "[" || char === "]" ? " " : char;
-	}).join("").replace(/\s+/g, " ").trim();
-	const bounded = normalized.length > MAX_MENTION_CONTEXT_NAME_LENGTH ? `${truncateUtf16Safe(normalized, MAX_MENTION_CONTEXT_NAME_LENGTH - 3)}...` : normalized;
-	return JSON.stringify(bounded || "unknown");
-}
-function buildFeishuAgentBody(params) {
-	const { ctx, quotedContent, permissionErrorForAgent, botOpenId } = params;
-	let messageBody = ctx.content;
-	if (quotedContent) messageBody = `[Replying to: "${quotedContent}"]\n\n${ctx.content}`;
-	messageBody = `${ctx.senderName ?? ctx.senderOpenId}: ${messageBody}`;
-	if (ctx.hasAnyMention) {
-		const botIdHint = botOpenId?.trim();
-		messageBody += "\n\n[System: The content may include mention tags in the form <at user_id=\"...\">name</at>. Treat these as real mentions of Feishu entities (users or bots).]";
-		if (botIdHint) messageBody += `\n[System: If user_id is "${botIdHint}", that mention refers to you.]`;
-	}
-	if (ctx.mentionTargets && ctx.mentionTargets.length > 0) {
-		const targetNames = ctx.mentionTargets.map((t) => formatMentionNameForAgentContext(t.name)).join(", ");
-		messageBody += `\n\n[System: Feishu users mentioned in the incoming message, for context only: ${targetNames}. Do not notify or mention these users solely because they are listed here.]`;
-	}
-	messageBody = `[message_id: ${ctx.messageId}]\n${messageBody}`;
-	if (permissionErrorForAgent) {
-		const grantUrl = permissionErrorForAgent.grantUrl ?? "";
-		messageBody += `\n\n[System: The bot encountered a Feishu API permission error. Please inform the user about this issue and provide the permission grant URL for the admin to authorize. Permission grant URL: ${grantUrl}]`;
-	}
-	return messageBody;
-}
 async function shouldIncludeFetchedGroupContextMessage(params) {
 	let senderAllowed = !params.isGroup || params.allowFrom.length === 0 || params.senderType === "app";
 	const senderId = params.senderId?.trim();
@@ -2264,7 +2142,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
@@ -2278,7 +2156,7 @@ async function handleFeishuMessage(params) {
 		messageId: messageDedupeKey,
 		namespace: account.accountId,
 		log,
-		claimHeld: processingClaimHeld
+		processingClaim
 	})) {
 		log(`feishu: skipping duplicate message ${messageId}`);
 		return;
@@ -2916,6 +2794,7 @@ async function handleFeishuMessage(params) {
 				conversation: {
 					kind: isGroup ? "group" : "direct",
 					id: ctx.chatId,
+					nativeChannelId: ctx.chatId,
 					label: isGroup && groupName && !isTopicSessionForThread ? groupName : void 0,
 					threadId: ctx.rootId && isTopicSessionForThread ? ctx.rootId : void 0
 				},
@@ -2942,7 +2821,7 @@ async function handleFeishuMessage(params) {
 						wasMentioned,
 						requireMention
 					},
-					commands: { authorized: commandAuthorized }
+					commands: { authorized: commandAuthorized === true }
 				},
 				extra: {
 					RootMessageId: ctx.rootId,
@@ -2985,7 +2864,7 @@ async function handleFeishuMessage(params) {
 			};
 		};
 		if (broadcastAgents) {
-			if (!await tryRecordMessagePersistent(messageDedupeKey ?? ctx.messageId, "broadcast", log)) {
+			if (!await recordProcessedFeishuMessage(messageDedupeKey ?? ctx.messageId, "broadcast", log)) {
 				log(`feishu[${account.accountId}]: broadcast already claimed by another account for message ${ctx.messageId}; skipping`);
 				return;
 			}
@@ -3146,7 +3025,11 @@ async function handleFeishuMessage(params) {
 			}
 			else {
 				const results = await Promise.allSettled(broadcastAgents.map(dispatchForAgent));
-				for (let i = 0; i < results.length; i++) if (results[i].status === "rejected") log(`feishu[${account.accountId}]: broadcast dispatch failed for agent=${broadcastAgents[i]}: ${String(results[i].reason)}`);
+				for (const [i, result] of results.entries()) if (result.status === "rejected") {
+					const agentId = broadcastAgents.at(i);
+					if (agentId === void 0) continue;
+					log(`feishu[${account.accountId}]: broadcast dispatch failed for agent=${agentId}: ${String(result.reason)}`);
+				}
 			}
 			if (isGroup && historyKey && chatHistories) createChannelHistoryWindow({ historyMap: chatHistories }).clear({
 				historyKey,
@@ -3255,6 +3138,10 @@ async function handleFeishuMessage(params) {
 	}
 }
 //#endregion
+//#region extensions/feishu/src/card-action-state.ts
+const processedCardActions = /* @__PURE__ */ new Map();
+const resolvedCardActionChatTypes = /* @__PURE__ */ new Map();
+//#endregion
 //#region extensions/feishu/src/card-ux-shared.ts
 function buildFeishuCardButton(params) {
 	return {
@@ -3322,20 +3209,13 @@ function createApprovalCard(params) {
 //#region extensions/feishu/src/card-action.ts
 const FEISHU_APPROVAL_CARD_TTL_MS = 5 * 6e4;
 const FEISHU_CARD_ACTION_TOKEN_TTL_MS = 15 * 6e4;
-const processedCardActionTokens = /* @__PURE__ */ new Map();
-var FeishuRetryableCardActionError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "FeishuRetryableCardActionError";
-	}
-};
 function pruneProcessedCardActionTokens(now) {
 	const validNow = asDateTimestampMs(now);
 	if (validNow === void 0) {
-		processedCardActionTokens.clear();
+		processedCardActions.clear();
 		return;
 	}
-	for (const [key, entry] of processedCardActionTokens.entries()) if (!isFutureDateTimestampMs(entry.expiresAt, { nowMs: validNow })) processedCardActionTokens.delete(key);
+	for (const [key, entry] of processedCardActions.entries()) if (!isFutureDateTimestampMs(entry.expiresAt, { nowMs: validNow })) processedCardActions.delete(key);
 }
 function resolveProcessedCardActionTokenExpiresAt(now) {
 	return resolveExpiresAtMsFromDurationMs(FEISHU_CARD_ACTION_TOKEN_TTL_MS, { nowMs: now });
@@ -3346,36 +3226,30 @@ function beginFeishuCardActionToken(params) {
 	const normalizedToken = params.token.trim();
 	if (!normalizedToken) return false;
 	const key = `${params.accountId}:${normalizedToken}`;
-	const existing = processedCardActionTokens.get(key);
+	const existing = processedCardActions.get(key);
 	if (existing && isFutureDateTimestampMs(existing.expiresAt, { nowMs: now })) return false;
-	processedCardActionTokens.delete(key);
+	processedCardActions.delete(key);
 	const expiresAt = resolveProcessedCardActionTokenExpiresAt(now);
-	if (expiresAt !== void 0) processedCardActionTokens.set(key, {
+	if (expiresAt !== void 0) processedCardActions.set(key, {
 		status: "inflight",
 		expiresAt
 	});
 	return true;
 }
-function completeFeishuCardActionToken(params) {
-	const now = params.now ?? Date.now();
-	const normalizedToken = params.token.trim();
-	if (!normalizedToken) return;
-	const key = `${params.accountId}:${normalizedToken}`;
+function completeFeishuCardAction(actionId, accountId, now = Date.now()) {
+	const normalizedActionId = actionId.trim();
+	if (!normalizedActionId) return;
+	const key = `${accountId}:${normalizedActionId}`;
 	const expiresAt = resolveProcessedCardActionTokenExpiresAt(now);
 	if (expiresAt === void 0) {
-		processedCardActionTokens.delete(key);
+		processedCardActions.delete(key);
 		return;
 	}
-	processedCardActionTokens.set(key, {
+	processedCardActions.set(key, {
 		status: "completed",
 		expiresAt
 	});
 }
-function releaseFeishuCardActionToken(params) {
-	const normalizedToken = params.token.trim();
-	if (!normalizedToken) return;
-	processedCardActionTokens.delete(`${params.accountId}:${normalizedToken}`);
-}
 function buildSyntheticMessageEvent(event, content, chatType) {
 	const replyTargetMessageId = event.context.open_message_id ?? event.open_message_id;
 	const isTemporaryCardActionId = replyTargetMessageId?.startsWith("card-action-c-");
@@ -3419,11 +3293,7 @@ async function dispatchSyntheticCommand(params) {
 		accountId: params.accountId
 	});
 }
-function normalizeResolvedCardActionChatType(value) {
-	if (value === "group" || value === "topic" || value === "public") return "group";
-	if (value === "p2p" || value === "private") return "p2p";
-}
-const resolvedChatTypeCache = /* @__PURE__ */ new Map();
+const resolvedChatTypeCache = resolvedCardActionChatTypes;
 const CHAT_TYPE_CACHE_TTL_MS = 30 * 6e4;
 const CHAT_TYPE_CACHE_MAX_SIZE = 5e3;
 function pruneChatTypeCache(now) {
@@ -3461,7 +3331,7 @@ function cacheResolvedCardActionChatType(cacheKey, value, now) {
 	});
 }
 async function resolveCardActionChatType(params) {
-	const explicitChatType = normalizeResolvedCardActionChatType(params.chatType);
+	const explicitChatType = normalizeFeishuChatType$2(params.chatType);
 	if (explicitChatType) return explicitChatType;
 	const chatId = params.event.context.chat_id?.trim();
 	if (!chatId) return "p2p";
@@ -3475,7 +3345,7 @@ async function resolveCardActionChatType(params) {
 	try {
 		const response = await createFeishuClient(params.account).im.chat.get({ path: { chat_id: chatId } });
 		if (response.code === 0) {
-			const resolvedChatType = normalizeResolvedCardActionChatType(response.data?.chat_mode) ?? normalizeResolvedCardActionChatType(response.data?.chat_type);
+			const resolvedChatType = resolveFeishuChatType(response.data ?? {});
 			if (resolvedChatType) {
 				cacheResolvedCardActionChatType(cacheKey, resolvedChatType, now);
 				return resolvedChatType;
@@ -3513,7 +3383,7 @@ async function handleFeishuCardAction(params) {
 		token: event.token,
 		accountId: account.accountId
 	})) {
-		log(`feishu[${account.accountId}]: skipping duplicate card action token ${event.token}`);
+		log(`feishu[${account.accountId}]: skipping duplicate card action token`);
 		return;
 	}
 	try {
@@ -3525,10 +3395,7 @@ async function handleFeishuCardAction(params) {
 				reason: decoded.reason,
 				accountId
 			});
-			completeFeishuCardActionToken({
-				token: event.token,
-				accountId: account.accountId
-			});
+			completeFeishuCardAction(event.token, account.accountId);
 			return;
 		}
 		if (decoded.kind === "structured") {
@@ -3543,10 +3410,7 @@ async function handleFeishuCardAction(params) {
 						reason: "malformed",
 						accountId
 					});
-					completeFeishuCardActionToken({
-						token: event.token,
-						accountId: account.accountId
-					});
+					completeFeishuCardAction(event.token, account.accountId);
 					return;
 				}
 				const prompt = typeof envelope.m?.prompt === "string" && envelope.m.prompt.trim() ? envelope.m.prompt : `Run \`${command}\` in this Feishu conversation?`;
@@ -3558,10 +3422,7 @@ async function handleFeishuCardAction(params) {
 						reason: "malformed",
 						accountId
 					});
-					completeFeishuCardActionToken({
-						token: event.token,
-						accountId: account.accountId
-					});
+					completeFeishuCardAction(event.token, account.accountId);
 					return;
 				}
 				await sendCardFeishu({
@@ -3584,10 +3445,7 @@ async function handleFeishuCardAction(params) {
 					}),
 					accountId
 				});
-				completeFeishuCardActionToken({
-					token: event.token,
-					accountId: account.accountId
-				});
+				completeFeishuCardAction(event.token, account.accountId);
 				return;
 			}
 			if (envelope.a === "feishu.approval.cancel") {
@@ -3597,10 +3455,7 @@ async function handleFeishuCardAction(params) {
 					text: "Cancelled.",
 					accountId
 				});
-				completeFeishuCardActionToken({
-					token: event.token,
-					accountId: account.accountId
-				});
+				completeFeishuCardAction(event.token, account.accountId);
 				return;
 			}
 			if (envelope.a === "feishu.approval.confirm" || envelope.k === "quick") {
@@ -3612,10 +3467,7 @@ async function handleFeishuCardAction(params) {
 						reason: "malformed",
 						accountId
 					});
-					completeFeishuCardActionToken({
-						token: event.token,
-						accountId: account.accountId
-					});
+					completeFeishuCardAction(event.token, account.accountId);
 					return;
 				}
 				await dispatchSyntheticCommand({
@@ -3629,10 +3481,7 @@ async function handleFeishuCardAction(params) {
 					accountId,
 					chatType: envelope.c?.t
 				});
-				completeFeishuCardActionToken({
-					token: event.token,
-					accountId: account.accountId
-				});
+				completeFeishuCardAction(event.token, account.accountId);
 				return;
 			}
 			await sendInvalidInteractionNotice({
@@ -3641,10 +3490,7 @@ async function handleFeishuCardAction(params) {
 				reason: "malformed",
 				accountId
 			});
-			completeFeishuCardActionToken({
-				token: event.token,
-				accountId: account.accountId
-			});
+			completeFeishuCardAction(event.token, account.accountId);
 			return;
 		}
 		const content = buildFeishuCardActionTextFallback(event);
@@ -3659,23 +3505,146 @@ async function handleFeishuCardAction(params) {
 			channelRuntime: params.channelRuntime,
 			accountId
 		});
-		completeFeishuCardActionToken({
-			token: event.token,
-			accountId: account.accountId
-		});
+		completeFeishuCardAction(event.token, account.accountId);
 	} catch (err) {
-		if (err instanceof FeishuRetryableCardActionError) releaseFeishuCardActionToken({
-			token: event.token,
-			accountId: account.accountId
-		});
-		else completeFeishuCardActionToken({
-			token: event.token,
-			accountId: account.accountId
-		});
+		completeFeishuCardAction(event.token, account.accountId);
 		throw err;
 	}
 }
 //#endregion
+//#region extensions/feishu/src/monitor-defaults.ts
+const FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS = {
+	windowMs: 6e4,
+	maxRequests: 120,
+	maxTrackedKeys: 4096
+};
+const FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS = {
+	maxTrackedKeys: 4096,
+	ttlMs: 360 * 6e4,
+	logEvery: 25
+};
+function coercePositiveInt(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	const normalized = Math.floor(value);
+	return normalized > 0 ? normalized : fallback;
+}
+function resolveFeishuWebhookRateLimitDefaults(defaults) {
+	const resolved = defaults;
+	return {
+		windowMs: coercePositiveInt(resolved?.windowMs, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.windowMs),
+		maxRequests: coercePositiveInt(resolved?.maxRequests, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxRequests),
+		maxTrackedKeys: coercePositiveInt(resolved?.maxTrackedKeys, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxTrackedKeys)
+	};
+}
+function resolveFeishuWebhookAnomalyDefaults(defaults) {
+	const resolved = defaults;
+	return {
+		maxTrackedKeys: coercePositiveInt(resolved?.maxTrackedKeys, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.maxTrackedKeys),
+		ttlMs: coercePositiveInt(resolved?.ttlMs, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.ttlMs),
+		logEvery: coercePositiveInt(resolved?.logEvery, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.logEvery)
+	};
+}
+//#endregion
+//#region extensions/feishu/src/monitor.state.ts
+const wsClients = /* @__PURE__ */ new Map();
+const httpServers = /* @__PURE__ */ new Map();
+const botOpenIds = /* @__PURE__ */ new Map();
+const botNames = /* @__PURE__ */ new Map();
+const botIdentityRevisions = /* @__PURE__ */ new Map();
+const FEISHU_WEBHOOK_MAX_BODY_BYTES = 64 * 1024;
+const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 5e3;
+const FEISHU_HTTP_SERVER_CLOSE_TIMEOUT_MS = 5e3;
+const feishuWebhookRateLimitDefaults = resolveFeishuWebhookRateLimitDefaults(WEBHOOK_RATE_LIMIT_DEFAULTS);
+const feishuWebhookAnomalyDefaults = resolveFeishuWebhookAnomalyDefaults(WEBHOOK_ANOMALY_COUNTER_DEFAULTS);
+const feishuWebhookRateLimiter = createFixedWindowRateLimiter({
+	windowMs: feishuWebhookRateLimitDefaults.windowMs,
+	maxRequests: feishuWebhookRateLimitDefaults.maxRequests,
+	maxTrackedKeys: feishuWebhookRateLimitDefaults.maxTrackedKeys
+});
+const feishuWebhookAnomalyTracker = createWebhookAnomalyTracker({
+	maxTrackedKeys: feishuWebhookAnomalyDefaults.maxTrackedKeys,
+	ttlMs: feishuWebhookAnomalyDefaults.ttlMs,
+	logEvery: feishuWebhookAnomalyDefaults.logEvery
+});
+function readBotIdentityRevision(accountId) {
+	return botIdentityRevisions.get(accountId) ?? 0;
+}
+function bumpBotIdentityRevision(accountId) {
+	botIdentityRevisions.set(accountId, readBotIdentityRevision(accountId) + 1);
+}
+function captureBotIdentitySnapshot(accountId) {
+	return { revision: readBotIdentityRevision(accountId) };
+}
+function clearFeishuBotIdentityStateIfUnchanged(accountId, snapshot) {
+	if (readBotIdentityRevision(accountId) !== snapshot.revision) return;
+	botOpenIds.delete(accountId);
+	botNames.delete(accountId);
+	bumpBotIdentityRevision(accountId);
+}
+function setFeishuBotIdentityState(accountId, identity) {
+	botOpenIds.set(accountId, identity.botOpenId);
+	if (identity.botName) botNames.set(accountId, identity.botName);
+	else botNames.delete(accountId);
+	bumpBotIdentityRevision(accountId);
+}
+function clearFeishuBotIdentityState(accountId) {
+	botOpenIds.delete(accountId);
+	botNames.delete(accountId);
+	bumpBotIdentityRevision(accountId);
+}
+function isServerNotRunningError(error) {
+	return error.code === "ERR_SERVER_NOT_RUNNING";
+}
+async function closeFeishuHttpServer(server) {
+	await new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(fallbackTimer);
+			if (!err || isServerNotRunningError(err)) {
+				resolve();
+				return;
+			}
+			reject(err);
+		};
+		const fallbackTimer = setTimeout(() => {
+			try {
+				server.closeAllConnections();
+				settle();
+			} catch (err) {
+				settle(err instanceof Error ? err : new Error(String(err)));
+			}
+		}, FEISHU_HTTP_SERVER_CLOSE_TIMEOUT_MS);
+		try {
+			server.close((err) => {
+				settle(err);
+			});
+		} catch (err) {
+			settle(err instanceof Error ? err : new Error(String(err)));
+		}
+	});
+}
+async function closeTrackedFeishuHttpServer(accountId, server) {
+	const identitySnapshot = captureBotIdentitySnapshot(accountId);
+	try {
+		await closeFeishuHttpServer(server);
+	} finally {
+		if (httpServers.get(accountId) === server) {
+			httpServers.delete(accountId);
+			clearFeishuBotIdentityStateIfUnchanged(accountId, identitySnapshot);
+		}
+	}
+}
+function recordWebhookStatus(runtime, accountId, path, statusCode) {
+	feishuWebhookAnomalyTracker.record({
+		key: `${accountId}:${path}:${statusCode}`,
+		statusCode,
+		log: runtime?.log ?? console.log,
+		message: (count) => `feishu[${accountId}]: webhook anomaly path=${path} status=${statusCode} count=${count}`
+	});
+}
+//#endregion
 //#region extensions/feishu/src/monitor.bot-identity.ts
 const BOT_IDENTITY_RETRY_DELAYS_MS = [
 	6e4,
@@ -3699,9 +3668,10 @@ function applyBotIdentityState(accountId, identity) {
 async function retryBotIdentityProbe(account, accountId, runtime, abortSignal) {
 	const log = runtime?.log ?? console.log;
 	const error = runtime?.error ?? console.error;
-	for (let i = 0; i < BOT_IDENTITY_RETRY_DELAYS_MS.length; i += 1) {
+	const nextDelays = BOT_IDENTITY_RETRY_DELAYS_MS.slice(1)[Symbol.iterator]();
+	for (const [i, delayMs] of BOT_IDENTITY_RETRY_DELAYS_MS.entries()) {
 		if (abortSignal?.aborted) return;
-		if (!await waitForAbortableDelay(BOT_IDENTITY_RETRY_DELAYS_MS[i], abortSignal)) return;
+		if (!await waitForAbortableDelay(delayMs, abortSignal)) return;
 		const resolved = applyBotIdentityState(accountId, await fetchBotIdentityForMonitor(account, {
 			runtime,
 			abortSignal
@@ -3710,7 +3680,8 @@ async function retryBotIdentityProbe(account, accountId, runtime, abortSignal) {
 			log(`feishu[${accountId}]: bot open_id recovered via background retry: ${resolved.botOpenId}`);
 			return;
 		}
-		const nextDelay = BOT_IDENTITY_RETRY_DELAYS_MS[i + 1];
+		const nextDelayResult = nextDelays.next();
+		const nextDelay = nextDelayResult.done ? void 0 : nextDelayResult.value;
 		error(`feishu[${accountId}]: bot identity background retry ${i + 1}/${BOT_IDENTITY_RETRY_DELAYS_MS.length} failed` + (nextDelay ? `; next attempt in ${nextDelay / 1e3}s` : ""));
 	}
 	error(`feishu[${accountId}]: bot identity background retry exhausted; requireMention group messages may be skipped until restart`);
@@ -3886,11 +3857,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;
 			}
@@ -3903,7 +3874,7 @@ function createFeishuBotMenuHandler(params) {
 				channelRuntime: params.channelRuntime,
 				chatHistories,
 				accountId,
-				processingClaimHeld: true
+				processingClaim: claim.kind === "claimed" ? claim.handle : void 0
 			});
 			const promise = maybeHandleFeishuQuickActionMenu({
 				cfg,
@@ -3913,16 +3884,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) => {
@@ -3951,7 +3922,7 @@ function createFeishuCommentReplyDispatcher(params) {
 		accountId: params.accountId
 	}));
 	const textChunkLimit = core.channel.text.resolveTextChunkLimit(params.cfg, "feishu", params.accountId, { fallbackLimit: 4e3 });
-	const chunkMode = core.channel.text.resolveChunkMode(params.cfg, "feishu");
+	const chunkMode = core.channel.text.resolveChunkMode(params.cfg, "feishu", params.accountId);
 	const typingReaction = createCommentTypingReactionLifecycle({
 		cfg: params.cfg,
 		fileToken: params.fileToken,
@@ -4111,11 +4082,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,
@@ -4338,8 +4304,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)}`);
@@ -4487,7 +4454,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();
@@ -4513,7 +4480,7 @@ async function resolveDriveCommentEventCore(params) {
 		return null;
 	}
 	const context = await fetchDriveCommentContext({
-		client: createClient ? createClient(account ?? { accountId }) : createFeishuClient((await import("./accounts-Bs5uJ4h0.js").then((n) => n.t)).resolveFeishuAccount({
+		client: createClient ? createClient(account ?? { accountId }) : createFeishuClient((await import("./accounts-BDoGHJDk.js").then((n) => n.t)).resolveFeishuAccount({
 			cfg,
 			accountId
 		})),
@@ -4525,7 +4492,7 @@ async function resolveDriveCommentEventCore(params) {
 		timeoutMs: verificationTimeoutMs,
 		logger,
 		accountId,
-		waitMs
+		abortSignal
 	});
 	return {
 		eventId,
@@ -4651,7 +4618,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"}`);
@@ -4935,7 +4903,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();
@@ -4955,20 +4923,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 {
@@ -4978,15 +4948,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);
 			}
 		});
 	};
@@ -5028,7 +4998,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;
@@ -5042,10 +5012,7 @@ function dedupeFeishuDebounceEntriesByDedupeKey(entries) {
 function resolveFeishuDebounceMentions(params) {
 	const { entries, botOpenId } = params;
 	if (entries.length === 0) return;
-	for (let index = entries.length - 1; index >= 0; index -= 1) {
-		const entry = entries[index];
-		if (isMentionForwardRequest(entry, botOpenId)) return mergeFeishuDebounceMentions([entry]);
-	}
+	for (const entry of entries.toReversed()) if (isMentionForwardRequest(entry, botOpenId)) return mergeFeishuDebounceMentions([entry]);
 	const merged = mergeFeishuDebounceMentions(entries);
 	if (!merged) return;
 	const normalizedBotOpenId = botOpenId?.trim();
@@ -5053,7 +5020,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"
@@ -5063,7 +5030,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,
@@ -5079,7 +5046,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			channelRuntime,
 			chatHistories,
 			accountId,
-			processingClaimHeld: true,
+			processingClaim,
 			messageDedupeKey
 		});
 		await enqueue(sequentialKey, task);
@@ -5096,23 +5063,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);
@@ -5121,35 +5091,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)}`);
 		}
 	});
@@ -5167,17 +5137,24 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			log(`feishu[${accountId}]: dropping self-authored message ${messageId ?? "unknown"}`);
 			return;
 		}
-		const messageDedupeKey = resolveFeishuMessageDedupeKey(event);
-		if (!tryBeginFeishuMessageProcessing(messageDedupeKey, accountId)) {
-			log(`feishu[${accountId}]: dropping duplicate event for message ${messageId}`);
+		const claim = await claimUnprocessedFeishuMessage({
+			messageId: resolveFeishuMessageDedupeKey(event),
+			namespace: accountId,
+			log
+		});
+		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;
@@ -5185,12 +5162,22 @@ 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)}`);
 		}
 	};
 }
 //#endregion
+//#region extensions/feishu/src/monitor-rate-limit-key.ts
+function normalizeFeishuWebhookRateLimitClient(clientIp) {
+	if (!clientIp) return "unknown";
+	if (clientIp === "::1" || clientIp.startsWith("127.")) return "loopback";
+	return clientIp;
+}
+function buildFeishuWebhookRateLimitKey(params) {
+	return `${params.accountId}:${params.path}:${normalizeFeishuWebhookRateLimitClient(params.clientIp)}`;
+}
+//#endregion
 //#region extensions/feishu/src/monitor.transport.ts
 const FEISHU_WS_RECONNECT_INITIAL_DELAY_MS = 1e3;
 const FEISHU_WS_RECONNECT_MAX_DELAY_MS = 3e4;
@@ -5228,14 +5215,6 @@ function respondText(res, statusCode, body) {
 	res.setHeader("Content-Type", "text/plain; charset=utf-8");
 	res.end(body);
 }
-function normalizeFeishuWebhookRateLimitClient(clientIp) {
-	if (!clientIp) return "unknown";
-	if (clientIp === "::1" || clientIp.startsWith("127.")) return "loopback";
-	return clientIp;
-}
-function buildFeishuWebhookRateLimitKey(params) {
-	return `${params.accountId}:${params.path}:${normalizeFeishuWebhookRateLimitClient(params.clientIp)}`;
-}
 function getFeishuWsReconnectDelayMs(attempt) {
 	return Math.min(FEISHU_WS_RECONNECT_INITIAL_DELAY_MS * 2 ** Math.max(0, attempt - 1), FEISHU_WS_RECONNECT_MAX_DELAY_MS);
 }
@@ -5529,7 +5508,7 @@ async function resolveReactionSyntheticEvent(params) {
 	const senderId = event.user_id?.open_id;
 	const senderUserId = event.user_id?.user_id;
 	if (!emoji || !messageId || !senderId) return null;
-	const { resolveFeishuAccount } = await import("./accounts-Bs5uJ4h0.js").then((n) => n.t);
+	const { resolveFeishuAccount } = await import("./accounts-BDoGHJDk.js").then((n) => n.t);
 	const reactionNotifications = resolveFeishuAccount({
 		cfg,
 		accountId
@@ -5638,7 +5617,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) => {
@@ -5665,7 +5644,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,
@@ -5695,7 +5673,8 @@ function registerEventHandlers(eventDispatcher, context) {
 			cfg,
 			accountId,
 			runtime,
-			fireAndForget
+			fireAndForget,
+			abortSignal
 		}),
 		"im.message.reaction.created_v1": async (data) => {
 			await runFeishuHandler({
@@ -5824,6 +5803,7 @@ async function monitorSingleAccount(params) {
 			runtime,
 			chatHistories,
 			fireAndForget: params.fireAndForget ?? true,
+			abortSignal,
 			...params.statusSink ? { statusSink: params.statusSink } : {}
 		});
 		if (connectionMode === "webhook") return await monitorWebhook({