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

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

@@ -1,44 +1,46 @@
-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-CKhCa76b.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-DfE5Fhz6.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-Bcofg0Vv.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-BHv8WW9i.js";
-import { t as createFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
+import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-DG6pKTPE.js";
+import { t as createFeishuThreadBindingManager } from "./thread-bindings-Dqs_A0du.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 buildFeishuMediaFallbackText, c as parsePostContent, d as isMentionForwardRequest, f as isFeishuGroupChatType, g as normalizeFeishuExternalKey, h as shouldSuppressFeishuTextForVoiceMedia, i as sendCardFeishu, l as extractMentionTargets, m as sendMediaFeishu, n as getMessageFeishu, o as sendMessageFeishu, p as saveMessageResourceFeishu, r as listFeishuThreadMessages, s as sendStructuredCardFeishu, u as isFeishuBroadcastMention, v as resolveFeishuIdentityEmoji } from "./send-DcrXbqqA.js";
-import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-BgboTHIn.js";
-import { t as fetchBotIdentityForMonitor } from "./monitor.startup-Cy8NPGAX.js";
-import { createChannelMessageReplyPipeline, formatChannelProgressDraftLineForEntry, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelPreviewStreamMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { _ 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-DOwcLJ1j.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";
 import { asBoolean, asNullableRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readStringValue, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
 import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { normalizeAccountId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import * as Lark from "@larksuiteoapi/node-sdk";
+import { formatReasoningMessage, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 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 { 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, formatAgentEnvelope, formatInboundMediaUnavailableText, recordChannelBotPairLoopAndCheckSuppression, resolveEnvelopeFormatOptions, 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, 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";
@@ -74,6 +76,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;
@@ -139,11 +302,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;
@@ -156,7 +322,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([
@@ -169,32 +335,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 {
@@ -295,15 +437,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) {
@@ -316,18 +458,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 {
@@ -345,11 +480,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 {
@@ -369,29 +504,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,
@@ -408,17 +534,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
@@ -742,9 +865,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.
@@ -759,11 +880,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));
@@ -1021,6 +1137,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
@@ -1032,6 +1189,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;
@@ -1106,23 +1271,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}`;
@@ -1412,16 +1571,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;
@@ -1431,44 +1597,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;
@@ -1614,6 +1799,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;
@@ -1724,9 +1912,12 @@ function createFeishuReplyDispatcher(params) {
 	});
 	const renderMode = account.config?.renderMode ?? "auto";
 	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 = "";
@@ -1736,15 +1927,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;
 	};
@@ -1761,9 +1957,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) => {
@@ -1796,12 +1995,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,
@@ -1812,14 +2014,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 = "";
@@ -1829,24 +2035,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 {
@@ -1874,82 +2182,98 @@ function createFeishuReplyDispatcher(params) {
 			chunkMentions: paramsLocal.chunkMentions,
 			initialChunks
 		}));
+		const results = [];
+		const acceptedChunks = [];
 		for (const [index, chunk] of chunks.entries()) {
 			const mentions = [...paramsLocal.chunkMentions ?? [], ...index === 0 ? paramsLocal.firstChunkMentions ?? [] : []];
-			await paramsLocal.sendChunk({
-				chunk,
-				isFirst: index === 0,
-				mentions: mentions.length > 0 ? mentions : void 0
-			});
-			markVisibleReplySent();
+			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",
-						chunkMentions: requiredMentionTargets,
-						sendChunk: async ({ chunk, mentions }) => {
-							await sendMessageFeishu({
-								cfg,
-								to: sendTarget,
-								text: chunk,
-								replyToMessageId: sendReplyToMessageId,
-								replyInThread: effectiveReplyInThread,
-								allowTopLevelReplyFallback,
-								accountId,
-								...mentions ? { mentions } : {}
-							});
-						}
+		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 = await buildFeishuMediaFallbackText({
-					text: sentFallbackText ? void 0 : options.fallbackText,
-					mediaUrl
-				});
+			});
+			if (degradedVoiceFallbackText && !sentFallbackText) {
 				sentFallbackText = true;
-				await sendChunkedTextReply({
-					text: fallbackText,
-					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 } : {}
-						});
-					}
-				});
+				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;
@@ -1972,13 +2296,130 @@ function createFeishuReplyDispatcher(params) {
 		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 dispatcherOptions = {
 		responsePrefix: prefixContext.responsePrefix,
@@ -1997,13 +2438,13 @@ 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?.());
 		},
 		onIdle: () => queueIdleSideEffects(),
@@ -2012,14 +2453,13 @@ function createFeishuReplyDispatcher(params) {
 		}
 	};
 	const handleDeliveryError = async (error, info) => {
-		streamingCloseErroredForReply = true;
-		streamingClosedForReply = false;
 		params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
-		await queueIdleSideEffects({ markClosedForReply: false }).catch((cleanupError) => params.runtime.error?.(`feishu[${account.accountId}] reply error cleanup failed: ${String(cleanupError)}`));
+		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;
@@ -2040,42 +2480,52 @@ function createFeishuReplyDispatcher(params) {
 				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 shouldDeliverText = hasText && !hasVoiceMedia && !skipTextForDuplicateFinal;
 				const shouldDiscardStreamingPreview = info?.kind === "final" && (finalTextExceedsStreamingLimit || hasMedia && (hasVoiceMedia && !shouldDeliverText && !ttsTextAlreadyVisible || skipTextForDuplicateFinal));
-				if (!shouldDeliverText && !hasMedia) return;
+				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;
-								await sendChunkedTextReply({
+								deliveredResults.push(await sendChunkedTextReply({
 									text,
 									useCard: false,
 									infoKind: "block",
 									firstChunkMentions,
 									chunkMentions: requiredMentionTargets,
-									sendChunk: async ({ chunk, mentions }) => {
-										await sendMessageFeishu({
-											cfg,
-											to: sendTarget,
-											text: chunk,
-											replyToMessageId: sendReplyToMessageId,
-											replyInThread: effectiveReplyInThread,
-											allowTopLevelReplyFallback,
-											accountId,
-											...mentions ? { mentions } : {}
-										});
-									}
-								});
+									sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
+										cfg,
+										to: sendTarget,
+										text: chunk,
+										replyToMessageId: sendReplyToMessageId,
+										replyInThread: effectiveReplyInThread,
+										allowTopLevelReplyFallback,
+										accountId,
+										...mentions ? { mentions } : {}
+									})
+								}));
 								sentIndependentBlockText = true;
-								if (hasMedia) await sendMediaReplies(payload);
+								if (hasMedia) await collectMediaDelivery(payload);
 							}
-							return;
+							return mergeFeishuReplyDeliveryResults(deliveredResults, text);
 						}
 						startStreaming();
 						if (streamingStartPromise) await streamingStartPromise;
@@ -2085,75 +2535,87 @@ function createFeishuReplyDispatcher(params) {
 						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));
+					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) await sendMediaReplies(payload);
-						return;
+						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);
-						await sendChunkedTextReply({
+						deliveredResults.push(await sendChunkedTextReply({
 							text,
 							useCard: true,
 							infoKind: info?.kind,
 							chunkMentions: requiredMentionTargets,
-							sendChunk: async ({ chunk, mentions }) => {
-								await sendStructuredCardFeishu({
-									cfg,
-									to: sendTarget,
-									text: chunk,
-									replyToMessageId: sendReplyToMessageId,
-									replyInThread: effectiveReplyInThread,
-									allowTopLevelReplyFallback,
-									accountId,
-									header: cardHeader,
-									note: cardNote,
-									...mentions ? { mentions } : {}
-								});
-							}
-						});
+							sendChunk: async ({ chunk, mentions }) => await sendStructuredCardFeishu({
+								cfg,
+								to: sendTarget,
+								text: chunk,
+								replyToMessageId: sendReplyToMessageId,
+								replyInThread: effectiveReplyInThread,
+								allowTopLevelReplyFallback,
+								accountId,
+								header: cardHeader,
+								note: cardNote,
+								...mentions ? { mentions } : {}
+							})
+						}));
 					} else {
 						const firstChunkMentions = info?.kind === "final" && mentionTargets?.length ? mentionTargets : void 0;
-						await sendChunkedTextReply({
+						deliveredResults.push(await sendChunkedTextReply({
 							text,
 							useCard: false,
 							infoKind: info?.kind,
 							firstChunkMentions,
 							chunkMentions: requiredMentionTargets,
-							sendChunk: async ({ chunk, mentions }) => {
-								await sendMessageFeishu({
-									cfg,
-									to: sendTarget,
-									text: chunk,
-									replyToMessageId: sendReplyToMessageId,
-									replyInThread: effectiveReplyInThread,
-									allowTopLevelReplyFallback,
-									accountId,
-									...mentions ? { mentions } : {}
-								});
-							}
-						});
+							sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
+								cfg,
+								to: sendTarget,
+								text: chunk,
+								replyToMessageId: sendReplyToMessageId,
+								replyInThread: effectiveReplyInThread,
+								allowTopLevelReplyFallback,
+								accountId,
+								...mentions ? { mentions } : {}
+							})
+						}));
 					}
 				}
-				if (hasMedia) await sendMediaReplies(payload, hasVoiceMedia && hasText ? { fallbackText: text } : void 0);
+				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
 		},
 		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",
@@ -2172,7 +2634,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",
@@ -2182,13 +2644,13 @@ 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
 		},
@@ -2225,15 +2687,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
@@ -2244,8 +2705,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);
@@ -2313,7 +2773,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
@@ -2323,7 +2783,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,
@@ -2787,7 +3247,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,
@@ -2796,12 +3256,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;
@@ -2836,10 +3294,11 @@ 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,
@@ -3074,6 +3533,7 @@ async function handleFeishuMessage(params) {
 					rawBody: commandFacingContent,
 					commandBody: commandFacingContent
 				},
+				sessionTranscript: { historyLimit: isGroup ? historyLimit : 0 },
 				access: {
 					mentions: {
 						canDetectMention: isGroup,
@@ -3123,144 +3583,202 @@ 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 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;
+			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 createBroadcastInboundAdapter = (paramsLocal) => ({
+				ingest: () => ({
+					id: ctx.messageId,
+					timestamp: messageCreateTimeMs,
+					rawText: ctx.content,
+					textForAgent: paramsLocal.ctxPayload.BodyForAgent,
+					textForCommands: paramsLocal.ctxPayload.CommandBody,
+					raw: ctx
+				}),
+				resolveTurn: () => ({
+					cfg,
+					channel: "feishu",
+					accountId: route.accountId,
+					route: {
+						agentId: paramsLocal.agentId,
+						sessionKey: paramsLocal.sessionKey
+					},
+					ctxPayload: paramsLocal.ctxPayload,
+					record: paramsLocal.record,
+					...paramsLocal.variant.kind === "observeOnly" ? {
+						admission: {
+							kind: "observeOnly",
+							reason: "broadcast-observer"
+						},
+						delivery: { deliver: async () => ({ visibleReplySent: false }) },
+						replyOptions: bindIngressLifecycleToReplyOptions(paramsLocal.lifecycle)
+					} : {
+						dispatcherOptions: paramsLocal.variant.dispatcher.dispatcherOptions,
+						delivery: paramsLocal.variant.dispatcher.delivery,
+						replyOptions: {
+							...paramsLocal.variant.dispatcher.replyOptions,
+							...bindIngressLifecycleToReplyOptions(paramsLocal.lifecycle)
+						}
+					}
+				})
+			});
 			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 = 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 { dispatcherOptions, delivery, replyOptions, 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,
-						requiredMentionTargets,
-						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: () => ({
+					const agentCtx = await buildCtxPayloadForAgent(agentId, agentSessionKey, route.accountId, ctx.mentionedBot && agentId === activeAgentId);
+					let variant;
+					if (agentId === activeAgentId) {
+						const identity = resolveAgentOutboundIdentity(cfg, agentId);
+						variant = {
+							kind: "active",
+							dispatcher: createFeishuReplyDispatcher({
 								cfg,
-								channel: "feishu",
-								accountId: route.accountId,
-								route: {
-									agentId,
-									sessionKey: agentSessionKey
-								},
-								ctxPayload: agentCtx,
-								record: agentRecord,
-								dispatcherOptions,
-								delivery,
-								replyOptions
+								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
 							})
-						}
-					});
-					if (turnResult.dispatched && shouldSendNoVisibleReplyFallback(turnResult.dispatchResult)) await ensureNoVisibleReplyFallback("broadcast-dispatch-complete-no-visible-reply");
-				} else {
-					delete agentCtx.CommandAuthorized;
-					log(`feishu[${account.accountId}]: broadcast observer dispatch agent=${agentId} (session=${agentSessionKey})`);
-					await core.channel.inbound.run({
+						};
+						log(`feishu[${account.accountId}]: broadcast active dispatch agent=${agentId} (session=${agentSessionKey})`);
+					} else {
+						delete agentCtx.CommandAuthorized;
+						variant = { kind: "observeOnly" };
+						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 }) }
-							})
-						}
+						adapter: createBroadcastInboundAdapter({
+							agentId,
+							sessionKey: agentSessionKey,
+							ctxPayload: agentCtx,
+							record: agentRecord,
+							lifecycle: lane.lifecycle,
+							variant
+						})
 					});
+					if (variant.kind === "active" && turnResult.dispatched && shouldSendNoVisibleReplyFallback(turnResult.dispatchResult)) await variant.dispatcher.ensureNoVisibleReplyFallback("broadcast-dispatch-complete-no-visible-reply");
+					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);
@@ -3332,7 +3850,10 @@ async function handleFeishuMessage(params) {
 						},
 						dispatcherOptions,
 						delivery,
-						replyOptions
+						replyOptions: {
+							...replyOptions,
+							...turnAdoptionLifecycle ? bindIngressLifecycleToReplyOptions(turnAdoptionLifecycle) : {}
+						}
 					})
 				}
 			});
@@ -3344,6 +3865,7 @@ async function handleFeishuMessage(params) {
 		}
 	} catch (err) {
 		error(`feishu[${account.accountId}]: failed to dispatch message: ${String(err)}`);
+		if (turnAdoptionLifecycle) throw err;
 	}
 }
 //#endregion
@@ -3721,6 +4243,350 @@ async function handleFeishuCardAction(params) {
 	}
 }
 //#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 transportLifecycle = fanInChannelIngressLifecycles(lifecycles).lifecycle;
+	if (!transportLifecycle) 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 transportLifecycle.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 {
+				await transportLifecycle.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: transportLifecycle.abortSignal,
+			onAdopted: async () => {
+				handedOff = true;
+				await adoptAll();
+			},
+			onDeferred: () => {
+				handedOff = true;
+				transportLifecycle.onDeferred();
+			},
+			onAdoptionFinalizing: () => {
+				transportLifecycle.onAdoptionFinalizing();
+			},
+			onAbandoned: async () => {
+				handedOff = true;
+				await abandonAll();
+			}
+		},
+		settle: async () => {
+			if (handedOff) return;
+			handedOff = true;
+			releaseReplayClaims();
+			try {
+				transportLifecycle.onAdoptionFinalizing();
+				await transportLifecycle.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 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
 const FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS = {
 	windowMs: 6e4,
@@ -3871,7 +4737,8 @@ function applyBotIdentityState(accountId, identity) {
 	});
 	return {
 		botOpenId,
-		botName
+		botName,
+		source: botOpenId ? identity.source : void 0
 	};
 }
 async function retryBotIdentityProbe(account, accountId, runtime, abortSignal) {
@@ -3881,12 +4748,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();
@@ -3896,10 +4764,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
@@ -4153,20 +5021,40 @@ function createFeishuCommentReplyDispatcher(params) {
 			}
 		},
 		delivery: {
+			observeMessageSent: true,
 			deliver: async (payload, info) => {
-				if (info.kind !== "final") return;
+				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;
+					return noVisibleFeishuReplyDelivery;
 				}
 				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
+				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) => {
@@ -4332,18 +5220,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({
@@ -4399,7 +5287,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,
@@ -4571,7 +5459,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,
@@ -4678,16 +5566,19 @@ 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;
 	}
 	const context = await fetchDriveCommentContext({
-		client: createClient ? createClient(account ?? { accountId }) : createFeishuClient((await import("./accounts-BDoGHJDk.js").then((n) => n.t)).resolveFeishuAccount({
+		client: createClient ? createClient(account ?? { accountId }) : createFeishuClient((await import("./accounts-CKhCa76b.js").then((n) => n.t)).resolveFeishuAccount({
 			cfg,
 			accountId
 		})),
@@ -4695,7 +5586,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,
@@ -4717,32 +5608,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) {
@@ -5034,7 +5925,8 @@ async function handleFeishuCommentEvent(params) {
 						error(`feishu[${account.accountId}]: failed to record comment inbound session ${commentSessionKey}: ${String(err)}`);
 					} },
 					dispatcherOptions,
-					delivery
+					delivery,
+					...params.turnAdoptionLifecycle ? { replyOptions: bindIngressLifecycleToReplyOptions(params.turnAdoptionLifecycle) } : {}
 				})
 			}
 		});
@@ -5121,52 +6013,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
@@ -5227,7 +6107,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"
@@ -5237,25 +6117,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) => {
@@ -5295,45 +6182,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;
 		}
@@ -5342,6 +6264,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({
@@ -5351,14 +6274,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 });
@@ -5468,7 +6408,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;
@@ -5509,6 +6449,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 				onReconnected: publishWsConnected,
 				onReconnecting: publishWsReconnecting
 			});
+			setSocketTerminator?.(() => wsClient?.close({ force: true }));
 			if (abortSignal?.aborted) {
 				cleanupFeishuWsClient({
 					accountId,
@@ -5534,6 +6475,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 					error,
 					clearIdentity: true
 				});
+				setSocketTerminator?.(void 0);
 				return;
 			}
 			cleanupFeishuWsClient({
@@ -5542,6 +6484,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 				error,
 				clearIdentity: false
 			});
+			setSocketTerminator?.(void 0);
 			if (abortSignal?.aborted) break;
 			statusSink?.({
 				connected: false,
@@ -5558,6 +6501,7 @@ async function monitorWebSocket({ account, accountId, runtime, abortSignal, even
 				error,
 				clearIdentity: false
 			});
+			setSocketTerminator?.(void 0);
 			if (abortSignal?.aborted) break;
 			statusSink?.({
 				connected: false,
@@ -5575,6 +6519,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;
@@ -5829,7 +6774,7 @@ async function resolveReactionSyntheticEvent(params) {
 	const senderId = event.user_id?.open_id;
 	const senderUserId = event.user_id?.user_id;
 	if (!emoji || !messageId || !senderId) return null;
-	const { resolveFeishuAccount } = await import("./accounts-BDoGHJDk.js").then((n) => n.t);
+	const { resolveFeishuAccount } = await import("./accounts-CKhCa76b.js").then((n) => n.t);
 	const reactionNotifications = resolveFeishuAccount({
 		cfg,
 		accountId
@@ -5882,41 +6827,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,
@@ -5968,6 +6913,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 () => {},
@@ -5995,7 +6941,8 @@ function registerEventHandlers(eventDispatcher, context) {
 			accountId,
 			runtime,
 			fireAndForget,
-			abortSignal
+			abortSignal,
+			resolveIngressLifecycle: context.resolveIngressLifecycle
 		}),
 		"vc.bot.meeting_invited_v1": createFeishuVcMeetingInvitedHandler({
 			cfg,
@@ -6098,19 +7045,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`);
@@ -6120,6 +7070,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,
@@ -6134,24 +7091,31 @@ async function monitorSingleAccount(params) {
 			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();
 	}