@openclaw/feishu 2026.7.2-beta.2 → 2026.7.2-beta.4

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

@@ -1,17 +1,17 @@
-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 { _ as normalizeCommentFileType, c as encodeQuery, d as isRecord$2, f as normalizeString, g as buildFeishuCommentTarget, h as requestFeishuApi, l as extractReplyText, m as readString$1, o as resolveFeishuAccount, p as parseCommentContentElements, s as resolveFeishuRuntimeAccount } from "./accounts-BDoGHJDk.js";
 import { i as resolveReceiveIdType } from "./targets-BUjQ1TcA.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 { 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 { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-Dee7cKsS.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-B4E8OXZ0.js";
+import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-_zrcOxzS.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-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 { _ as buildFeishuMediaFallbackText, a as getMessageFeishu, d as parsePostContent, f as extractMentionTargets, g as normalizeFeishuExternalKey, h as isFeishuGroupChatType, l as sendMessageFeishu, m as isMentionForwardRequest, n as sendMediaFeishu, o as listFeishuThreadMessages, p as isFeishuBroadcastMention, r as shouldSuppressFeishuTextForVoiceMedia, s as sendCardFeishu, t as saveMessageResourceFeishu, u as sendStructuredCardFeishu, v as resolveFeishuIdentityEmoji } from "./media-CRJunSRr.js";
+import { a as waitForAbortableDelay, i as raceWithTimeoutAndAbort } from "./probe-Za1kgUvx.js";
+import { t as fetchBotIdentityForMonitor } from "./monitor.startup-CSUPT_U1.js";
+import { DEFAULT_INGRESS_ADOPTION_STALL_MS, bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, 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";
@@ -22,21 +22,24 @@ 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 { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { collectErrorGraphCandidates, 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, createChannelPartialDeliveryError, formatAgentEnvelope, formatInboundMediaUnavailableText, isChannelPartialDeliveryError, 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 { 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 { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 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";
@@ -72,6 +75,167 @@ function buildFeishuAgentBody(params) {
 }
 //#endregion
 //#region extensions/feishu/src/bot-broadcast.ts
+function createFeishuBroadcastIngressSettlement(params) {
+	const lanes = /* @__PURE__ */ new Set();
+	const failures = [];
+	const fallbackAbortSignal = new AbortController().signal;
+	let fanoutSettled = false;
+	let terminal;
+	let adoption;
+	let abandonment;
+	let finalizing = false;
+	let deferred = false;
+	let replayReleased = false;
+	const beginFinalizing = () => {
+		if (finalizing) return;
+		finalizing = true;
+		params.lifecycle?.onAdoptionFinalizing();
+	};
+	const defer = () => {
+		if (deferred) return;
+		deferred = true;
+		params.lifecycle?.onDeferred();
+	};
+	const reportReplayCommitError = (error) => {
+		try {
+			params.onReplayCommitError?.(error);
+		} catch {}
+	};
+	const releaseReplayClaim = (error) => {
+		if (replayReleased || terminal === "adopted") return;
+		replayReleased = true;
+		params.replayClaim?.release({ error });
+	};
+	const runAbandonment = async (error) => {
+		if (terminal) return;
+		releaseReplayClaim(error);
+		try {
+			await params.lifecycle?.onAbandoned();
+		} finally {
+			terminal = "abandoned";
+		}
+	};
+	const abandon = async (error) => {
+		if (terminal) return;
+		if (adoption) {
+			await adoption.catch(() => void 0);
+			if (terminal) return;
+		}
+		const activeAbandonment = abandonment ?? runAbandonment(error);
+		abandonment = activeAbandonment;
+		await activeAbandonment;
+	};
+	const runAdoption = async () => {
+		beginFinalizing();
+		try {
+			await params.lifecycle?.onAdopted();
+			terminal = "adopted";
+			try {
+				params.onAdopted?.();
+			} catch {}
+			try {
+				await params.replayClaim?.commit();
+			} catch (error) {
+				reportReplayCommitError(error);
+			}
+		} catch (error) {
+			await runAbandonment(error).catch(() => void 0);
+			throw error;
+		}
+	};
+	const adopt = async () => {
+		if (terminal) return;
+		if (abandonment) {
+			await abandonment.catch(() => void 0);
+			if (terminal) return;
+		}
+		const activeAdoption = adoption ?? runAdoption();
+		adoption = activeAdoption;
+		await activeAdoption;
+	};
+	const maybeSettle = async () => {
+		if (!fanoutSettled || terminal) return;
+		if (failures.length > 0 || [...lanes].some((lane) => lane.status === "failed" || lane.status === "abandoned")) {
+			await abandon(failures.length === 1 ? failures[0] : new AggregateError(failures, "Feishu broadcast dispatch failed"));
+			return;
+		}
+		if ([...lanes].some((lane) => lane.status === "pending" || lane.status === "deferred" || lane.status === "adopted")) return;
+		await adopt();
+	};
+	return {
+		createLane: (replayClaim) => {
+			const lane = {
+				replayClaim,
+				status: "pending"
+			};
+			lanes.add(lane);
+			const releaseLane = (error) => {
+				lane.replayClaim?.release({ error });
+			};
+			return {
+				lifecycle: {
+					abortSignal: params.lifecycle?.abortSignal ?? fallbackAbortSignal,
+					onAdopted: async () => {
+						if (lane.status === "adopted" || lane.status === "completed" || lane.status === "failed" || lane.status === "abandoned") return;
+						lane.status = "adopted";
+						beginFinalizing();
+						try {
+							await lane.replayClaim?.commit();
+						} catch (error) {
+							reportReplayCommitError(error);
+						}
+						lane.status = "completed";
+						await maybeSettle();
+					},
+					onDeferred: () => {
+						if (lane.status !== "pending") return;
+						lane.status = "deferred";
+						defer();
+					},
+					onAdoptionFinalizing: beginFinalizing,
+					onAbandoned: async () => {
+						if (lane.status === "completed" || lane.status === "failed" || lane.status === "abandoned") return;
+						lane.status = "abandoned";
+						releaseLane(/* @__PURE__ */ new Error("feishu-broadcast-turn-abandoned"));
+						await maybeSettle();
+					}
+				},
+				onDispatchComplete: async (dispatched) => {
+					if (!dispatched && lane.status === "pending") {
+						const error = /* @__PURE__ */ new Error("feishu broadcast lane was not dispatched");
+						lane.status = "failed";
+						failures.push(error);
+						releaseLane(error);
+						return;
+					}
+					if (lane.status !== "pending") return;
+					const error = /* @__PURE__ */ new Error("feishu broadcast dispatch returned before turn adoption");
+					lane.status = "failed";
+					failures.push(error);
+					releaseLane(error);
+				},
+				onDispatchFailed: async (error) => {
+					failures.push(error);
+					if (lane.status !== "completed") {
+						lane.status = "failed";
+						releaseLane(error);
+					}
+					await maybeSettle();
+				}
+			};
+		},
+		onLanePending: defer,
+		onDispatchComplete: async () => {
+			fanoutSettled = true;
+			await maybeSettle();
+		},
+		onDispatchFailed: async (error) => {
+			failures.push(error);
+			fanoutSettled = true;
+			await maybeSettle();
+		}
+	};
+}
 function resolveBroadcastAgents(cfg, peerId) {
 	const broadcast = cfg.broadcast;
 	if (!broadcast || typeof broadcast !== "object") return null;
@@ -137,11 +301,14 @@ function resolveFeishuGroupSession(params) {
 	};
 }
 function parseMessageContent(content, messageType) {
-	if (messageType === "post") return parsePostContent(content).textContent;
+	if (messageType === "post") return parsePostContent(content, {
+		renderMediaPlaceholders: false,
+		emptyTextFallback: ""
+	}).textContent;
 	try {
 		const parsed = JSON.parse(content);
 		if (messageType === "text") return parsed.text || "";
-		if (FEISHU_MEDIA_MESSAGE_TYPES.has(messageType)) return formatFeishuMediaContent(parsed, messageType).body;
+		if (FEISHU_MEDIA_MESSAGE_TYPES.has(messageType)) return formatFeishuMediaContent(parsed, messageType);
 		if (messageType === "share_chat") {
 			if (parsed && typeof parsed === "object") {
 				const share = parsed;
@@ -154,7 +321,7 @@ function parseMessageContent(content, messageType) {
 		if (messageType === "merge_forward") return "[Merged and Forwarded Message - loading...]";
 		return content;
 	} catch {
-		return content;
+		return FEISHU_MEDIA_MESSAGE_TYPES.has(messageType) ? "" : content;
 	}
 }
 const FEISHU_MEDIA_MESSAGE_TYPES = /* @__PURE__ */ new Set([
@@ -167,32 +334,8 @@ const FEISHU_MEDIA_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 ]);
 function formatFeishuMediaContent(parsed, messageType) {
 	const speechToText = messageType === "audio" && typeof parsed.speech_to_text === "string" ? parsed.speech_to_text.trim() : "";
-	if (speechToText) return { body: speechToText };
-	const placeholder = inferPlaceholder(messageType);
-	const fileName = typeof parsed.file_name === "string" ? parsed.file_name.trim() : "";
-	return {
-		body: fileName ? `${placeholder} (${fileName})` : placeholder,
-		mediaPlaceholder: placeholder,
-		unavailableBody: fileName || void 0
-	};
-}
-function resolveFeishuMediaFailurePresentation(content, messageType) {
-	if (messageType === "post") return { unavailableBody: parsePostContent(content, {
-		renderMediaPlaceholders: false,
-		emptyTextFallback: ""
-	}).textContent };
-	if (!FEISHU_MEDIA_MESSAGE_TYPES.has(messageType)) return {};
-	try {
-		const parsed = JSON.parse(content);
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-		const presentation = formatFeishuMediaContent(parsed, messageType);
-		return {
-			mediaPlaceholder: presentation.mediaPlaceholder,
-			unavailableBody: presentation.unavailableBody
-		};
-	} catch {
-		return {};
-	}
+	if (speechToText) return speechToText;
+	return "";
 }
 function formatSubMessageContent(content, contentType) {
 	try {
@@ -293,15 +436,15 @@ async function resolveSavedFeishuMedia(params) {
 	const contentType = params.result.contentType ?? await core.media.detectMime({ buffer: params.result.buffer });
 	return await core.channel.media.saveMediaBuffer(params.result.buffer, contentType, "inbound", params.maxBytes, params.result.fileName ?? params.originalFilename);
 }
-function inferPlaceholder(messageType) {
+function resolveFeishuMediaKind(messageType) {
 	switch (messageType) {
-		case "image": return "<media:image>";
-		case "file": return "<media:document>";
-		case "audio": return "<media:audio>";
+		case "image": return "image";
+		case "file": return "document";
+		case "audio": return "audio";
 		case "video":
-		case "media": return "<media:video>";
-		case "sticker": return "<media:sticker>";
-		default: return "<media:document>";
+		case "media": return "video";
+		case "sticker": return "sticker";
+		default: return "document";
 	}
 }
 async function resolveFeishuMediaList(params) {
@@ -314,18 +457,11 @@ async function resolveFeishuMediaList(params) {
 		"media",
 		"sticker",
 		"post"
-	].includes(messageType)) return {
-		media: [],
-		unavailableCount: 0
-	};
+	].includes(messageType)) return [];
 	const out = [];
-	let unavailableCount = 0;
 	if (messageType === "post") {
 		const { imageKeys, mediaKeys } = parsePostContent(content);
-		if (imageKeys.length === 0 && mediaKeys.length === 0) return {
-			media: [],
-			unavailableCount: 0
-		};
+		if (imageKeys.length === 0 && mediaKeys.length === 0) return [];
 		if (imageKeys.length > 0) log?.(`feishu: post message contains ${imageKeys.length} embedded image(s)`);
 		if (mediaKeys.length > 0) log?.(`feishu: post message contains ${mediaKeys.length} embedded media file(s)`);
 		for (const imageKey of imageKeys) try {
@@ -343,11 +479,11 @@ async function resolveFeishuMediaList(params) {
 			out.push({
 				path: saved.path,
 				contentType: saved.contentType,
-				placeholder: "<media:image>"
+				kind: "image"
 			});
 			log?.(`feishu: downloaded embedded image ${imageKey}, saved to ${saved.path}`);
 		} catch (err) {
-			unavailableCount += 1;
+			out.push({ kind: "image" });
 			log?.(`feishu: failed to download embedded image ${imageKey}: ${String(err)}`);
 		}
 		for (const media of mediaKeys) try {
@@ -367,29 +503,20 @@ async function resolveFeishuMediaList(params) {
 			out.push({
 				path: saved.path,
 				contentType: saved.contentType,
-				placeholder: "<media:video>"
+				kind: "video"
 			});
 			log?.(`feishu: downloaded embedded media ${media.fileKey}, saved to ${saved.path}`);
 		} catch (err) {
-			unavailableCount += 1;
+			out.push({ kind: "video" });
 			log?.(`feishu: failed to download embedded media ${media.fileKey}: ${String(err)}`);
 		}
-		return {
-			media: out,
-			unavailableCount
-		};
+		return out;
 	}
 	const mediaKeys = parseMediaKeys(content, messageType);
-	if (!mediaKeys.imageKey && !mediaKeys.fileKey) return {
-		media: [],
-		unavailableCount: 1
-	};
+	if (!mediaKeys.imageKey && !mediaKeys.fileKey) return [{ kind: resolveFeishuMediaKind(messageType) }];
 	try {
 		const fileKey = mediaKeys.fileKey || mediaKeys.imageKey;
-		if (!fileKey) return {
-			media: [],
-			unavailableCount: 1
-		};
+		if (!fileKey) return [{ kind: resolveFeishuMediaKind(messageType) }];
 		const saved = await resolveSavedFeishuMedia({
 			result: await saveMessageResourceFeishu({
 				cfg,
@@ -406,17 +533,14 @@ async function resolveFeishuMediaList(params) {
 		out.push({
 			path: saved.path,
 			contentType: saved.contentType,
-			placeholder: inferPlaceholder(messageType)
+			kind: resolveFeishuMediaKind(messageType)
 		});
 		log?.(`feishu: downloaded ${messageType} media, saved to ${saved.path}`);
 	} catch (err) {
-		unavailableCount += 1;
+		out.push({ kind: resolveFeishuMediaKind(messageType) });
 		log?.(`feishu: failed to download ${messageType} media: ${String(err)}`);
 	}
-	return {
-		media: out,
-		unavailableCount
-	};
+	return out;
 }
 //#endregion
 //#region extensions/feishu/src/bot-group-name-state.ts
@@ -478,10 +602,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 +799,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 {};
@@ -597,9 +864,7 @@ function dedupeOptions(namespace, log) {
 * unidentifiable event is never suppressed.
 */
 async function claimUnprocessedFeishuMessage(params) {
-	const claim = await feishuDedupeState.guard.claim(params.messageId, dedupeOptions(params.namespace, params.log));
-	if (claim.kind === "inflight") return { kind: "inflight" };
-	return claim;
+	return await feishuDedupeState.guard.claim(params.messageId, dedupeOptions(params.namespace, params.log));
 }
 /**
 * Claims (unless the caller already holds the claim) and commits a message.
@@ -614,11 +879,6 @@ async function finalizeFeishuMessageProcessing(params) {
 	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 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) {
 	return await feishuDedupeState.guard.forget(messageId, dedupeOptions(namespace, log));
@@ -876,6 +1136,47 @@ function resolveFeishuReasoningPreviewEnabled(params) {
 	return configDefault === "stream";
 }
 //#endregion
+//#region extensions/feishu/src/reply-delivery-result.ts
+const noVisibleFeishuReplyDelivery = { visibleReplySent: false };
+function hasProviderIdentity(result) {
+	return Boolean(result && (result.messageId?.trim() || result.receipt?.primaryPlatformMessageId?.trim() || result.receipt?.platformMessageIds.length));
+}
+/** Normalizes every physical Lark send behind one logical reply payload. */
+function createFeishuReplyDeliveryResult(params) {
+	const results = params.visibleReplySent ? (params.results ?? []).filter(hasProviderIdentity) : [];
+	const receipt = results.length > 0 ? createMessageReceiptFromOutboundResults({
+		results,
+		...params.kind ? { kind: params.kind } : {}
+	}) : void 0;
+	if (!receipt) return {
+		visibleReplySent: params.visibleReplySent,
+		...params.content === void 0 ? {} : { content: params.content }
+	};
+	return {
+		messageIds: [...receipt.platformMessageIds],
+		receipt,
+		visibleReplySent: params.visibleReplySent,
+		...params.content === void 0 ? {} : { content: params.content }
+	};
+}
+/** Preserves the first result's provider identity while retaining supplemental ids. */
+function mergeFeishuReplyDeliveryResults(results, content) {
+	const visible = results.filter((result) => result.visibleReplySent === true);
+	return createFeishuReplyDeliveryResult({
+		results: visible,
+		visibleReplySent: visible.length > 0,
+		content: content === void 0 ? results.find((result) => result.content !== void 0)?.content : content
+	});
+}
+/** Keeps a failed outcome while exposing the provider-visible subset to core lifecycle hooks. */
+function createFeishuPartialReplyDeliveryError(cause, result) {
+	if (result.visibleReplySent !== true) return cause instanceof Error ? cause : new Error(formatErrorMessage(cause), { cause });
+	return createChannelPartialDeliveryError(cause, {
+		...result,
+		visibleReplySent: true
+	});
+}
+//#endregion
 //#region extensions/feishu/src/reply-dispatcher-state.ts
 const streamingStartBackoffUntilByAccount = /* @__PURE__ */ new Map();
 //#endregion
@@ -887,6 +1188,14 @@ function resolveStreamingCardSendMode(options) {
 }
 //#endregion
 //#region extensions/feishu/src/streaming-card.ts
+/** Provider finalization failed after a streaming card may already be visible. */
+var FeishuStreamingFinalizationError = class extends Error {
+	constructor(cause, result) {
+		super(cause instanceof Error ? cause.message : String(cause), { cause });
+		this.name = "FeishuStreamingFinalizationError";
+		this.result = result;
+	}
+};
 const STREAMING_UPDATE_THROTTLE_MS = 160;
 const STREAMING_SIGNIFICANT_DELTA_CHARS = 18;
 const FEISHU_STREAMING_TOKEN_DEFAULT_LIFETIME_SECONDS = 7200;
@@ -961,23 +1270,17 @@ function truncateSummary(text, max = 50) {
 	const clean = text.replace(/\n/g, " ").trim();
 	return clean.length <= max ? clean : sliceUtf16Safe(clean, 0, max - 3) + "...";
 }
-function hasNaturalStreamingBoundary(text) {
-	return /[\n。！？!?；;：:]$/.test(text);
-}
 function shouldPushStreamingUpdate(previousText, nextText) {
-	if (!previousText) return true;
-	if (hasNaturalStreamingBoundary(nextText)) return true;
-	return nextText.length - previousText.length >= STREAMING_SIGNIFICANT_DELTA_CHARS;
+	return !previousText || /[\n。！？!?；;：:]$/.test(nextText) || nextText.length - previousText.length >= STREAMING_SIGNIFICANT_DELTA_CHARS;
 }
+/** Merges cumulative or overlapping streaming snapshots without duplicating content. */
 function mergeStreamingText(previousText, nextText) {
 	const previous = typeof previousText === "string" ? previousText : "";
 	const next = typeof nextText === "string" ? nextText : "";
 	if (!next) return previous;
 	if (!previous || next === previous) return next;
-	if (next.startsWith(previous)) return next;
-	if (previous.startsWith(next)) return previous;
-	if (next.includes(previous)) return next;
-	if (previous.includes(next)) return previous;
+	if (next.startsWith(previous) || next.includes(previous)) return next;
+	if (previous.startsWith(next) || previous.includes(next)) return previous;
 	const maxOverlap = Math.min(previous.length, next.length);
 	for (let overlap = maxOverlap; overlap > 0; overlap -= 1) if (previous.slice(-overlap) === next.slice(0, overlap)) return `${previous}${next.slice(overlap)}`;
 	return `${previous}${next}`;
@@ -1267,16 +1570,23 @@ var FeishuStreamingSession = class {
 			}
 		}).catch((e) => this.log?.(`Note update failed: ${String(e)}`));
 	}
-	async close(finalText, options) {
-		if (!this.state || this.closed) return false;
+	async closeWithResult(finalText, options) {
+		if (!this.state || this.closed) return { visibleReplySent: false };
 		this.closed = true;
 		this.clearFlushTimer();
 		await this.queue;
 		const text = finalText ?? this.pendingText ?? this.state.currentText;
 		const apiBase = resolveApiBase(this.creds.domain);
 		let visibleContentSent = Boolean(this.state.sentText.trim());
+		let finalWriteError;
 		if ((text || finalText !== void 0) && text !== this.state.sentText) {
-			const sent = text.startsWith(this.state.sentText) ? await this.updateCardContent(text, (e) => this.log?.(`Final update failed: ${String(e)}`)) : await this.replaceCardContent(text, (e) => this.log?.(`Final replace failed: ${String(e)}`));
+			const sent = text.startsWith(this.state.sentText) ? await this.updateCardContent(text, (e) => {
+				finalWriteError = e;
+				this.log?.(`Final update failed: ${String(e)}`);
+			}) : await this.replaceCardContent(text, (e) => {
+				finalWriteError = e;
+				this.log?.(`Final replace failed: ${String(e)}`);
+			});
 			this.state.currentText = text;
 			if (sent) {
 				this.state.sentText = text;
@@ -1286,44 +1596,63 @@ 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`,
-			init: {
-				method: "PATCH",
-				headers: {
-					Authorization: `Bearer ${await getToken(this.creds, {
-						fetchImpl: this.fetchImpl,
-						lookupFn: this.lookupFn
-					})}`,
-					"Content-Type": "application/json; charset=utf-8",
-					"User-Agent": getFeishuUserAgent()
+		let closeError;
+		try {
+			const { response, release } = await fetchWithSsrFGuard({
+				url: `${apiBase}/cardkit/v1/cards/${this.state.cardId}/settings`,
+				init: {
+					method: "PATCH",
+					headers: {
+						Authorization: `Bearer ${await getToken(this.creds, {
+							fetchImpl: this.fetchImpl,
+							lookupFn: this.lookupFn
+						})}`,
+						"Content-Type": "application/json; charset=utf-8",
+						"User-Agent": getFeishuUserAgent()
+					},
+					body: JSON.stringify({
+						settings: JSON.stringify({ config: {
+							streaming_mode: false,
+							summary: { content: truncateSummary(acceptedText) }
+						} }),
+						sequence: this.state.sequence,
+						uuid: `c_${this.state.cardId}_${this.state.sequence}`
+					})
 				},
-				body: JSON.stringify({
-					settings: JSON.stringify({ config: {
-						streaming_mode: false,
-						summary: { content: truncateSummary(acceptedText) }
-					} }),
-					sequence: this.state.sequence,
-					uuid: `c_${this.state.cardId}_${this.state.sequence}`
-				})
-			},
-			fetchImpl: this.fetchImpl,
-			lookupFn: this.lookupFn,
-			policy: { allowedHostnames: resolveAllowedHostnames(this.creds.domain) },
-			auditContext: "feishu.streaming-card.close",
-			timeoutMs: this.creds.httpTimeoutMs ?? 3e4
-		}).then(async ({ response, release }) => {
+				fetchImpl: this.fetchImpl,
+				lookupFn: this.lookupFn,
+				policy: { allowedHostnames: resolveAllowedHostnames(this.creds.domain) },
+				auditContext: "feishu.streaming-card.close",
+				timeoutMs: this.creds.httpTimeoutMs ?? 3e4
+			});
 			try {
 				await assertSuccessfulCardKitResponse(response, "feishu.streaming-card.close", "Close streaming card");
 			} finally {
 				await release();
 			}
-		}).catch((e) => this.log?.(`Close failed: ${String(e)}`));
+		} catch (error) {
+			closeError = error;
+			this.log?.(`Close failed: ${String(error)}`);
+		}
 		const finalState = this.state;
 		this.state = null;
 		this.pendingText = null;
 		this.log?.(`Closed streaming: cardId=${finalState.cardId}`);
-		return visibleContentSent;
+		const result = {
+			visibleReplySent: visibleContentSent,
+			...visibleContentSent ? { content: finalState.sentText } : {},
+			messageId: finalState.messageId
+		};
+		if (finalWriteError !== void 0 || closeError !== void 0) throw new FeishuStreamingFinalizationError(finalWriteError !== void 0 && closeError !== void 0 ? new AggregateError([finalWriteError, closeError], "Feishu streaming card finalization failed") : finalWriteError ?? closeError, result);
+		return result;
+	}
+	async close(finalText, options) {
+		try {
+			return (await this.closeWithResult(finalText, options)).visibleReplySent;
+		} catch (error) {
+			if (error instanceof FeishuStreamingFinalizationError) return error.result.visibleReplySent;
+			throw error;
+		}
 	}
 	async discard() {
 		if (!this.state || this.closed) return;
@@ -1469,6 +1798,9 @@ function mergeStreamingFinalText(previousText, nextText, appendError) {
 	if (previousText.endsWith(`\n\n${nextText}`)) return previousText;
 	return `${previousText}\n\n${nextText}`;
 }
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
 /** Maximum age (ms) for a message to receive a typing indicator reaction.
 * Messages older than this are likely replays after context compaction (#30418). */
 const TYPING_INDICATOR_MAX_AGE_MS = 2 * 6e4;
@@ -1489,11 +1821,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;
@@ -1518,7 +1845,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;
@@ -1583,10 +1910,13 @@ 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 hookRunner = getGlobalHookRunner();
+	const modifyingHooksRegistered = (hookRunner?.hasHooks("reply_payload_sending") ?? false) || (hookRunner?.hasHooks("message_sending") ?? false);
+	const previewStreamingEnabled = streamingEnabled && !modifyingHooksRegistered;
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
 	const coreBlockStreamingEnabled = blockStreamingEnabled === true;
-	const reasoningPreviewEnabled = streamingEnabled && params.allowReasoningPreview === true;
+	const reasoningPreviewEnabled = previewStreamingEnabled && params.allowReasoningPreview === true;
 	let streaming = null;
 	let streamText = "";
 	let lastPartial = "";
@@ -1596,15 +1926,20 @@ function createFeishuReplyDispatcher(params) {
 	let lastSnapshotTextLength = 0;
 	let hasStreamingFinalText = false;
 	const deliveredFinalTexts = /* @__PURE__ */ new Set();
+	const closedStreamingSettlements = /* @__PURE__ */ new Map();
 	let sentIndependentBlockText = false;
 	let partialUpdateQueue = Promise.resolve();
 	let streamingStartPromise = null;
-	let streamingClosedForReply = false;
-	let streamingCloseErroredForReply = false;
+	let streamingGeneration = 0;
+	let activeStreamingGeneration;
+	let inFlightStreamingClose;
 	let visibleReplySent = false;
 	let skippedFinalReason = null;
 	let idleSideEffectsPromise = Promise.resolve();
+	let activeIdleSideEffectsPromise = null;
+	let idleRequestedForReply = false;
 	let replyLifecycleStateInitialized = false;
+	const pendingStreamingDeliveries = [];
 	const markVisibleReplySent = () => {
 		visibleReplySent = true;
 	};
@@ -1621,9 +1956,12 @@ function createFeishuReplyDispatcher(params) {
 		return parts.join("");
 	};
 	const flushStreamingCardUpdate = (combined) => {
+		const session = streaming;
+		const generation = activeStreamingGeneration;
+		const startPromise = streamingStartPromise;
 		partialUpdateQueue = partialUpdateQueue.then(async () => {
-			if (streamingStartPromise) await streamingStartPromise;
-			if (streaming?.isActive()) await streaming.update(combined);
+			if (startPromise) await startPromise;
+			if (generation !== void 0 && session?.isActive()) await session.update(combined);
 		});
 	};
 	const queueStreamingUpdate = (nextText, options) => {
@@ -1656,12 +1994,15 @@ function createFeishuReplyDispatcher(params) {
 				httpTimeoutMs: resolveConfiguredHttpTimeoutMs(account)
 			} : null;
 			if (!creds) return;
-			streaming = new FeishuStreamingSession(createFeishuClient(account), creds, (message) => params.runtime.log?.(`feishu[${account.accountId}] ${message}`));
+			const session = new FeishuStreamingSession(createFeishuClient(account), creds, (message) => params.runtime.log?.(`feishu[${account.accountId}] ${message}`));
+			const generation = ++streamingGeneration;
+			streaming = session;
+			activeStreamingGeneration = generation;
 			try {
 				const cardHeader = resolveCardHeader(agentId, identity);
 				const cardNote = resolveCardNote(agentId, identity, prefixContext.prefixContext);
 				const streamingTarget = sendTarget.replace(/^(feishu|lark):/i, "").replace(/^(chat|user|group|dm|open_id):/i, "").trim();
-				await streaming.start(streamingTarget, resolveReceiveIdType(sendTarget), {
+				await session.start(streamingTarget, resolveReceiveIdType(sendTarget), {
 					replyToMessageId: sendReplyToMessageId,
 					replyInThread: effectiveReplyInThread,
 					rootId,
@@ -1672,14 +2013,18 @@ function createFeishuReplyDispatcher(params) {
 			} catch (error) {
 				rememberStreamingStartFailure(account.accountId);
 				params.runtime.error?.(`feishu[${account.accountId}]: streaming start failed; using non-streaming card fallback for ${STREAMING_START_FAILURE_BACKOFF_MS / 1e3}s: ${String(error)}`);
-				streaming = null;
-				streamingStartPromise = null;
+				if (streaming === session) {
+					streaming = null;
+					streamingStartPromise = null;
+					activeStreamingGeneration = void 0;
+				}
 			}
 		})();
 	};
 	const resetStreamingState = () => {
 		streaming = null;
 		streamingStartPromise = null;
+		activeStreamingGeneration = void 0;
 		partialUpdateQueue = Promise.resolve();
 		streamText = "";
 		lastPartial = "";
@@ -1689,24 +2034,126 @@ function createFeishuReplyDispatcher(params) {
 		lastSnapshotTextLength = 0;
 		hasStreamingFinalText = false;
 	};
-	const closeStreaming = async (options) => {
+	const rememberClosedStreamingSettlement = (generation, content, result, error) => {
+		if (generation === void 0 || !content) return;
+		closedStreamingSettlements.set(generation, {
+			result,
+			content,
+			...error === void 0 ? {} : { error }
+		});
+	};
+	const performStreamingClose = async () => {
+		const streamingToClose = streaming;
+		const generationToClose = activeStreamingGeneration;
+		const startPromiseToClose = streamingStartPromise;
+		const updateQueueToClose = partialUpdateQueue;
+		const finalizedAnswerText = streamText;
+		const finalizedReasoningText = reasoningText;
+		if (generationToClose !== void 0 && activeStreamingGeneration === generationToClose) activeStreamingGeneration = void 0;
 		try {
-			if (streamingStartPromise) await streamingStartPromise;
-			await partialUpdateQueue;
-			if (streaming?.isActive()) {
+			if (startPromiseToClose) await startPromiseToClose;
+			await updateQueueToClose;
+			if (streamingToClose?.isActive()) {
 				statusLine = "";
-				const text = buildCombinedStreamText(reasoningText, streamText);
+				const text = buildCombinedStreamText(finalizedReasoningText, finalizedAnswerText);
 				const finalNote = resolveCardNote(agentId, identity, prefixContext.prefixContext);
-				const contentVisible = await streaming.close(text, { note: finalNote });
-				if (contentVisible) markVisibleReplySent();
-				if (contentVisible && streamText) {
-					deliveredFinalTexts.add(streamText);
-					if (options?.markClosedForReply !== false && !streamingCloseErroredForReply) streamingClosedForReply = true;
+				let closed;
+				try {
+					closed = await streamingToClose.closeWithResult(text, { note: finalNote });
+				} catch (error) {
+					if (!(error instanceof FeishuStreamingFinalizationError)) throw error;
+					const failedResult = createFeishuReplyDeliveryResult({
+						results: [error.result],
+						visibleReplySent: error.result.visibleReplySent,
+						content: error.result.content,
+						kind: "card"
+					});
+					if (failedResult.visibleReplySent) markVisibleReplySent();
+					if (failedResult.visibleReplySent && finalizedAnswerText) {
+						const partialError = createFeishuPartialReplyDeliveryError(error.cause ?? error, failedResult);
+						if (failedResult.content === text) deliveredFinalTexts.add(finalizedAnswerText);
+						rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, failedResult, partialError);
+						return {
+							result: failedResult,
+							...generationToClose === void 0 ? {} : { generation: generationToClose },
+							error: partialError
+						};
+					}
+					rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, failedResult, error);
+					return {
+						result: failedResult,
+						...generationToClose === void 0 ? {} : { generation: generationToClose },
+						error
+					};
+				}
+				const result = createFeishuReplyDeliveryResult({
+					results: [closed],
+					visibleReplySent: closed.visibleReplySent,
+					content: closed.content,
+					kind: "card"
+				});
+				if (result.visibleReplySent) markVisibleReplySent();
+				if (result.visibleReplySent && finalizedAnswerText) {
+					deliveredFinalTexts.add(finalizedAnswerText);
+					rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, result);
 				}
+				return {
+					result,
+					...generationToClose === void 0 ? {} : { generation: generationToClose }
+				};
 			}
+			return {
+				result: noVisibleFeishuReplyDelivery,
+				...generationToClose === void 0 ? {} : { generation: generationToClose }
+			};
+		} catch (error) {
+			return {
+				result: noVisibleFeishuReplyDelivery,
+				...generationToClose === void 0 ? {} : { generation: generationToClose },
+				error
+			};
 		} finally {
-			resetStreamingState();
+			if (streaming === streamingToClose) resetStreamingState();
+		}
+	};
+	const closeStreaming = () => {
+		const generation = activeStreamingGeneration;
+		if (generation !== void 0 && inFlightStreamingClose?.generation === generation) return inFlightStreamingClose.promise;
+		const content = streamText;
+		const closePromise = performStreamingClose();
+		if (generation !== void 0) {
+			const closing = {
+				generation,
+				content,
+				promise: closePromise
+			};
+			inFlightStreamingClose = closing;
+			const clear = () => {
+				if (inFlightStreamingClose === closing) inFlightStreamingClose = void 0;
+			};
+			closePromise.then(clear, clear);
 		}
+		return closePromise;
+	};
+	const deferStreamingDelivery = (result, infoKind, ownerGeneration) => {
+		let resolveFinalization;
+		let rejectFinalization;
+		const finalization = new Promise((resolve, reject) => {
+			resolveFinalization = resolve;
+			rejectFinalization = reject;
+		});
+		pendingStreamingDeliveries.push({
+			result,
+			...infoKind ? { infoKind } : {},
+			...ownerGeneration === void 0 ? {} : { streamingGeneration: ownerGeneration },
+			resolve: resolveFinalization,
+			reject: rejectFinalization
+		});
+		if (idleRequestedForReply) queueIdleSideEffects().catch((error) => params.runtime.error?.(`feishu[${account.accountId}] late reply finalization failed: ${String(error)}`));
+		return {
+			...noVisibleFeishuReplyDelivery,
+			finalization
+		};
 	};
 	const discardStreamingPreview = async () => {
 		try {
@@ -1731,75 +2178,101 @@ function createFeishuReplyDispatcher(params) {
 			limit: textChunkLimit,
 			mode: chunkMode,
 			firstChunkMentions: paramsLocal.firstChunkMentions,
+			chunkMentions: paramsLocal.chunkMentions,
 			initialChunks
 		}));
+		const results = [];
+		const acceptedChunks = [];
 		for (const [index, chunk] of chunks.entries()) {
-			await paramsLocal.sendChunk({
-				chunk,
-				isFirst: index === 0
-			});
-			markVisibleReplySent();
+			const mentions = [...paramsLocal.chunkMentions ?? [], ...index === 0 ? paramsLocal.firstChunkMentions ?? [] : []];
+			try {
+				const result = await paramsLocal.sendChunk({
+					chunk,
+					isFirst: index === 0,
+					mentions: mentions.length > 0 ? mentions : void 0
+				});
+				results.push(result);
+				acceptedChunks.push(chunk);
+				markVisibleReplySent();
+			} catch (error) {
+				throw createFeishuPartialReplyDeliveryError(error, createFeishuReplyDeliveryResult({
+					results,
+					visibleReplySent: results.length > 0,
+					content: acceptedChunks.join(""),
+					kind: paramsLocal.useCard ? "card" : "text"
+				}));
+			}
 		}
 		if (paramsLocal.infoKind === "final") deliveredFinalTexts.add(paramsLocal.text);
+		return createFeishuReplyDeliveryResult({
+			results,
+			visibleReplySent: results.length > 0,
+			content: paramsLocal.text,
+			kind: paramsLocal.useCard ? "card" : "text"
+		});
 	};
 	const sendMediaReplies = async (payload, options) => {
 		const mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
 		let sentFallbackText = false;
-		await sendMediaWithLeadingCaption({
-			mediaUrls,
-			caption: "",
-			send: async ({ mediaUrl }) => {
-				const result = await sendMediaFeishu({
-					cfg,
-					to: sendTarget,
-					mediaUrl,
-					replyToMessageId: sendReplyToMessageId,
-					replyInThread: effectiveReplyInThread,
-					accountId,
-					...payload.audioAsVoice === true ? { audioAsVoice: true } : {}
-				});
-				markVisibleReplySent();
-				if (result?.voiceIntentDegradedToFile && options?.fallbackText && !sentFallbackText) {
-					sentFallbackText = true;
-					await sendChunkedTextReply({
-						text: options.fallbackText,
-						useCard: false,
-						infoKind: "final",
-						sendChunk: async ({ chunk }) => {
-							await sendMessageFeishu({
-								cfg,
-								to: sendTarget,
-								text: chunk,
-								replyToMessageId: sendReplyToMessageId,
-								replyInThread: effectiveReplyInThread,
-								allowTopLevelReplyFallback,
-								accountId
-							});
-						}
+		let degradedVoiceFallbackText;
+		const results = [];
+		const sendFallbackText = async (text) => await sendChunkedTextReply({
+			text,
+			useCard: false,
+			infoKind: "final",
+			chunkMentions: requiredMentionTargets,
+			sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
+				cfg,
+				to: sendTarget,
+				text: chunk,
+				replyToMessageId: sendReplyToMessageId,
+				replyInThread: effectiveReplyInThread,
+				allowTopLevelReplyFallback,
+				accountId,
+				...mentions ? { mentions } : {}
+			})
+		});
+		try {
+			await sendMediaWithLeadingCaption({
+				mediaUrls,
+				caption: "",
+				send: async ({ mediaUrl }) => {
+					const result = await sendMediaFeishu({
+						cfg,
+						to: sendTarget,
+						mediaUrl,
+						replyToMessageId: sendReplyToMessageId,
+						replyInThread: effectiveReplyInThread,
+						allowTopLevelReplyFallback,
+						accountId,
+						...payload.audioAsVoice === true ? { audioAsVoice: true } : {}
+					});
+					results.push(createFeishuReplyDeliveryResult({
+						results: [result],
+						visibleReplySent: true,
+						kind: result?.voiceIntentDegradedToFile ? "media" : void 0
+					}));
+					markVisibleReplySent();
+					if (result?.voiceIntentDegradedToFile && options?.fallbackText && !sentFallbackText) degradedVoiceFallbackText = options.fallbackText;
+				},
+				onError: options?.fallbackText === void 0 ? void 0 : async ({ mediaUrl }) => {
+					const fallbackText = await buildFeishuMediaFallbackText({
+						text: sentFallbackText ? void 0 : options.fallbackText,
+						mediaUrl
 					});
+					sentFallbackText = true;
+					results.push(await sendFallbackText(fallbackText));
 				}
-			},
-			onError: options?.fallbackText === void 0 ? void 0 : async ({ mediaUrl }) => {
-				const fallbackText = formatMediaFallbackText(sentFallbackText ? void 0 : options.fallbackText, mediaUrl);
+			});
+			if (degradedVoiceFallbackText && !sentFallbackText) {
 				sentFallbackText = true;
-				await sendChunkedTextReply({
-					text: fallbackText,
-					useCard: false,
-					infoKind: "final",
-					sendChunk: async ({ chunk }) => {
-						await sendMessageFeishu({
-							cfg,
-							to: sendTarget,
-							text: chunk,
-							replyToMessageId: sendReplyToMessageId,
-							replyInThread: effectiveReplyInThread,
-							allowTopLevelReplyFallback,
-							accountId
-						});
-					}
-				});
+				results.push(await sendFallbackText(degradedVoiceFallbackText));
 			}
-		});
+		} catch (error) {
+			const partial = isChannelPartialDeliveryError(error) ? error.deliveryResult : void 0;
+			throw createFeishuPartialReplyDeliveryError(error, mergeFeishuReplyDeliveryResults([...results, ...partial ? [partial] : []]));
+		}
+		return mergeFeishuReplyDeliveryResults(results);
 	};
 	const ensureNoVisibleReplyFallback = async (reason) => {
 		await idleSideEffectsPromise;
@@ -1815,24 +2288,142 @@ 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})`);
 		return true;
 	};
-	const queueIdleSideEffects = (options) => {
+	const claimClosedStreamingResult = (generation, content) => {
+		if (generation !== void 0) {
+			const settlement = closedStreamingSettlements.get(generation);
+			if (settlement) settlement.contentClaimed = true;
+			return settlement;
+		}
+		let latestKey;
+		for (const [key, settlement] of closedStreamingSettlements) if (settlement.contentClaimed !== true && (content === void 0 || settlement.content === content)) latestKey = key;
+		if (latestKey === void 0) return;
+		const result = closedStreamingSettlements.get(latestKey);
+		if (result) result.contentClaimed = true;
+		return result;
+	};
+	const markClosedStreamingContentClaimed = (generation) => {
+		if (generation !== void 0) {
+			const settlement = closedStreamingSettlements.get(generation);
+			if (settlement) settlement.contentClaimed = true;
+		}
+	};
+	const ensureVisibleStreamingDelivery = async (result, content, infoKind) => {
+		if (result?.visibleReplySent === true || !content?.trim()) return result;
+		const cardHeader = resolveCardHeader(agentId, identity);
+		const cardNote = resolveCardNote(agentId, identity, prefixContext.prefixContext);
+		return await sendChunkedTextReply({
+			text: content,
+			useCard: true,
+			infoKind,
+			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 } : {}
+			})
+		});
+	};
+	function queueIdleSideEffects() {
+		idleRequestedForReply = true;
+		if (activeIdleSideEffectsPromise) return activeIdleSideEffectsPromise;
 		const nextIdleSideEffects = idleSideEffectsPromise.then(async () => {
-			await closeStreaming(options);
-			typingCallbacks?.onIdle?.();
+			try {
+				do {
+					const completions = pendingStreamingDeliveries.splice(0);
+					const closeOutcome = await closeStreaming();
+					const finalized = closeOutcome.result;
+					const ownsCurrentClose = (completion) => closeOutcome.generation !== void 0 && completion.streamingGeneration === closeOutcome.generation;
+					if (completions.some((completion) => ownsCurrentClose(completion))) markClosedStreamingContentClaimed(closeOutcome.generation);
+					for (const completion of completions) {
+						const claimedSettlement = ownsCurrentClose(completion) ? {
+							result: finalized,
+							...closeOutcome.error === void 0 ? {} : { error: closeOutcome.error }
+						} : claimClosedStreamingResult(completion.streamingGeneration, completion.result.content);
+						const deliveryError = claimedSettlement?.error;
+						let providerFinalized = claimedSettlement?.result;
+						try {
+							providerFinalized = await ensureVisibleStreamingDelivery(providerFinalized, completion.result.content, completion.infoKind);
+						} catch (fallbackError) {
+							const fallbackPartial = isChannelPartialDeliveryError(fallbackError) ? fallbackError.deliveryResult : void 0;
+							const fallbackCause = fallbackPartial && fallbackError instanceof Error ? fallbackError.cause ?? fallbackError : fallbackError;
+							completion.reject(createFeishuPartialReplyDeliveryError(deliveryError === void 0 ? fallbackCause : new AggregateError([deliveryError, fallbackCause], "Feishu streaming finalization and static fallback failed"), mergeFeishuReplyDeliveryResults([
+								...providerFinalized ? [providerFinalized] : [],
+								...fallbackPartial ? [fallbackPartial] : [],
+								completion.result
+							], fallbackPartial?.content ?? providerFinalized?.content ?? completion.result.content)));
+							continue;
+						}
+						const settledResult = mergeFeishuReplyDeliveryResults([...providerFinalized ? [providerFinalized] : [], completion.result], deliveryError === void 0 ? completion.result.content ?? providerFinalized?.content : providerFinalized?.content ?? completion.result.content);
+						if (deliveryError !== void 0) completion.reject(createFeishuPartialReplyDeliveryError(isChannelPartialDeliveryError(deliveryError) && deliveryError instanceof Error ? deliveryError.cause ?? deliveryError : deliveryError instanceof FeishuStreamingFinalizationError ? deliveryError.cause ?? deliveryError : deliveryError, settledResult));
+						else completion.resolve(settledResult);
+					}
+					if (closeOutcome.error !== void 0) throw toError(closeOutcome.error);
+				} while (pendingStreamingDeliveries.length > 0);
+			} finally {
+				typingCallbacks?.onIdle?.();
+			}
 		});
+		activeIdleSideEffectsPromise = nextIdleSideEffects;
 		idleSideEffectsPromise = nextIdleSideEffects.catch(() => {});
+		const finishIdleSideEffects = () => {
+			if (activeIdleSideEffectsPromise === nextIdleSideEffects) activeIdleSideEffectsPromise = null;
+			if (pendingStreamingDeliveries.length > 0) queueIdleSideEffects().catch((error) => params.runtime.error?.(`feishu[${account.accountId}] queued reply finalization failed: ${String(error)}`));
+		};
+		nextIdleSideEffects.then(finishIdleSideEffects, finishIdleSideEffects);
 		return nextIdleSideEffects;
+	}
+	const throwStreamingDeliveryFailure = async (paramsLocal) => {
+		let finalized = noVisibleFeishuReplyDelivery;
+		let finalizationError;
+		let fallbackPartial;
+		const claimedSettlement = claimClosedStreamingResult(paramsLocal.ownerGeneration, paramsLocal.content);
+		if (claimedSettlement) {
+			finalized = claimedSettlement.result;
+			finalizationError = claimedSettlement.error;
+		} else if (paramsLocal.ownerGeneration !== void 0 && inFlightStreamingClose?.generation === paramsLocal.ownerGeneration) {
+			const closeOutcome = await inFlightStreamingClose.promise;
+			const completedSettlement = claimClosedStreamingResult(paramsLocal.ownerGeneration, paramsLocal.content);
+			finalized = completedSettlement?.result ?? closeOutcome?.result ?? finalized;
+			finalizationError = completedSettlement?.error ?? closeOutcome?.error;
+		} else if (paramsLocal.ownerGeneration !== void 0 && activeStreamingGeneration === paramsLocal.ownerGeneration) {
+			const closeOutcome = await closeStreaming();
+			finalized = closeOutcome.result;
+			finalizationError = closeOutcome.error;
+		}
+		try {
+			finalized = await ensureVisibleStreamingDelivery(finalized, paramsLocal.content, paramsLocal.infoKind) ?? finalized;
+		} catch (fallbackError) {
+			fallbackPartial = isChannelPartialDeliveryError(fallbackError) ? fallbackError.deliveryResult : void 0;
+			const fallbackCause = fallbackPartial && fallbackError instanceof Error ? fallbackError.cause ?? fallbackError : fallbackError;
+			finalizationError = finalizationError ? new AggregateError([finalizationError, fallbackCause], "Feishu streaming finalization and static fallback failed") : fallbackCause;
+		}
+		const mediaPartial = isChannelPartialDeliveryError(paramsLocal.error) ? paramsLocal.error.deliveryResult : void 0;
+		const accepted = mergeFeishuReplyDeliveryResults([
+			finalized,
+			...fallbackPartial ? [fallbackPartial] : [],
+			...mediaPartial ? [mediaPartial] : []
+		], fallbackPartial?.visibleReplySent === true ? fallbackPartial.content : finalized.visibleReplySent === true ? finalized.content : paramsLocal.content);
+		const mediaCause = mediaPartial && paramsLocal.error instanceof Error ? paramsLocal.error.cause ?? paramsLocal.error : paramsLocal.error;
+		throw createFeishuPartialReplyDeliveryError(finalizationError ? new AggregateError([mediaCause, finalizationError instanceof Error ? finalizationError.cause ?? finalizationError : finalizationError], "Feishu reply delivery and streaming finalization failed") : mediaCause, accepted);
 	};
-	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,
@@ -1846,52 +2437,80 @@ function createFeishuReplyDispatcher(params) {
 			if (!replyLifecycleStateInitialized) {
 				replyLifecycleStateInitialized = true;
 				deliveredFinalTexts.clear();
+				closedStreamingSettlements.clear();
 				sentIndependentBlockText = false;
-				streamingClosedForReply = false;
-				streamingCloseErroredForReply = false;
+				idleRequestedForReply = false;
 				visibleReplySent = false;
 				skippedFinalReason = null;
 			}
-			if (streamingEnabled && renderMode === "card") startStreaming();
+			if (previewStreamingEnabled && 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({
+		onIdle: () => queueIdleSideEffects(),
+		onCleanup: () => {
+			typingCallbacks?.onCleanup?.();
+		}
+	};
+	const handleDeliveryError = async (error, info) => {
+		params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
+		await queueIdleSideEffects().catch((cleanupError) => params.runtime.error?.(`feishu[${account.accountId}] reply error cleanup failed: ${String(cleanupError)}`));
+	};
+	return {
+		dispatcherOptions,
+		delivery: {
+			observeMessageSent: true,
+			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 useCard = useStaticCard || useStreamingCard;
+				const skipTextForDuplicateFinal = info?.kind === "final" && hasText && deliveredFinalTexts.has(text);
+				const shouldDeliverText = hasText && !hasVoiceMedia && !skipTextForDuplicateFinal;
+				const shouldDiscardStreamingPreview = info?.kind === "final" && (finalTextExceedsStreamingLimit || hasMedia && (hasVoiceMedia && !shouldDeliverText && !ttsTextAlreadyVisible || skipTextForDuplicateFinal));
+				const priorClosedStreamingSettlement = info?.kind === "final" && hasText && skipTextForDuplicateFinal ? claimClosedStreamingResult(void 0, text) : void 0;
+				if (!shouldDeliverText && !hasMedia) {
+					if (priorClosedStreamingSettlement?.error !== void 0) throw toError(priorClosedStreamingSettlement.error);
+					return priorClosedStreamingSettlement?.result ?? noVisibleFeishuReplyDelivery;
+				}
+				const deliveredResults = priorClosedStreamingSettlement ? [priorClosedStreamingSettlement.result] : [];
+				const collectMediaDelivery = async (mediaPayload, mediaOptions) => {
+					try {
+						deliveredResults.push(await sendMediaReplies(mediaPayload, mediaOptions));
+					} catch (error) {
+						const partial = isChannelPartialDeliveryError(error) ? error.deliveryResult : void 0;
+						const accumulated = mergeFeishuReplyDeliveryResults([...deliveredResults, ...partial ? [partial] : []]);
+						throw createFeishuPartialReplyDeliveryError(partial && error instanceof Error ? error.cause ?? error : error, accumulated);
+					}
+				};
+				if (shouldDiscardStreamingPreview) await discardStreamingPreview();
+				if (shouldDeliverText) {
+					if (info?.kind === "block") {
+						if (!useStreamingCard) {
+							if (coreBlockStreamingEnabled) {
+								const firstChunkMentions = !sentIndependentBlockText && mentionTargets?.length ? mentionTargets : void 0;
+								deliveredResults.push(await sendChunkedTextReply({
+									text,
+									useCard: false,
+									infoKind: "block",
+									firstChunkMentions,
+									chunkMentions: requiredMentionTargets,
+									sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
 										cfg,
 										to: sendTarget,
 										text: chunk,
@@ -1899,47 +2518,59 @@ function createFeishuReplyDispatcher(params) {
 										replyInThread: effectiveReplyInThread,
 										allowTopLevelReplyFallback,
 										accountId,
-										...isFirst && firstChunkMentions ? { mentions: firstChunkMentions } : {}
-									});
-								}
-							});
-							sentIndependentBlockText = true;
-							if (hasMedia) await sendMediaReplies(payload);
+										...mentions ? { mentions } : {}
+									})
+								}));
+								sentIndependentBlockText = true;
+								if (hasMedia) await collectMediaDelivery(payload);
+							}
+							return mergeFeishuReplyDeliveryResults(deliveredResults, text);
 						}
-						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({
+					const shouldStreamText = info?.kind === "block" || info?.kind === "final";
+					const matchingInFlightClose = info?.kind === "final" && inFlightStreamingClose?.content === text ? inFlightStreamingClose : void 0;
+					const ownerGeneration = activeStreamingGeneration ?? matchingInFlightClose?.generation;
+					if (shouldStreamText && ownerGeneration !== void 0 && (streaming?.isActive() || matchingInFlightClose !== void 0)) {
+						if (activeStreamingGeneration !== void 0) {
+							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) try {
+							await collectMediaDelivery(payload);
+						} catch (error) {
+							await throwStreamingDeliveryFailure({
+								error,
+								content: text,
+								infoKind: info?.kind,
+								ownerGeneration
+							});
+						}
+						return deferStreamingDelivery(mergeFeishuReplyDeliveryResults(deliveredResults, text), info?.kind, ownerGeneration);
+					}
+					if (useCard) {
+						const cardHeader = resolveCardHeader(agentId, identity);
+						const cardNote = resolveCardNote(agentId, identity, prefixContext.prefixContext);
+						deliveredResults.push(await sendChunkedTextReply({
+							text,
+							useCard: true,
+							infoKind: info?.kind,
+							chunkMentions: requiredMentionTargets,
+							sendChunk: async ({ chunk, mentions }) => await sendStructuredCardFeishu({
 								cfg,
 								to: sendTarget,
 								text: chunk,
@@ -1948,19 +2579,19 @@ function createFeishuReplyDispatcher(params) {
 								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({
+								note: cardNote,
+								...mentions ? { mentions } : {}
+							})
+						}));
+					} else {
+						const firstChunkMentions = info?.kind === "final" && mentionTargets?.length ? mentionTargets : void 0;
+						deliveredResults.push(await sendChunkedTextReply({
+							text,
+							useCard: false,
+							infoKind: info?.kind,
+							firstChunkMentions,
+							chunkMentions: requiredMentionTargets,
+							sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
 								cfg,
 								to: sendTarget,
 								text: chunk,
@@ -1968,32 +2599,22 @@ function createFeishuReplyDispatcher(params) {
 								replyInThread: effectiveReplyInThread,
 								allowTopLevelReplyFallback,
 								accountId,
-								...isFirst && firstChunkMentions ? { mentions: firstChunkMentions } : {}
-							});
-						}
-					});
+								...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 collectMediaDelivery(payload, hasVoiceMedia && hasText ? { fallbackText: text } : void 0);
+				const result = mergeFeishuReplyDeliveryResults(deliveredResults, text);
+				if (priorClosedStreamingSettlement?.error !== void 0) throw createFeishuPartialReplyDeliveryError(isChannelPartialDeliveryError(priorClosedStreamingSettlement.error) && priorClosedStreamingSettlement.error instanceof Error ? priorClosedStreamingSettlement.error.cause ?? priorClosedStreamingSettlement.error : priorClosedStreamingSettlement.error, result);
+				return result;
+			},
+			onError: handleDeliveryError
 		},
-		onIdle: () => queueIdleSideEffects(),
-		onCleanup: () => {
-			typingCallbacks?.onCleanup?.();
-		}
-	});
-	return {
-		dispatcher,
 		replyOptions: {
-			...replyOptions,
 			onModelSelected: prefixContext.onModelSelected,
 			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : true,
-			onPartialReply: streamingEnabled ? (payload) => {
+			onPartialReply: previewStreamingEnabled ? (payload) => {
 				if (!payload.text) return;
 				const cleaned = stripReasoningTagsFromText(payload.text, {
 					mode: "strict",
@@ -2012,7 +2633,7 @@ function createFeishuReplyDispatcher(params) {
 				queueReasoningUpdate(formatReasoningMessage(payload.text));
 			} : void 0,
 			onReasoningEnd: reasoningPreviewEnabled ? () => {} : void 0,
-			onToolStart: streamingEnabled ? (payload) => {
+			onToolStart: previewStreamingEnabled ? (payload) => {
 				if (!isChannelProgressDraftWorkToolName(payload.name)) return;
 				const statusLineLocal = formatChannelProgressDraftLineForEntry(account.config, {
 					event: "tool",
@@ -2022,17 +2643,16 @@ function createFeishuReplyDispatcher(params) {
 				}, { detailMode: payload.detailMode });
 				if (statusLineLocal) updateStreamingStatusLine(statusLineLocal);
 			} : void 0,
-			onAssistantMessageStart: streamingEnabled ? () => {
+			onAssistantMessageStart: previewStreamingEnabled ? () => {
 				updateStreamingStatusLine("", { startIfNeeded: false });
 			} : void 0,
-			onCompactionStart: streamingEnabled ? () => {
+			onCompactionStart: previewStreamingEnabled ? () => {
 				updateStreamingStatusLine("📦 **Compacting context...**");
 			} : void 0,
-			onCompactionEnd: streamingEnabled ? () => {
+			onCompactionEnd: previewStreamingEnabled ? () => {
 				updateStreamingStatusLine("");
 			} : void 0
 		},
-		markDispatchIdle,
 		ensureNoVisibleReplyFallback,
 		getVisibleReplyState: () => ({
 			visibleReplySent,
@@ -2041,6 +2661,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;
@@ -2055,15 +2686,14 @@ function isFeishuTopicSessionScope(scope) {
 	return scope === "group_topic" || scope === "group_topic_sender";
 }
 async function resolveFeishuAudioPreflightTranscript(params) {
-	if (params.content.trim() !== "<media:audio>") return;
-	const audioMedia = params.mediaList.filter((media) => media.contentType?.startsWith("audio/"));
+	if (params.messageType !== "audio" || params.content.trim()) return;
+	const audioMedia = params.mediaList.filter((media) => Boolean(media.path) && (media.kind === "audio" || media.contentType?.startsWith("audio/")));
 	if (audioMedia.length === 0) return;
 	try {
 		const { transcribeFirstAudio } = await import("./audio-preflight.runtime-BBfC9elv.js");
 		return await transcribeFirstAudio({
 			ctx: {
-				MediaPaths: audioMedia.map((media) => media.path),
-				MediaTypes: audioMedia.map((media) => media.contentType).filter(Boolean),
+				media: audioMedia,
 				ChatType: params.chatType
 			},
 			cfg: params.cfg
@@ -2074,8 +2704,7 @@ async function resolveFeishuAudioPreflightTranscript(params) {
 	}
 }
 /**
-* Build media payload for inbound context.
-* Similar to Discord's buildDiscordMediaPayload().
+* Parse an inbound Feishu event into its caption and routing metadata.
 */
 function parseFeishuMessageEvent(event, botOpenId, _botName) {
 	const rawContent = parseMessageContent(event.message.content, event.message.message_type);
@@ -2093,6 +2722,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,
@@ -2142,7 +2772,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, processingClaim, messageDedupeKey: messageDedupeKeyOverride } = params;
+	const { cfg, event, botOpenId, botName, runtime, channelRuntime, chatHistories, accountId, processingClaim, messageDedupeKey: messageDedupeKeyOverride, turnAdoptionLifecycle } = params;
 	const account = resolveFeishuRuntimeAccount({
 		cfg,
 		accountId
@@ -2152,7 +2782,7 @@ async function handleFeishuMessage(params) {
 	const error = runtime?.error ?? console.error;
 	const messageId = event.message.message_id;
 	const messageDedupeKey = messageDedupeKeyOverride ?? resolveFeishuMessageDedupeKey(event);
-	if (!await finalizeFeishuMessageProcessing({
+	if (!turnAdoptionLifecycle && !await finalizeFeishuMessageProcessing({
 		messageId: messageDedupeKey,
 		namespace: account.accountId,
 		log,
@@ -2164,7 +2794,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 {
@@ -2195,7 +2880,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,
@@ -2332,6 +3027,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 };
@@ -2379,7 +3091,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
 					});
@@ -2514,7 +3226,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,
@@ -2534,7 +3246,7 @@ async function handleFeishuMessage(params) {
 		});
 		log(`feishu[${account.accountId}]: ${inboundLabel}: ${preview}`);
 		const mediaMaxBytes = (feishuCfg?.mediaMaxMb ?? 30) * 1024 * 1024;
-		const mediaResolution = await resolveFeishuMediaList({
+		const mediaList = await resolveFeishuMediaList({
 			cfg,
 			messageId: ctx.messageId,
 			messageType: event.message.message_type,
@@ -2543,12 +3255,10 @@ async function handleFeishuMessage(params) {
 			log,
 			accountId: account.accountId
 		});
-		const mediaList = mediaResolution.media;
-		const mediaFailurePresentation = resolveFeishuMediaFailurePresentation(event.message.content, event.message.message_type);
-		const mediaFailureContent = mediaResolution.unavailableCount > 0 ? formatInboundMediaUnavailableText({
-			body: mediaFailurePresentation.unavailableBody ?? ctx.content,
-			mediaPlaceholder: mediaFailurePresentation.mediaPlaceholder,
-			notice: `[feishu ${mediaResolution.unavailableCount > 1 ? `${mediaResolution.unavailableCount} attachments` : "attachment"} unavailable]`
+		const unavailableMediaCount = mediaList.filter((media) => !media.path).length;
+		const mediaFailureContent = unavailableMediaCount > 0 ? formatInboundMediaUnavailableText({
+			body: ctx.content,
+			notice: `[feishu ${unavailableMediaCount > 1 ? `${unavailableMediaCount} attachments` : "attachment"} unavailable]`
 		}) : ctx.content;
 		let quotedMessageInfo = null;
 		let quotedContent;
@@ -2583,11 +3293,17 @@ async function handleFeishuMessage(params) {
 			cfg: effectiveCfg,
 			mediaList,
 			content: ctx.content,
+			messageType: event.message.message_type,
 			chatType: isGroup ? "group" : "direct",
 			log
 		});
-		const preflightAudioIndex = audioTranscript === void 0 ? -1 : mediaList.findIndex((media) => media.contentType?.startsWith("audio/"));
+		const preflightAudioIndex = audioTranscript === void 0 ? -1 : mediaList.findIndex((media) => media.kind === "audio" || 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 : {
@@ -2618,7 +3334,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,
@@ -2627,7 +3343,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(),
@@ -2639,7 +3355,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,
@@ -2706,7 +3422,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
@@ -2748,7 +3464,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,
@@ -2770,7 +3486,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,
@@ -2789,7 +3504,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",
@@ -2800,6 +3516,7 @@ async function handleFeishuMessage(params) {
 				},
 				route: {
 					agentId,
+					dmScope: route.dmScope,
 					accountId: agentAccountId,
 					routeSessionKey: agentSessionKey
 				},
@@ -2815,6 +3532,7 @@ async function handleFeishuMessage(params) {
 					rawBody: commandFacingContent,
 					commandBody: commandFacingContent
 				},
+				sessionTranscript: { historyLimit: isGroup ? historyLimit : 0 },
 				access: {
 					mentions: {
 						canDetectMention: isGroup,
@@ -2864,189 +3582,225 @@ async function handleFeishuMessage(params) {
 			};
 		};
 		if (broadcastAgents) {
-			if (!await recordProcessedFeishuMessage(messageDedupeKey ?? ctx.messageId, "broadcast", log)) {
+			const broadcastDedupeKey = messageDedupeKey ?? ctx.messageId;
+			const broadcastClaim = await claimUnprocessedFeishuMessage({
+				messageId: broadcastDedupeKey,
+				namespace: "broadcast",
+				log
+			});
+			if (broadcastClaim.kind === "duplicate" || broadcastClaim.kind === "inflight") {
 				log(`feishu[${account.accountId}]: broadcast already claimed by another account for message ${ctx.messageId}; skipping`);
 				return;
 			}
+			const broadcastSettlement = createFeishuBroadcastIngressSettlement({
+				lifecycle: turnAdoptionLifecycle,
+				replayClaim: broadcastClaim.kind === "claimed" ? broadcastClaim.handle : void 0,
+				onReplayCommitError: (err) => error(`feishu[${account.accountId}]: failed to commit broadcast replay guard: ${String(err)}`),
+				onAdopted: () => {
+					if (isGroup && historyKey && chatHistories) createChannelHistoryWindow({ historyMap: chatHistories }).clear({
+						historyKey,
+						limit: historyLimit
+					});
+				}
+			});
+			const abandonBroadcast = async (err) => {
+				try {
+					await broadcastSettlement.onDispatchFailed(err);
+				} catch (abandonError) {
+					error(`feishu[${account.accountId}]: failed to abandon broadcast ingress: ${String(abandonError)}`);
+				}
+			};
 			const strategy = cfg.broadcast?.strategy === "sequential" ? "sequential" : "parallel";
 			const activeAgentId = ctx.mentionedBot || !requireMention ? normalizeAgentId$2(route.agentId) : null;
 			const agentIds = (cfg.agents?.list ?? []).map((a) => normalizeAgentId$2(a.id));
 			const hasKnownAgents = agentIds.length > 0;
 			log(`feishu[${account.accountId}]: broadcasting to ${broadcastAgents.length} agents (strategy=${strategy}, active=${activeAgentId ?? "none"})`);
 			const dispatchForAgent = async (agentId) => {
-				if (hasKnownAgents && !agentIds.includes(normalizeAgentId$2(agentId))) {
+				const normalizedAgentId = normalizeAgentId$2(agentId);
+				if (hasKnownAgents && !agentIds.includes(normalizedAgentId)) {
 					log(`feishu[${account.accountId}]: broadcast agent ${agentId} not found in agents.list; skipping`);
 					return;
 				}
-				const agentSessionKey = buildBroadcastSessionKey(route.sessionKey, route.agentId, agentId);
-				const agentStorePath = core.channel.session.resolveStorePath(cfg.session?.store, { agentId });
-				const agentRecord = {
-					updateLastRoute: buildFeishuInboundLastRouteUpdate({
-						sessionKey: agentSessionKey,
-						accountId: route.accountId
-					}),
-					onRecordError: (err) => {
-						log(`feishu[${account.accountId}]: failed to record broadcast inbound session ${agentSessionKey}: ${String(err)}`);
+				let agentClaim;
+				for (let attempt = 0; attempt < 2; attempt += 1) {
+					agentClaim = await claimUnprocessedFeishuMessage({
+						messageId: broadcastDedupeKey,
+						namespace: `broadcast:${normalizedAgentId}`,
+						log
+					});
+					if (agentClaim.kind === "duplicate") return;
+					if (agentClaim.kind !== "inflight") break;
+					broadcastSettlement.onLanePending();
+					try {
+						await agentClaim.pending;
+						return;
+					} catch (err) {
+						if (attempt === 1) throw err;
 					}
-				};
-				const allowReasoningPreview = resolveFeishuReasoningPreviewEnabled({
-					cfg,
-					agentId,
-					storePath: agentStorePath,
-					sessionKey: agentSessionKey
-				});
-				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 lane = broadcastSettlement.createLane(agentClaim?.kind === "claimed" ? agentClaim.handle : void 0);
+				try {
+					const agentSessionKey = buildBroadcastSessionKey(route.sessionKey, route.agentId, agentId);
+					const agentStorePath = resolveStorePath(cfg.session?.store, { agentId });
+					const agentRecord = {
+						updateLastRoute: buildFeishuInboundLastRouteUpdate({
+							sessionKey: agentSessionKey,
+							accountId: route.accountId
+						}),
+						onRecordError: (err) => {
+							log(`feishu[${account.accountId}]: failed to record broadcast inbound session ${agentSessionKey}: ${String(err)}`);
+						}
+					};
+					const allowReasoningPreview = resolveFeishuReasoningPreviewEnabled({
 						cfg,
 						agentId,
-						runtime,
-						chatId: ctx.chatId,
-						sendTarget: feishuTo,
-						allowReasoningPreview,
-						replyToMessageId: replyTargetMessageId,
-						typingTargetMessageId,
-						skipReplyToInMessages: !isGroup && !directThreadReply,
-						replyInThread,
-						rootId: ctx.rootId,
-						threadReply,
-						accountId: account.accountId,
-						identity,
-						mentionTargets: ctx.mentionTargets,
-						messageCreateTimeMs,
+						storePath: agentStorePath,
 						sessionKey: agentSessionKey
 					});
-					log(`feishu[${account.accountId}]: broadcast active dispatch agent=${agentId} (session=${agentSessionKey})`);
-					const turnResult = await core.channel.inbound.run({
-						channel: "feishu",
-						accountId: route.accountId,
-						raw: ctx,
-						adapter: {
-							ingest: () => ({
-								id: ctx.messageId,
-								timestamp: messageCreateTimeMs,
-								rawText: ctx.content,
-								textForAgent: agentCtx.BodyForAgent,
-								textForCommands: agentCtx.CommandBody,
-								raw: ctx
-							}),
-							resolveTurn: () => ({
-								channel: "feishu",
-								accountId: route.accountId,
-								routeSessionKey: agentSessionKey,
-								storePath: agentStorePath,
-								ctxPayload: agentCtx,
-								recordInboundSession: core.channel.session.recordInboundSession,
-								record: agentRecord,
-								onPreDispatchFailure: () => core.channel.reply.settleReplyDispatcher({
-									dispatcher,
-									onSettled: () => markDispatchIdle()
+					const agentCtx = await buildCtxPayloadForAgent(agentId, agentSessionKey, route.accountId, ctx.mentionedBot && agentId === activeAgentId);
+					if (agentId === activeAgentId) {
+						const identity = resolveAgentOutboundIdentity(cfg, agentId);
+						const { dispatcherOptions, delivery, replyOptions, ensureNoVisibleReplyFallback } = createFeishuReplyDispatcher({
+							cfg,
+							agentId,
+							runtime,
+							chatId: ctx.chatId,
+							sendTarget: feishuTo,
+							allowReasoningPreview,
+							replyToMessageId: replyTargetMessageId,
+							typingTargetMessageId,
+							skipReplyToInMessages: !isGroup && !directThreadReply,
+							replyInThread,
+							rootId: ctx.rootId,
+							threadReply,
+							accountId: account.accountId,
+							identity,
+							mentionTargets: ctx.mentionTargets,
+							requiredMentionTargets,
+							messageCreateTimeMs,
+							sessionKey: agentSessionKey
+						});
+						log(`feishu[${account.accountId}]: broadcast active dispatch agent=${agentId} (session=${agentSessionKey})`);
+						const turnResult = await core.channel.inbound.run({
+							channel: "feishu",
+							accountId: route.accountId,
+							raw: ctx,
+							adapter: {
+								ingest: () => ({
+									id: ctx.messageId,
+									timestamp: messageCreateTimeMs,
+									rawText: ctx.content,
+									textForAgent: agentCtx.BodyForAgent,
+									textForCommands: agentCtx.CommandBody,
+									raw: ctx
 								}),
-								runDispatch: () => core.channel.reply.withReplyDispatcher({
-									dispatcher,
-									onSettled: () => markDispatchIdle(),
-									run: () => core.channel.reply.dispatchReplyFromConfig({
-										ctx: agentCtx,
-										cfg,
-										dispatcher,
-										replyOptions
-									})
+								resolveTurn: () => ({
+									cfg,
+									channel: "feishu",
+									accountId: route.accountId,
+									route: {
+										agentId,
+										sessionKey: agentSessionKey
+									},
+									ctxPayload: agentCtx,
+									record: agentRecord,
+									dispatcherOptions,
+									delivery,
+									replyOptions: {
+										...replyOptions,
+										...bindIngressLifecycleToReplyOptions(lane.lifecycle)
+									}
 								})
-							})
-						}
-					});
-					if (turnResult.dispatched && shouldSendNoVisibleReplyFallback({
-						...turnResult.dispatchResult,
-						failedCounts: dispatcher.getFailedCounts?.() ?? {
-							tool: 0,
-							block: 0,
-							final: 0
-						}
-					})) 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",
-						accountId: route.accountId,
-						raw: ctx,
-						adapter: {
-							ingest: () => ({
-								id: ctx.messageId,
-								timestamp: messageCreateTimeMs,
-								rawText: ctx.content,
-								textForAgent: agentCtx.BodyForAgent,
-								textForCommands: agentCtx.CommandBody,
-								raw: ctx
-							}),
-							resolveTurn: () => ({
-								channel: "feishu",
-								accountId: route.accountId,
-								routeSessionKey: agentSessionKey,
-								storePath: agentStorePath,
-								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
-									})
+							}
+						});
+						if (turnResult.dispatched && shouldSendNoVisibleReplyFallback(turnResult.dispatchResult)) await ensureNoVisibleReplyFallback("broadcast-dispatch-complete-no-visible-reply");
+						await lane.onDispatchComplete(turnResult.dispatched);
+					} else {
+						delete agentCtx.CommandAuthorized;
+						log(`feishu[${account.accountId}]: broadcast observer dispatch agent=${agentId} (session=${agentSessionKey})`);
+						const turnResult = await core.channel.inbound.run({
+							channel: "feishu",
+							accountId: route.accountId,
+							raw: ctx,
+							adapter: {
+								ingest: () => ({
+									id: ctx.messageId,
+									timestamp: messageCreateTimeMs,
+									rawText: ctx.content,
+									textForAgent: agentCtx.BodyForAgent,
+									textForCommands: agentCtx.CommandBody,
+									raw: ctx
+								}),
+								resolveTurn: () => ({
+									cfg,
+									channel: "feishu",
+									accountId: route.accountId,
+									route: {
+										agentId,
+										sessionKey: agentSessionKey
+									},
+									ctxPayload: agentCtx,
+									record: agentRecord,
+									admission: {
+										kind: "observeOnly",
+										reason: "broadcast-observer"
+									},
+									delivery: { deliver: async () => ({ visibleReplySent: false }) },
+									replyOptions: bindIngressLifecycleToReplyOptions(lane.lifecycle)
 								})
-							})
-						}
-					});
+							}
+						});
+						await lane.onDispatchComplete(turnResult.dispatched);
+					}
+				} catch (err) {
+					await lane.onDispatchFailed(err);
+					throw err;
 				}
 			};
+			const results = [];
 			if (strategy === "sequential") for (const agentId of broadcastAgents) try {
 				await dispatchForAgent(agentId);
-			} catch (err) {
-				log(`feishu[${account.accountId}]: broadcast dispatch failed for agent=${agentId}: ${String(err)}`);
+				results.push({
+					status: "fulfilled",
+					value: void 0
+				});
+			} catch (reason) {
+				results.push({
+					status: "rejected",
+					reason
+				});
 			}
-			else {
-				const results = await Promise.allSettled(broadcastAgents.map(dispatchForAgent));
-				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)}`);
-				}
+			else results.push(...await Promise.allSettled(broadcastAgents.map(dispatchForAgent)));
+			const failures = [];
+			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)}`);
+				failures.push(result.reason);
+			}
+			if (failures.length > 0) {
+				const failure = failures.length === 1 ? failures[0] : new AggregateError(failures, "Feishu broadcast dispatch failed");
+				await abandonBroadcast(failure);
+				throw failure;
+			}
+			try {
+				await broadcastSettlement.onDispatchComplete();
+			} catch (err) {
+				await abandonBroadcast(err);
+				throw err;
 			}
-			if (isGroup && historyKey && chatHistories) createChannelHistoryWindow({ historyMap: chatHistories }).clear({
-				historyKey,
-				limit: historyLimit
-			});
 			log(`feishu[${account.accountId}]: broadcast dispatch complete for ${broadcastAgents.length} agents`);
 		} 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,
@@ -3062,6 +3816,7 @@ async function handleFeishuMessage(params) {
 				accountId: account.accountId,
 				identity,
 				mentionTargets: ctx.mentionTargets,
+				requiredMentionTargets,
 				messageCreateTimeMs,
 				sessionKey: route.sessionKey
 			});
@@ -3080,12 +3835,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,
@@ -3101,40 +3858,24 @@ 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: {
+							...replyOptions,
+							...turnAdoptionLifecycle ? bindIngressLifecycleToReplyOptions(turnAdoptionLifecycle) : {}
+						}
 					})
 				}
 			});
 			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) {
 		error(`feishu[${account.accountId}]: failed to dispatch message: ${String(err)}`);
+		if (turnAdoptionLifecycle) throw err;
 	}
 }
 //#endregion
@@ -3250,7 +3991,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;
@@ -3286,7 +4027,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,
@@ -3484,32 +4225,376 @@ async function handleFeishuCardAction(params) {
 				completeFeishuCardAction(event.token, account.accountId);
 				return;
 			}
-			await sendInvalidInteractionNotice({
-				cfg,
-				event,
-				reason: "malformed",
-				accountId
-			});
-			completeFeishuCardAction(event.token, account.accountId);
-			return;
+			await sendInvalidInteractionNotice({
+				cfg,
+				event,
+				reason: "malformed",
+				accountId
+			});
+			completeFeishuCardAction(event.token, account.accountId);
+			return;
+		}
+		const content = buildFeishuCardActionTextFallback(event);
+		log(`feishu[${account.accountId}]: handling card action from ${event.operator.open_id}: ${content}`);
+		await dispatchSyntheticCommand({
+			cfg,
+			event,
+			command: content,
+			account,
+			botOpenId: params.botOpenId,
+			runtime,
+			channelRuntime: params.channelRuntime,
+			accountId
+		});
+		completeFeishuCardAction(event.token, account.accountId);
+	} catch (err) {
+		completeFeishuCardAction(event.token, account.accountId);
+		throw err;
+	}
+}
+//#endregion
+//#region extensions/feishu/src/feishu-ingress.ts
+const FEISHU_INGRESS_PAYLOAD_VERSION = 1;
+const FEISHU_INGRESS_POLL_INTERVAL_MS = 500;
+const FEISHU_INGRESS_PRUNE_INTERVAL_MS = 3600 * 1e3;
+const FEISHU_INGRESS_COMPLETED_TTL_MS = 720 * 60 * 60 * 1e3;
+const FEISHU_INGRESS_COMPLETED_MAX_ENTRIES = 2e4;
+const FEISHU_INGRESS_FAILED_TTL_MS = 720 * 60 * 60 * 1e3;
+const FEISHU_INGRESS_FAILED_MAX_ENTRIES = 2e4;
+const FEISHU_DURABLE_EVENT_TYPES = /* @__PURE__ */ new Set(["drive.notice.comment_add_v1", "im.message.receive_v1"]);
+var FeishuIngressPermanentError = class extends Error {
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.name = "FeishuIngressPermanentError";
+	}
+};
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function parseRawEnvelope(rawEnvelope) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawEnvelope);
+	} catch (error) {
+		throw new FeishuIngressPermanentError("invalid-event", "Feishu ingress envelope contains invalid JSON.", { cause: error });
+	}
+	if (!isRecord$1(parsed)) throw new FeishuIngressPermanentError("invalid-event", "Feishu ingress envelope must be a JSON object.");
+	return parsed;
+}
+function decryptEnvelope(envelope, encryptKey) {
+	const encrypted = readString(envelope.encrypt);
+	if (!encrypted) return envelope;
+	const key = encryptKey?.trim();
+	if (!key) throw new FeishuIngressPermanentError("authentication-failed", "Feishu encrypted ingress envelope has no configured encrypt key.");
+	try {
+		return parseRawEnvelope(new Lark.AESCipher(key).decrypt(encrypted));
+	} catch (error) {
+		if (error instanceof FeishuIngressPermanentError) throw error;
+		throw new FeishuIngressPermanentError("authentication-failed", "Feishu ingress envelope decryption failed.", { cause: error });
+	}
+}
+function inspectFeishuIngressEnvelope(rawEnvelope, encryptKey, allowInvalidLane = false) {
+	const envelope = decryptEnvelope(parseRawEnvelope(rawEnvelope), encryptKey);
+	const nestedHeader = isRecord$1(envelope.header) ? envelope.header : null;
+	const nestedEvent = isRecord$1(envelope.event) ? envelope.event : null;
+	const eventType = readString(nestedHeader?.event_type) ?? readString(envelope.event_type);
+	if (!eventType || !FEISHU_DURABLE_EVENT_TYPES.has(eventType)) return null;
+	const eventId = readString(nestedHeader?.event_id) ?? readString(envelope.event_id);
+	if (!eventId) throw new FeishuIngressPermanentError("invalid-event", `Feishu ${eventType} envelope is missing header.event_id.`);
+	const event = nestedEvent ?? envelope;
+	if (eventType === "im.message.receive_v1") {
+		const chatId = readString((isRecord$1(event.message) ? event.message : null)?.chat_id);
+		if (!chatId) {
+			if (allowInvalidLane) return {
+				eventId,
+				eventType,
+				laneKey: `invalid:${eventType}:${eventId}`
+			};
+			throw new FeishuIngressPermanentError("invalid-event", "Feishu message ingress envelope is missing event.message.chat_id.");
+		}
+		return {
+			eventId,
+			eventType,
+			laneKey: `chat:${chatId}`
+		};
+	}
+	const noticeMeta = isRecord$1(event.notice_meta) ? event.notice_meta : null;
+	const fileType = readString(noticeMeta?.file_type);
+	const documentId = readString(noticeMeta?.file_token);
+	if (!fileType || !documentId) {
+		if (allowInvalidLane) return {
+			eventId,
+			eventType,
+			laneKey: `invalid:${eventType}:${eventId}`
+		};
+		throw new FeishuIngressPermanentError("invalid-event", "Feishu comment ingress envelope is missing its document identity.");
+	}
+	return {
+		eventId,
+		eventType,
+		laneKey: `comment-doc:${fileType}:${documentId}`
+	};
+}
+function resolveFeishuIngressNonRetryableFailure(error) {
+	if (error instanceof FeishuIngressPermanentError) return {
+		reason: error.reason,
+		message: error.message
+	};
+	for (const candidate of collectErrorGraphCandidates(error, (current) => [current.cause, current.response])) {
+		const status = isRecord$1(candidate) ? candidate.status : void 0;
+		if (status === 401 || status === 403) return {
+			reason: "authentication-failed",
+			message: formatErrorMessage(error)
+		};
+	}
+	return null;
+}
+/** Fan one merged Feishu turn's adoption across every transport and logical claim. */
+function buildFeishuFlushIngressLifecycle(sources, options) {
+	const durableSources = sources.filter((source) => source.lifecycle !== void 0);
+	const lifecycles = durableSources.map((source) => source.lifecycle);
+	const replayClaims = durableSources.map((source) => source.replayClaim).filter((claim) => claim !== void 0);
+	const [firstLifecycle] = lifecycles;
+	if (!firstLifecycle) return {
+		lifecycle: void 0,
+		settle: async () => {}
+	};
+	let handedOff = false;
+	let terminal;
+	let adopting;
+	let abandoning;
+	const releaseReplayClaims = () => {
+		for (const claim of replayClaims) claim.release({ error: /* @__PURE__ */ new Error("feishu-ingress-not-adopted") });
+	};
+	const runAbandon = async () => {
+		if (terminal) return;
+		releaseReplayClaims();
+		await Promise.all(lifecycles.map(async (lifecycle) => await lifecycle.onAbandoned()));
+		terminal = "abandoned";
+	};
+	const ensureAbandoned = async () => {
+		if (terminal) return;
+		const activeAbandonment = abandoning ?? runAbandon();
+		abandoning = activeAbandonment;
+		try {
+			await activeAbandonment;
+		} finally {
+			if (abandoning === activeAbandonment && terminal !== "abandoned") abandoning = void 0;
+		}
+	};
+	const abandonAll = async () => {
+		if (terminal) return;
+		if (adopting) {
+			await adopting.catch(() => void 0);
+			if (terminal) return;
+		}
+		await ensureAbandoned();
+	};
+	const adoptAll = async () => {
+		if (terminal) return;
+		if (abandoning) {
+			await abandoning.catch(() => void 0);
+			if (terminal) return;
+		}
+		const activeAdoption = adopting ?? (async () => {
+			try {
+				for (const lifecycle of lifecycles) await lifecycle.onAdopted();
+				terminal = "adopted";
+				const results = await Promise.allSettled(replayClaims.map(async (claim) => claim.commit()));
+				for (const result of results) if (result.status === "rejected") try {
+					options?.onReplayCommitError?.(result.reason);
+				} catch {}
+			} catch (error) {
+				await ensureAbandoned().catch(() => void 0);
+				throw error;
+			}
+		})();
+		adopting = activeAdoption;
+		try {
+			await activeAdoption;
+		} finally {
+			if (adopting === activeAdoption && terminal !== "adopted") adopting = void 0;
+		}
+	};
+	return {
+		lifecycle: {
+			abortSignal: lifecycles.length === 1 ? firstLifecycle.abortSignal : AbortSignal.any(lifecycles.map((lifecycle) => lifecycle.abortSignal)),
+			onAdopted: async () => {
+				handedOff = true;
+				await adoptAll();
+			},
+			onDeferred: () => {
+				handedOff = true;
+				for (const lifecycle of lifecycles) lifecycle.onDeferred();
+			},
+			onAdoptionFinalizing: () => {
+				for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
+			},
+			onAbandoned: async () => {
+				handedOff = true;
+				await abandonAll();
+			}
+		},
+		settle: async () => {
+			if (handedOff) return;
+			handedOff = true;
+			releaseReplayClaims();
+			try {
+				for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
+				for (const lifecycle of lifecycles) await lifecycle.onAdopted();
+				terminal = "adopted";
+			} catch (error) {
+				await ensureAbandoned().catch(() => void 0);
+				throw error;
+			}
+		}
+	};
+}
+function createFeishuDurableIngress(options) {
+	let socketTerminator;
+	const activeLifecycles = /* @__PURE__ */ new Map();
+	const deferredClaims = /* @__PURE__ */ new Map();
+	const monitor = createChannelIngressMonitor({
+		queue: options.queue ?? (() => getFeishuRuntime().state.openChannelIngressQueue({ accountId: options.accountId })),
+		inspect: (rawEnvelope, context) => {
+			const facts = inspectFeishuIngressEnvelope(rawEnvelope, options.encryptKey, context.phase === "admission");
+			return facts ? {
+				eventId: facts.eventId,
+				laneKey: facts.laneKey
+			} : null;
+		},
+		payload: {
+			version: FEISHU_INGRESS_PAYLOAD_VERSION,
+			serialize: (rawEnvelope, { receivedAt }) => ({
+				receivedAt,
+				rawEnvelope
+			}),
+			deserialize: (body) => body.rawEnvelope,
+			encode: ({ body }) => ({
+				version: FEISHU_INGRESS_PAYLOAD_VERSION,
+				...body
+			}),
+			decode: (payload) => ({
+				version: payload.version,
+				body: {
+					receivedAt: payload.receivedAt,
+					rawEnvelope: payload.rawEnvelope
+				}
+			}),
+			createClaimError: (kind, claim) => new FeishuIngressPermanentError("invalid-event", kind === "invalid-version" ? `Feishu ingress row ${claim.id} has an unsupported version.` : `Feishu ingress row ${claim.id} has invalid delivery identity.`)
+		},
+		deliver: async (rawEnvelope, lifecycle, claim) => {
+			let resolveDeferred;
+			const deferred = new Promise((resolve) => {
+				resolveDeferred = resolve;
+			});
+			let deferredSettled = false;
+			const settleDeferred = () => {
+				if (deferredSettled) return;
+				deferredSettled = true;
+				if (deferredClaims.get(claim.id) === deferred) deferredClaims.delete(claim.id);
+				resolveDeferred();
+			};
+			const abandonHandlers = /* @__PURE__ */ new Set();
+			const wrappedLifecycle = {
+				...lifecycle,
+				onAdopted: async () => {
+					try {
+						await lifecycle.onAdopted();
+					} finally {
+						settleDeferred();
+					}
+				},
+				onAbandoned: async () => {
+					try {
+						await Promise.allSettled([...abandonHandlers].map(async (handler) => await handler()));
+						await lifecycle.onAbandoned();
+					} finally {
+						settleDeferred();
+					}
+				},
+				registerAbandonHandler: (handler) => {
+					abandonHandlers.add(handler);
+					return () => abandonHandlers.delete(handler);
+				}
+			};
+			activeLifecycles.set(claim.id, wrappedLifecycle);
+			try {
+				const result = await options.dispatcher.invoke(parseRawEnvelope(rawEnvelope), { needCheck: false });
+				if (!isRecord$1(result)) return;
+				if (result.kind === "deferred") {
+					if (!deferredSettled) deferredClaims.set(claim.id, deferred);
+					return { kind: "deferred" };
+				}
+				if (result.kind === "completed") return { kind: "completed" };
+				if (result.kind === "failed-retryable") return {
+					kind: "failed-retryable",
+					error: result.error
+				};
+				return;
+			} finally {
+				if (activeLifecycles.get(claim.id) === wrappedLifecycle) activeLifecycles.delete(claim.id);
+			}
+		},
+		pollIntervalMs: options.pollIntervalMs ?? FEISHU_INGRESS_POLL_INTERVAL_MS,
+		retention: {
+			pruneIntervalMs: FEISHU_INGRESS_PRUNE_INTERVAL_MS,
+			completedTtlMs: FEISHU_INGRESS_COMPLETED_TTL_MS,
+			completedMaxEntries: FEISHU_INGRESS_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: FEISHU_INGRESS_FAILED_TTL_MS,
+			failedMaxEntries: FEISHU_INGRESS_FAILED_MAX_ENTRIES
+		},
+		drain: {
+			adoptionStallTimeoutMs: options.adoptionStallTimeoutMs ?? DEFAULT_INGRESS_ADOPTION_STALL_MS,
+			resolveNonRetryableFailure: resolveFeishuIngressNonRetryableFailure,
+			onLog: (message) => options.runtime.error?.(`feishu ingress: ${message}`)
+		},
+		createStoppedError: () => /* @__PURE__ */ new Error("Feishu ingress is stopped."),
+		onError: (error) => options.runtime.error?.(`feishu ingress drain failed: ${formatErrorMessage(error)}`)
+	});
+	const invoke = async (data, params) => {
+		let rawEnvelope;
+		try {
+			const serialized = JSON.stringify(data);
+			if (serialized === void 0) throw new TypeError("Feishu ingress envelope has no JSON representation.");
+			rawEnvelope = serialized;
+		} catch (error) {
+			throw new FeishuIngressPermanentError("invalid-event", "Feishu ingress envelope is not serializable.", { cause: error });
 		}
-		const content = buildFeishuCardActionTextFallback(event);
-		log(`feishu[${account.accountId}]: handling card action from ${event.operator.open_id}: ${content}`);
-		await dispatchSyntheticCommand({
-			cfg,
-			event,
-			command: content,
-			account,
-			botOpenId: params.botOpenId,
-			runtime,
-			channelRuntime: params.channelRuntime,
-			accountId
-		});
-		completeFeishuCardAction(event.token, account.accountId);
-	} catch (err) {
-		completeFeishuCardAction(event.token, account.accountId);
-		throw err;
-	}
+		const facts = inspectFeishuIngressEnvelope(rawEnvelope, options.encryptKey, true);
+		if (!facts) return await options.dispatcher.invoke(data, params);
+		try {
+			await monitor.admit(rawEnvelope, { facts: {
+				eventId: facts.eventId,
+				laneKey: facts.laneKey
+			} });
+		} catch (error) {
+			socketTerminator?.();
+			throw error;
+		}
+	};
+	return {
+		invoke,
+		resolveLifecycle: (data) => {
+			const eventId = isRecord$1(data) ? readString(data.event_id) : null;
+			return eventId ? activeLifecycles.get(eventId) : void 0;
+		},
+		setSocketTerminator: (terminate) => {
+			socketTerminator = terminate;
+		},
+		start: monitor.start,
+		stop: async () => {
+			await monitor.stop();
+			await Promise.allSettled(deferredClaims.values());
+			activeLifecycles.clear();
+			socketTerminator = void 0;
+		},
+		waitForIdle: monitor.waitForIdle
+	};
 }
 //#endregion
 //#region extensions/feishu/src/monitor-defaults.ts
@@ -3662,7 +4747,8 @@ function applyBotIdentityState(accountId, identity) {
 	});
 	return {
 		botOpenId,
-		botName
+		botName,
+		source: botOpenId ? identity.source : void 0
 	};
 }
 async function retryBotIdentityProbe(account, accountId, runtime, abortSignal) {
@@ -3672,12 +4758,13 @@ async function retryBotIdentityProbe(account, accountId, runtime, abortSignal) {
 	for (const [i, delayMs] of BOT_IDENTITY_RETRY_DELAYS_MS.entries()) {
 		if (abortSignal?.aborted) return;
 		if (!await waitForAbortableDelay(delayMs, abortSignal)) return;
-		const resolved = applyBotIdentityState(accountId, await fetchBotIdentityForMonitor(account, {
+		const identity = await fetchBotIdentityForMonitor(account, {
 			runtime,
-			abortSignal
-		}));
-		if (resolved.botOpenId) {
-			log(`feishu[${accountId}]: bot open_id recovered via background retry: ${resolved.botOpenId}`);
+			abortSignal,
+			allowCachedFallback: false
+		});
+		if (normalizeOptionalString(identity.botOpenId) && identity.source === "provider") {
+			log(`feishu[${accountId}]: bot open_id recovered via background retry: ${applyBotIdentityState(accountId, identity).botOpenId}`);
 			return;
 		}
 		const nextDelayResult = nextDelays.next();
@@ -3687,10 +4774,10 @@ async function retryBotIdentityProbe(account, accountId, runtime, abortSignal) {
 	error(`feishu[${accountId}]: bot identity background retry exhausted; requireMention group messages may be skipped until restart`);
 }
 function startBotIdentityRecovery(params) {
-	const { account, accountId, runtime, abortSignal } = params;
+	const { account, accountId, runtime, abortSignal, currentSource } = params;
 	const log = runtime?.log ?? console.log;
-	log(`feishu[${accountId}]: bot open_id unknown; starting background retry (delays: ${BOT_IDENTITY_RETRY_DELAYS_MS.map((delay) => `${delay / 1e3}s`).join(", ")})`);
-	log(`feishu[${accountId}]: requireMention group messages stay gated until bot identity recovery succeeds`);
+	log(`feishu[${accountId}]: bot open_id ${currentSource === "cache" ? "loaded from cache" : "unknown"}; starting background provider refresh (delays: ${BOT_IDENTITY_RETRY_DELAYS_MS.map((delay) => `${delay / 1e3}s`).join(", ")})`);
+	if (currentSource !== "cache") log(`feishu[${accountId}]: requireMention group messages stay gated until bot identity recovery succeeds`);
 	retryBotIdentityProbe(account, accountId, runtime, abortSignal);
 }
 //#endregion
@@ -3931,41 +5018,59 @@ 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: {
+			observeMessageSent: true,
+			deliver: async (payload, info) => {
+				if (info.kind !== "final") return noVisibleFeishuReplyDelivery;
+				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 noVisibleFeishuReplyDelivery;
+				}
+				const chunks = core.channel.text.chunkTextWithMode(reply.text, textChunkLimit, chunkMode);
+				const results = [];
+				const acceptedChunks = [];
+				for (const chunk of chunks) try {
+					const result = await deliverCommentThreadText(client, {
+						file_token: params.fileToken,
+						file_type: params.fileType,
+						comment_id: params.commentId,
+						content: chunk,
+						is_whole_comment: params.isWholeComment
+					});
+					results.push({ messageId: result.delivery_mode === "reply_comment" ? result.reply_id : result.comment_id });
+					acceptedChunks.push(chunk);
+				} catch (error) {
+					throw createFeishuPartialReplyDeliveryError(error, createFeishuReplyDeliveryResult({
+						results,
+						visibleReplySent: results.length > 0,
+						content: acceptedChunks.join(""),
+						kind: "text"
+					}));
+				}
+				return createFeishuReplyDeliveryResult({
+					results,
+					visibleReplySent: results.length > 0,
+					content: reply.text,
+					kind: "text"
+				});
+			},
+			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
 	};
@@ -4125,18 +5230,18 @@ async function fetchDriveComments(params) {
 }
 async function requestFeishuOpenApi(params) {
 	const formatErrorDetails = (error) => {
-		if (!isRecord$1(error)) return typeof error === "string" ? error : JSON.stringify(error);
-		const response = isRecord$1(error.response) ? error.response : void 0;
-		const responseData = isRecord$1(response?.data) ? response?.data : void 0;
+		if (!isRecord$2(error)) return typeof error === "string" ? error : JSON.stringify(error);
+		const response = isRecord$2(error.response) ? error.response : void 0;
+		const responseData = isRecord$2(response?.data) ? response?.data : void 0;
 		return safeJsonStringify({
 			message: typeof error.message === "string" ? error.message : typeof error === "string" ? error : JSON.stringify(error),
-			code: readString(error.code),
-			method: readString(isRecord$1(error.config) ? error.config.method : void 0),
-			url: readString(isRecord$1(error.config) ? error.config.url : void 0),
+			code: readString$1(error.code),
+			method: readString$1(isRecord$2(error.config) ? error.config.method : void 0),
+			url: readString$1(isRecord$2(error.config) ? error.config.url : void 0),
 			http_status: typeof response?.status === "number" ? response.status : void 0,
-			feishu_code: typeof responseData?.code === "number" ? responseData.code : readString(responseData?.code),
-			feishu_msg: readString(responseData?.msg),
-			feishu_log_id: readString(responseData?.log_id)
+			feishu_code: typeof responseData?.code === "number" ? responseData.code : readString$1(responseData?.code),
+			feishu_msg: readString$1(responseData?.msg),
+			feishu_log_id: readString$1(responseData?.log_id)
 		});
 	};
 	const result = await raceWithTimeoutAndAbort(params.client.request({
@@ -4192,7 +5297,7 @@ async function resolveCommentReplyContext(params) {
 		createTime: typeof params.reply.create_time === "number" ? params.reply.create_time : void 0,
 		isBotAuthored: typeof userId === "string" && normalizedBotOpenIds.has(userId),
 		content: await resolveParsedCommentContent({
-			elements: isRecord$1(params.reply.content) ? params.reply.content.elements : void 0,
+			elements: isRecord$2(params.reply.content) ? params.reply.content.elements : void 0,
 			botOpenIds: params.botOpenIds,
 			currentDocument: params.currentDocument,
 			client: params.client,
@@ -4364,7 +5469,7 @@ async function fetchDriveCommentContext(params) {
 			const rootWholeReply = comment.reply_list?.replies?.[0];
 			const normalizedBotOpenIds = new Set(Array.from(params.botOpenIds ?? []).map((botId) => normalizeString(botId)).filter((botId) => Boolean(botId)));
 			const content = await resolveParsedCommentContent({
-				elements: isRecord$1(rootWholeReply?.content) ? rootWholeReply.content.elements : void 0,
+				elements: isRecord$2(rootWholeReply?.content) ? rootWholeReply.content.elements : void 0,
 				botOpenIds: params.botOpenIds,
 				currentDocument,
 				client: params.client,
@@ -4471,11 +5576,14 @@ async function resolveDriveCommentEventCore(params) {
 		logger?.(`feishu[${accountId}]: unsupported drive comment notice type ${noticeType}`);
 		return null;
 	}
-	if (!botOpenId) {
+	const configuredBotOpenId = botOpenId?.trim();
+	const eventRecipientBotOpenId = event.notice_meta?.to_user_id?.open_id?.trim();
+	const effectiveBotOpenId = configuredBotOpenId || (event.is_mentioned === true ? eventRecipientBotOpenId : void 0);
+	if (!effectiveBotOpenId) {
 		logger?.(`feishu[${accountId}]: skipping drive comment notice because bot open_id is unavailable event=${eventId}`);
 		return null;
 	}
-	if (senderId === botOpenId) {
+	if (senderId === effectiveBotOpenId) {
 		logger?.(`feishu[${accountId}]: ignoring self-authored drive comment notice event=${eventId} sender=${senderId}`);
 		return null;
 	}
@@ -4488,7 +5596,7 @@ async function resolveDriveCommentEventCore(params) {
 		fileType,
 		commentId,
 		replyId,
-		botOpenIds: [botOpenId, event.notice_meta?.to_user_id?.open_id],
+		botOpenIds: [effectiveBotOpenId, event.notice_meta?.to_user_id?.open_id],
 		timeoutMs: verificationTimeoutMs,
 		logger,
 		accountId,
@@ -4510,32 +5618,32 @@ async function resolveDriveCommentEventCore(params) {
 	};
 }
 function parseFeishuDriveCommentNoticeEventPayload(value) {
-	if (!isRecord$1(value) || !isRecord$1(value.notice_meta)) return null;
+	if (!isRecord$2(value) || !isRecord$2(value.notice_meta)) return null;
 	const noticeMeta = value.notice_meta;
-	const fromUserId = isRecord$1(noticeMeta.from_user_id) ? noticeMeta.from_user_id : void 0;
-	const toUserId = isRecord$1(noticeMeta.to_user_id) ? noticeMeta.to_user_id : void 0;
+	const fromUserId = isRecord$2(noticeMeta.from_user_id) ? noticeMeta.from_user_id : void 0;
+	const toUserId = isRecord$2(noticeMeta.to_user_id) ? noticeMeta.to_user_id : void 0;
 	return {
-		comment_id: readString(value.comment_id),
-		event_id: readString(value.event_id),
+		comment_id: readString$1(value.comment_id),
+		event_id: readString$1(value.event_id),
 		is_mentioned: asBoolean(value.is_mentioned),
 		notice_meta: {
-			file_token: readString(noticeMeta.file_token),
-			file_type: readString(noticeMeta.file_type),
+			file_token: readString$1(noticeMeta.file_token),
+			file_type: readString$1(noticeMeta.file_type),
 			from_user_id: fromUserId ? {
-				open_id: readString(fromUserId.open_id),
-				user_id: readString(fromUserId.user_id),
-				union_id: readString(fromUserId.union_id)
+				open_id: readString$1(fromUserId.open_id),
+				user_id: readString$1(fromUserId.user_id),
+				union_id: readString$1(fromUserId.union_id)
 			} : void 0,
-			notice_type: readString(noticeMeta.notice_type),
+			notice_type: readString$1(noticeMeta.notice_type),
 			to_user_id: toUserId ? {
-				open_id: readString(toUserId.open_id),
-				user_id: readString(toUserId.user_id),
-				union_id: readString(toUserId.union_id)
+				open_id: readString$1(toUserId.open_id),
+				user_id: readString$1(toUserId.user_id),
+				union_id: readString$1(toUserId.union_id)
 			} : void 0
 		},
-		reply_id: readString(value.reply_id),
-		timestamp: readString(value.timestamp),
-		type: readString(value.type)
+		reply_id: readString$1(value.reply_id),
+		timestamp: readString$1(value.timestamp),
+		type: readString$1(value.type)
 	};
 }
 async function resolveDriveCommentEventTurn(params) {
@@ -4744,31 +5852,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,
@@ -4779,7 +5907,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({
@@ -4796,34 +5923,20 @@ 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,
+					...params.turnAdoptionLifecycle ? { replyOptions: bindIngressLifecycleToReplyOptions(params.turnAdoptionLifecycle) } : {}
 				})
 			}
 		});
@@ -4836,10 +5949,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();
 	}
 }
@@ -4914,52 +6023,40 @@ function createFeishuDriveCommentNoticeHandler(params) {
 		});
 		if (!fireAndForget) await promise;
 	};
-	return async (data) => {
-		await runFeishuHandler(async () => {
-			const event = parseFeishuDriveCommentNoticeEventPayload(data);
-			if (!event) {
-				error(`feishu[${accountId}]: ignoring malformed drive comment notice payload`);
+	const handleNotice = async (data, turnAdoptionLifecycle) => {
+		const event = parseFeishuDriveCommentNoticeEventPayload(data);
+		if (!event) {
+			if (turnAdoptionLifecycle) throw new FeishuIngressPermanentError("invalid-event", "Feishu durable comment event payload is malformed.");
+			error(`feishu[${accountId}]: ignoring malformed drive comment notice payload`);
+			return;
+		}
+		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"}`);
+		await enqueue(buildCommentNoticeQueueKey(event), async () => {
+			if (turnAdoptionLifecycle?.abortSignal.aborted) {
+				await turnAdoptionLifecycle.onAbandoned();
 				return;
 			}
-			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.kind === "duplicate") {
-					log(`feishu[${accountId}]: dropping duplicate comment event ${syntheticMessageId}`);
-					return;
-				}
-				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 {
-				await enqueue(buildCommentNoticeQueueKey(event), async () => {
-					await handleFeishuCommentEvent({
-						cfg,
-						accountId,
-						event,
-						botOpenId: getBotOpenId(accountId),
-						runtime,
-						abortSignal
-					});
-				});
-				await processingClaim?.commit();
-			} catch (err) {
-				if (isFeishuRetryableSyntheticEventError(err)) processingClaim?.release({ error: err });
-				else await processingClaim?.commit();
-				throw err;
-			}
+			await handleFeishuCommentEvent({
+				cfg,
+				accountId,
+				event,
+				botOpenId: getBotOpenId(accountId),
+				runtime,
+				abortSignal,
+				turnAdoptionLifecycle
+			});
 		});
 	};
+	return async (data) => {
+		const ingressLifecycle = params.resolveIngressLifecycle?.(data);
+		if (!ingressLifecycle) {
+			await runFeishuHandler(async () => await handleNotice(data));
+			return;
+		}
+		const { lifecycle, settle } = buildFeishuFlushIngressLifecycle([{ lifecycle: ingressLifecycle }]);
+		await handleNotice(data, lifecycle);
+		await settle();
+	};
 }
 //#endregion
 //#region extensions/feishu/src/monitor.message-handler.ts
@@ -5020,7 +6117,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, 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, resolveIngressLifecycle }) {
 	const inboundDebounceMs = channelRuntime.debounce.resolveInboundDebounceMs({
 		cfg,
 		channel: "feishu"
@@ -5030,25 +6127,32 @@ 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, processingClaim) => {
+	const dispatchFeishuMessage = async (event, messageDedupeKey, processingClaim, turnAdoptionLifecycle) => {
 		const sequentialKey = resolveSequentialKey({
 			accountId,
 			event,
 			botOpenId: getBotOpenId(accountId),
 			botName: getBotName(accountId)
 		});
-		const task = () => handleMessage({
-			cfg,
-			event,
-			botOpenId: getBotOpenId(accountId),
-			botName: getBotName(accountId),
-			runtime,
-			channelRuntime,
-			chatHistories,
-			accountId,
-			processingClaim,
-			messageDedupeKey
-		});
+		const task = async () => {
+			if (turnAdoptionLifecycle?.abortSignal.aborted) {
+				await turnAdoptionLifecycle.onAbandoned();
+				return;
+			}
+			await handleMessage({
+				cfg,
+				event,
+				botOpenId: getBotOpenId(accountId),
+				botName: getBotName(accountId),
+				runtime,
+				channelRuntime,
+				chatHistories,
+				accountId,
+				processingClaim,
+				messageDedupeKey,
+				turnAdoptionLifecycle
+			});
+		};
 		await enqueue(sequentialKey, task);
 	};
 	const resolveSenderDebounceId = (event) => {
@@ -5088,45 +6192,80 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			return Boolean(text) && !channelRuntime.commands.isControlCommandMessage(text, cfg);
 		},
 		onFlush: async (entries) => {
-			const last = entries.at(-1);
+			const activeEntries = entries.filter((entry) => !entry.abandoned);
+			const last = activeEntries.at(-1);
 			if (!last) return;
-			if (entries.length === 1) {
-				await dispatchFeishuMessage(last.event, resolveFeishuMessageDedupeKey(last.event), last.processingClaim);
+			const { lifecycle, settle } = buildFeishuFlushIngressLifecycle(activeEntries.map((entry) => ({
+				lifecycle: entry.turnAdoptionLifecycle,
+				replayClaim: entry.processingClaim
+			})), { onReplayCommitError: (err) => error(`feishu[${accountId}]: failed to commit logical replay guard: ${String(err)}`) });
+			if (lifecycle?.abortSignal.aborted) {
+				await lifecycle.onAbandoned();
 				return;
 			}
-			const dedupedEntries = dedupeFeishuDebounceEntriesByDedupeKey(entries);
-			const freshEntries = [];
-			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.event);
-			await recordSuppressedMessageIds(dedupedEntries, dispatchDedupeKey);
-			const combinedText = freshEntries.map((entry) => resolveDebounceText(entry.event)).filter(Boolean).join("\n");
-			const mergedMentions = resolveFeishuDebounceMentions({
-				entries: freshEntries.map((entry) => entry.event),
-				botOpenId: getBotOpenId(accountId)
-			});
-			await dispatchFeishuMessage({
-				...dispatchEntry.event,
-				message: {
-					...dispatchEntry.event.message,
-					...combinedText.trim() ? {
-						message_type: "text",
-						content: JSON.stringify({ text: combinedText })
-					} : {},
-					mentions: mergedMentions ?? dispatchEntry.event.message.mentions
+			try {
+				if (activeEntries.length === 1) {
+					await dispatchFeishuMessage(last.event, resolveFeishuMessageDedupeKey(last.event), last.processingClaim, lifecycle);
+					await settle();
+					return;
+				}
+				const dedupedEntries = dedupeFeishuDebounceEntriesByDedupeKey(activeEntries);
+				const freshEntries = [];
+				for (const entry of dedupedEntries) if (!await hasProcessedMessage(resolveFeishuMessageDedupeKey(entry.event), accountId, log)) freshEntries.push(entry);
+				const dispatchEntry = freshEntries.at(-1);
+				if (!dispatchEntry) {
+					await settle();
+					return;
 				}
-			}, dispatchDedupeKey, dispatchEntry.processingClaim);
+				const dispatchDedupeKey = resolveFeishuMessageDedupeKey(dispatchEntry.event);
+				if (!lifecycle) await recordSuppressedMessageIds(dedupedEntries, dispatchDedupeKey);
+				const combinedText = freshEntries.map((entry) => resolveDebounceText(entry.event)).filter(Boolean).join("\n");
+				const mergedMentions = resolveFeishuDebounceMentions({
+					entries: freshEntries.map((entry) => entry.event),
+					botOpenId: getBotOpenId(accountId)
+				});
+				await dispatchFeishuMessage({
+					...dispatchEntry.event,
+					message: {
+						...dispatchEntry.event.message,
+						...combinedText.trim() ? {
+							message_type: "text",
+							content: JSON.stringify({ text: combinedText })
+						} : {},
+						mentions: mergedMentions ?? dispatchEntry.event.message.mentions
+					}
+				}, dispatchDedupeKey, dispatchEntry.processingClaim, lifecycle);
+				await settle();
+			} catch (err) {
+				await lifecycle?.onAbandoned();
+				throw err;
+			}
 		},
 		onError: (err, entries) => {
-			for (const entry of entries) entry.processingClaim?.release({ error: err });
+			for (const entry of entries) {
+				entry.processingClaim?.release({ error: err });
+				try {
+					Promise.resolve(entry.turnAdoptionLifecycle?.onAbandoned()).catch((abandonError) => {
+						error(`feishu[${accountId}]: failed to abandon durable ingress after debounce error: ${String(abandonError)}`);
+					});
+				} catch (abandonError) {
+					error(`feishu[${accountId}]: failed to abandon durable ingress after debounce error: ${String(abandonError)}`);
+				}
+			}
 			error(`feishu[${accountId}]: inbound debounce flush failed: ${String(err)}`);
 		}
 	});
 	return async (data) => {
+		const turnAdoptionLifecycle = resolveIngressLifecycle?.(data);
+		const completeSuppressedIngress = async () => {
+			if (!turnAdoptionLifecycle) return;
+			turnAdoptionLifecycle.onAdoptionFinalizing();
+			await turnAdoptionLifecycle.onAdopted();
+		};
 		statusSink?.({ lastEventAt: Date.now() });
 		const event = parseFeishuMessageEventPayload(data);
 		if (!event) {
+			if (turnAdoptionLifecycle) throw new FeishuIngressPermanentError("invalid-event", "Feishu durable message event payload is malformed.");
 			error(`feishu[${accountId}]: ignoring malformed message event payload`);
 			return;
 		}
@@ -5135,6 +6274,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 		const senderOpenId = event.sender.sender_id.open_id?.trim();
 		if (botOpenId && senderOpenId === botOpenId) {
 			log(`feishu[${accountId}]: dropping self-authored message ${messageId ?? "unknown"}`);
+			await completeSuppressedIngress();
 			return;
 		}
 		const claim = await claimUnprocessedFeishuMessage({
@@ -5144,14 +6284,31 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 		});
 		if (claim.kind === "duplicate" || claim.kind === "inflight") {
 			log(`feishu[${accountId}]: dropping ${claim.kind} event for message ${messageId}`);
+			await completeSuppressedIngress();
 			return;
 		}
+		const debounceEntry = {
+			event,
+			...claim.kind === "claimed" ? { processingClaim: claim.handle } : {},
+			...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {}
+		};
+		if (claim.kind === "claimed" && turnAdoptionLifecycle) turnAdoptionLifecycle.registerAbandonHandler?.(() => {
+			debounceEntry.abandoned = true;
+			claim.handle.release({ error: /* @__PURE__ */ new Error("feishu-ingress-abandoned-before-flush") });
+		});
 		const processMessage = async () => {
-			await inboundDebouncer.enqueue({
-				event,
-				...claim.kind === "claimed" ? { processingClaim: claim.handle } : {}
-			});
+			await inboundDebouncer.enqueue(debounceEntry);
 		};
+		if (turnAdoptionLifecycle) try {
+			await processMessage();
+			return { kind: "deferred" };
+		} catch (err) {
+			if (claim.kind === "claimed") claim.handle.release({ error: err });
+			return {
+				kind: "failed-retryable",
+				error: err
+			};
+		}
 		if (fireAndForget) {
 			processMessage().catch((err) => {
 				if (claim.kind === "claimed") claim.handle.release({ error: err });
@@ -5261,7 +6418,7 @@ function waitForFeishuWsCycleEnd(params) {
 		params.terminalError.then(finish);
 	});
 }
-async function monitorWebSocket({ account, accountId, runtime, abortSignal, eventDispatcher, statusSink }) {
+async function monitorWebSocket({ account, accountId, runtime, abortSignal, eventDispatcher, setSocketTerminator, statusSink }) {
 	const log = runtime?.log ?? console.log;
 	const error = runtime?.error ?? console.error;
 	let attempt = 0;
@@ -5302,6 +6459,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 				onReconnected: publishWsConnected,
 				onReconnecting: publishWsReconnecting
 			});
+			setSocketTerminator?.(() => wsClient?.close({ force: true }));
 			if (abortSignal?.aborted) {
 				cleanupFeishuWsClient({
 					accountId,
@@ -5327,6 +6485,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 					error,
 					clearIdentity: true
 				});
+				setSocketTerminator?.(void 0);
 				return;
 			}
 			cleanupFeishuWsClient({
@@ -5335,6 +6494,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 				error,
 				clearIdentity: false
 			});
+			setSocketTerminator?.(void 0);
 			if (abortSignal?.aborted) break;
 			statusSink?.({
 				connected: false,
@@ -5351,6 +6511,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 				error,
 				clearIdentity: false
 			});
+			setSocketTerminator?.(void 0);
 			if (abortSignal?.aborted) break;
 			statusSink?.({
 				connected: false,
@@ -5368,6 +6529,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 		error,
 		clearIdentity: true
 	});
+	setSocketTerminator?.(void 0);
 }
 async function monitorWebhook({ account, accountId, runtime, abortSignal, eventDispatcher, statusSink }) {
 	const log = runtime?.log ?? console.log;
@@ -5489,6 +6651,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;
@@ -5561,41 +6837,41 @@ function normalizeFeishuChatType(value) {
 	return value === "group" || value === "topic_group" || value === "private" || value === "p2p" ? value : void 0;
 }
 function parseFeishuBotAddedEventPayload(value) {
-	if (!isRecord$1(value) || !readString(value.chat_id) || !isRecord$1(value.operator_id)) return null;
+	if (!isRecord$2(value) || !readString$1(value.chat_id) || !isRecord$2(value.operator_id)) return null;
 	return value;
 }
 function parseFeishuBotRemovedChatId(value) {
-	if (!isRecord$1(value)) return null;
-	return readString(value.chat_id) ?? null;
+	if (!isRecord$2(value)) return null;
+	return readString$1(value.chat_id) ?? null;
 }
 function firstString(...values) {
 	for (const value of values) {
-		const trimmed = readString(value)?.trim();
+		const trimmed = readString$1(value)?.trim();
 		if (trimmed) return trimmed;
 	}
 }
 function readFeishuIdentityField(value, field) {
-	if (!isRecord$1(value)) return;
+	if (!isRecord$2(value)) return;
 	return firstString(value[field]);
 }
 function parseFeishuCardActionEventPayload(value) {
-	if (!isRecord$1(value)) return null;
-	const operator = isRecord$1(value.operator) ? value.operator : {};
+	if (!isRecord$2(value)) return null;
+	const operator = isRecord$2(value.operator) ? value.operator : {};
 	const action = value.action;
-	const context = isRecord$1(value.context) ? value.context : {};
-	if (!isRecord$1(action)) return null;
+	const context = isRecord$2(value.context) ? value.context : {};
+	if (!isRecord$2(action)) return null;
 	const operatorUserId = operator.user_id;
-	const token = readString(value.token);
+	const token = readString$1(value.token);
 	const openId = firstString(operator.open_id, readFeishuIdentityField(operatorUserId, "open_id"), value.open_id, context.open_id);
 	const userId = firstString(operator.user_id, readFeishuIdentityField(operatorUserId, "user_id"), value.user_id, context.user_id);
 	const unionId = firstString(operator.union_id, readFeishuIdentityField(operatorUserId, "union_id"));
-	const tag = readString(action.tag);
+	const tag = readString$1(action.tag);
 	const actionValue = action.value;
 	const openMessageId = firstString(context.open_message_id, value.open_message_id);
 	const contextOpenId = firstString(context.open_id, openId);
 	const contextUserId = firstString(context.user_id, userId);
 	const chatId = firstString(context.chat_id, context.open_chat_id);
-	if (!token || !openId || !tag || !isRecord$1(actionValue)) return null;
+	if (!token || !openId || !tag || !isRecord$2(actionValue)) return null;
 	return {
 		operator: {
 			open_id: openId,
@@ -5647,6 +6923,7 @@ function registerEventHandlers(eventDispatcher, context) {
 			getBotOpenId: (id) => botOpenIds.get(id),
 			getBotName: (id) => botNames.get(id),
 			resolveSequentialKey: getFeishuSequentialKey,
+			resolveIngressLifecycle: context.resolveIngressLifecycle,
 			...context.statusSink ? { statusSink: context.statusSink } : {}
 		}),
 		"im.message.message_read_v1": async () => {},
@@ -5674,7 +6951,16 @@ function registerEventHandlers(eventDispatcher, context) {
 			accountId,
 			runtime,
 			fireAndForget,
-			abortSignal
+			abortSignal,
+			resolveIngressLifecycle: context.resolveIngressLifecycle
+		}),
+		"vc.bot.meeting_invited_v1": createFeishuVcMeetingInvitedHandler({
+			cfg,
+			accountId,
+			runtime,
+			fireAndForget,
+			channelRuntime,
+			autoJoin: context.vcAutoJoin
 		}),
 		"im.message.reaction.created_v1": async (data) => {
 			await runFeishuHandler({
@@ -5769,19 +7055,22 @@ async function monitorSingleAccount(params) {
 	const { accountId } = account;
 	const log = runtime?.log ?? console.log;
 	const botOpenIdSource = params.botOpenIdSource ?? { kind: "fetch" };
-	const { botOpenId } = applyBotIdentityState(accountId, botOpenIdSource.kind === "prefetched" ? {
+	const botIdentity = botOpenIdSource.kind === "prefetched" ? {
 		botOpenId: botOpenIdSource.botOpenId,
-		botName: botOpenIdSource.botName
+		botName: botOpenIdSource.botName,
+		source: botOpenIdSource.source
 	} : await fetchBotIdentityForMonitor(account, {
 		runtime,
 		abortSignal
-	}));
+	});
+	const { botOpenId } = applyBotIdentityState(accountId, botIdentity);
 	log(`feishu[${accountId}]: bot open_id resolved: ${botOpenId ?? "unknown"}`);
-	if (!botOpenId && !abortSignal?.aborted) startBotIdentityRecovery({
+	if ((!botOpenId || botIdentity.source === "cache") && !abortSignal?.aborted) startBotIdentityRecovery({
 		account,
 		accountId,
 		runtime,
-		abortSignal
+		abortSignal,
+		currentSource: botIdentity.source
 	});
 	const connectionMode = account.config.connectionMode ?? "websocket";
 	if (connectionMode === "webhook" && !account.verificationToken?.trim()) throw new Error(`Feishu account "${accountId}" webhook mode requires verificationToken`);
@@ -5791,6 +7080,13 @@ async function monitorSingleAccount(params) {
 	let threadBindingManager;
 	try {
 		const eventDispatcher = createEventDispatcher(account);
+		const durableIngress = typeof eventDispatcher.invoke === "function" ? createFeishuDurableIngress({
+			accountId,
+			dispatcher: eventDispatcher,
+			...account.encryptKey ? { encryptKey: account.encryptKey } : {},
+			runtime: runtime ?? {}
+		}) : void 0;
+		const durableEventDispatcher = durableIngress ? Object.assign(Object.create(eventDispatcher), { invoke: durableIngress.invoke }) : eventDispatcher;
 		const chatHistories = /* @__PURE__ */ new Map();
 		threadBindingManager = createFeishuThreadBindingManager({
 			accountId,
@@ -5803,25 +7099,33 @@ async function monitorSingleAccount(params) {
 			runtime,
 			chatHistories,
 			fireAndForget: params.fireAndForget ?? true,
+			vcAutoJoin: account.config.vcAutoJoin === true,
 			abortSignal,
+			...durableIngress ? { resolveIngressLifecycle: durableIngress.resolveLifecycle } : {},
 			...params.statusSink ? { statusSink: params.statusSink } : {}
 		});
-		if (connectionMode === "webhook") return await monitorWebhook({
-			account,
-			accountId,
-			runtime,
-			abortSignal,
-			eventDispatcher,
-			...params.statusSink ? { statusSink: params.statusSink } : {}
-		});
-		return await monitorWebSocket({
-			account,
-			accountId,
-			runtime,
-			abortSignal,
-			eventDispatcher,
-			...params.statusSink ? { statusSink: params.statusSink } : {}
-		});
+		durableIngress?.start();
+		try {
+			if (connectionMode === "webhook") return await monitorWebhook({
+				account,
+				accountId,
+				runtime,
+				abortSignal,
+				eventDispatcher: durableEventDispatcher,
+				...params.statusSink ? { statusSink: params.statusSink } : {}
+			});
+			return await monitorWebSocket({
+				account,
+				accountId,
+				runtime,
+				abortSignal,
+				eventDispatcher: durableEventDispatcher,
+				...durableIngress ? { setSocketTerminator: durableIngress.setSocketTerminator } : {},
+				...params.statusSink ? { statusSink: params.statusSink } : {}
+			});
+		} finally {
+			await durableIngress?.stop();
+		}
 	} finally {
 		threadBindingManager?.stop();
 	}