@openclaw/msteams 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/{src-Gqmhf6Hw.cjs → src-B_BdEvcr.cjs}

@@ -1,15 +1,14 @@
-const require_delegated_state = require("./delegated-state-DOSCHaAB.cjs");
+const require_polls = require("./polls-BWKNpBSg.cjs");
 const require_runtime = require("./runtime-gZTAuFux.cjs");
 require("./runtime-api.cjs");
-const require_resolve_allowlist = require("./resolve-allowlist-CgA2KHN8.cjs");
-const require_channel = require("./channel-D_epy05a.cjs");
-const require_setup_surface = require("./setup-surface-BWSGtAxk.cjs");
-const require_polls = require("./polls-CWExq2xZ.cjs");
-const require_sso_token_store = require("./sso-token-store-OSg229re.cjs");
-const require_messenger = require("./messenger-BcpkE82v.cjs");
-let openclaw_plugin_sdk_allow_from = require("openclaw/plugin-sdk/allow-from");
+const require_resolve_allowlist = require("./resolve-allowlist-CEj9sABO.cjs");
+const require_channel = require("./channel-C7QxRjBW.cjs");
+const require_setup_surface = require("./setup-surface-ByWjaXEn.cjs");
+const require_sso_token_store = require("./sso-token-store-TKYk_Ms7.cjs");
+const require_messenger = require("./messenger-DTiaLTDO.cjs");
 let openclaw_plugin_sdk_channel_outbound = require("openclaw/plugin-sdk/channel-outbound");
 let openclaw_plugin_sdk_string_coerce_runtime = require("openclaw/plugin-sdk/string-coerce-runtime");
+let openclaw_plugin_sdk_allow_from = require("openclaw/plugin-sdk/allow-from");
 let openclaw_plugin_sdk_media_runtime = require("openclaw/plugin-sdk/media-runtime");
 let openclaw_plugin_sdk_ssrf_runtime = require("openclaw/plugin-sdk/ssrf-runtime");
 let openclaw_plugin_sdk_provider_http = require("openclaw/plugin-sdk/provider-http");
@@ -17,12 +16,15 @@ let openclaw_plugin_sdk_number_runtime = require("openclaw/plugin-sdk/number-run
 let openclaw_plugin_sdk_text_utility_runtime = require("openclaw/plugin-sdk/text-utility-runtime");
 let openclaw_plugin_sdk_routing = require("openclaw/plugin-sdk/routing");
 let node_crypto = require("node:crypto");
-node_crypto = require_delegated_state.__toESM(node_crypto, 1);
+node_crypto = require_polls.__toESM(node_crypto, 1);
+let openclaw_plugin_sdk_error_runtime = require("openclaw/plugin-sdk/error-runtime");
 let openclaw_plugin_sdk_channel_inbound = require("openclaw/plugin-sdk/channel-inbound");
 let openclaw_plugin_sdk_channel_ingress_runtime = require("openclaw/plugin-sdk/channel-ingress-runtime");
 let openclaw_plugin_sdk_context_visibility_runtime = require("openclaw/plugin-sdk/context-visibility-runtime");
 let openclaw_plugin_sdk_reply_history = require("openclaw/plugin-sdk/reply-history");
 let openclaw_plugin_sdk_agent_runtime = require("openclaw/plugin-sdk/agent-runtime");
+let openclaw_plugin_sdk_extension_shared = require("openclaw/plugin-sdk/extension-shared");
+let openclaw_plugin_sdk_plugin_runtime = require("openclaw/plugin-sdk/plugin-runtime");
 let openclaw_plugin_sdk_dedupe_runtime = require("openclaw/plugin-sdk/dedupe-runtime");
 let openclaw_plugin_sdk_collection_runtime = require("openclaw/plugin-sdk/collection-runtime");
 let openclaw_plugin_sdk_channel_pairing = require("openclaw/plugin-sdk/channel-pairing");
@@ -168,20 +170,50 @@ const msteamsIngressIdentity = {
 	aliases: [{
 		key: "sender-name",
 		kind: "plugin:msteams-sender-name",
-		normalizeEntry: normalizeIngressValue,
-		normalizeSubject: normalizeIngressValue,
+		normalizeEntry: normalizeSenderNameIngressValue,
+		normalizeSubject: normalizeSenderNameIngressValue,
 		dangerous: true
+	}, {
+		key: "conversation-id",
+		kind: "plugin:msteams-conversation-id",
+		normalizeEntry: normalizeAllowlistConversationId,
+		normalizeSubject: normalizeAllowlistConversationId
 	}],
 	isWildcardEntry: (entry) => normalizeIngressValue(entry) === "*",
-	resolveEntryId: ({ entryIndex, fieldKey }) => `msteams-entry-${entryIndex + 1}:${fieldKey === "sender-name" ? "name" : "id"}`
+	resolveEntryId: ({ entryIndex, fieldKey }) => `msteams-entry-${entryIndex + 1}:${fieldKey === "sender-name" ? "name" : fieldKey === "conversation-id" ? "conversation-id" : "id"}`
 };
 function normalizeIngressValue(value) {
 	return (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(value) ?? null;
 }
+function normalizeSenderNameIngressValue(value) {
+	const normalized = normalizeIngressValue(value);
+	if (!normalized) return null;
+	return require_resolve_allowlist.looksLikeMSTeamsConversationId(require_resolve_allowlist.normalizeMSTeamsConversationId(normalized)) ? null : normalized;
+}
+function normalizeAllowlistConversationId(value) {
+	const trimmed = value?.trim();
+	return trimmed ? require_resolve_allowlist.normalizeMSTeamsConversationId(trimmed) : null;
+}
+function formatMSTeamsSenderReason(params) {
+	switch (params.reasonCode) {
+		case "dm_policy_open": return "dmPolicy=open";
+		case "dm_policy_disabled": return "dmPolicy=disabled";
+		case "dm_policy_pairing_required": return "dmPolicy=pairing (not allowlisted)";
+		case "dm_policy_allowlisted": return `dmPolicy=${params.dmPolicy ?? "allowlist"} (allowlisted)`;
+		case "dm_policy_not_allowlisted": return `dmPolicy=${params.dmPolicy ?? "allowlist"} (not allowlisted)`;
+		case "group_policy_disabled": return "groupPolicy=disabled";
+		case "group_policy_empty_allowlist":
+		case "route_sender_empty": return "groupPolicy=allowlist (empty allowlist)";
+		case "group_policy_not_allowlisted": return "groupPolicy=allowlist (not allowlisted)";
+		case "group_policy_open": return "groupPolicy=open";
+		case "group_policy_allowed": return `groupPolicy=${params.groupPolicy ?? "allowlist"}`;
+		default: return params.reasonCode;
+	}
+}
 async function resolveMSTeamsSenderAccess(params) {
 	const activity = params.activity;
 	const msteamsCfg = params.cfg.channels?.msteams;
-	const conversationId = require_channel.normalizeMSTeamsConversationId(activity.conversation?.id ?? "unknown");
+	const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(activity.conversation?.id ?? "unknown");
 	const convType = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(activity.conversation?.conversationType);
 	const isDirectMessage = convType === "personal" || !convType && !activity.conversation?.isGroup;
 	const senderId = activity.from?.aadObjectId ?? activity.from?.id ?? "unknown";
@@ -214,7 +246,10 @@ async function resolveMSTeamsSenderAccess(params) {
 			readStoreAllowFrom: pairing.readAllowFromStore,
 			subject: {
 				stableId: senderId,
-				aliases: { "sender-name": senderName }
+				aliases: {
+					"sender-name": senderName,
+					...!isDirectMessage ? { "conversation-id": conversationId } : {}
+				}
 			},
 			conversation: {
 				kind: isDirectMessage ? "direct" : convType === "channel" ? "channel" : "group",
@@ -258,6 +293,136 @@ async function resolveMSTeamsSenderAccess(params) {
 		groupPolicy
 	};
 }
+async function admitMSTeamsMessage(params) {
+	const core = require_runtime.getMSTeamsRuntime();
+	const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+		cfg: params.cfg,
+		surface: "msteams"
+	});
+	const isControlCommand = allowTextCommands && core.channel.commands.isControlCommandMessage(params.text, params.cfg);
+	const access = await resolveMSTeamsSenderAccess({
+		cfg: params.cfg,
+		activity: params.activity,
+		hasControlCommand: isControlCommand
+	});
+	const { dmPolicy, senderId, senderName, pairing, isDirectMessage, channelGate, senderAccess, commandAccess, allowNameMatching, groupPolicy, msteamsCfg } = access;
+	const effectiveDmAllowFrom = senderAccess.effectiveAllowFrom;
+	const effectiveGroupAllowFrom = senderAccess.effectiveGroupAllowFrom;
+	if (isDirectMessage && msteamsCfg && senderAccess.decision !== "allow") {
+		if (senderAccess.reasonCode === "dm_policy_disabled") {
+			params.log.info("dropping dm (dms disabled)", {
+				sender: senderId,
+				label: senderName
+			});
+			params.log.debug?.("dropping dm (dms disabled)");
+			return null;
+		}
+		const allowMatch = require_channel.resolveMSTeamsAllowlistMatch({
+			allowFrom: effectiveDmAllowFrom,
+			senderId,
+			senderName,
+			allowNameMatching
+		});
+		if (senderAccess.decision === "pairing") {
+			params.conversationStore.upsert(params.conversationId, params.conversationRef).catch((err) => {
+				params.log.debug?.("failed to save conversation reference", { error: require_setup_surface.formatUnknownError(err) });
+			});
+			if (await pairing.upsertPairingRequest({
+				id: senderId,
+				meta: { name: senderName }
+			})) params.log.info("msteams pairing request created", {
+				sender: senderId,
+				label: senderName
+			});
+		}
+		params.log.debug?.("dropping dm (not allowlisted)", {
+			sender: senderId,
+			label: senderName,
+			allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
+		});
+		params.log.info("dropping dm (not allowlisted)", {
+			sender: senderId,
+			label: senderName,
+			dmPolicy,
+			reason: formatMSTeamsSenderReason({
+				reasonCode: senderAccess.reasonCode,
+				dmPolicy,
+				groupPolicy
+			}),
+			allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
+		});
+		return null;
+	}
+	if (!isDirectMessage && msteamsCfg) {
+		if (channelGate.allowlistConfigured && !channelGate.allowed) {
+			params.log.info("dropping group message (not in team/channel allowlist)", {
+				conversationId: params.conversationId,
+				teamKey: channelGate.teamKey ?? "none",
+				channelKey: channelGate.channelKey ?? "none",
+				channelMatchKey: channelGate.channelMatchKey ?? "none",
+				channelMatchSource: channelGate.channelMatchSource ?? "none"
+			});
+			params.log.debug?.("dropping group message (not in team/channel allowlist)", {
+				conversationId: params.conversationId,
+				teamKey: channelGate.teamKey ?? "none",
+				channelKey: channelGate.channelKey ?? "none",
+				channelMatchKey: channelGate.channelMatchKey ?? "none",
+				channelMatchSource: channelGate.channelMatchSource ?? "none"
+			});
+			return null;
+		}
+		if (!senderAccess.allowed && senderAccess.reasonCode === "group_policy_disabled") {
+			params.log.info("dropping group message (groupPolicy: disabled)", { conversationId: params.conversationId });
+			params.log.debug?.("dropping group message (groupPolicy: disabled)", { conversationId: params.conversationId });
+			return null;
+		}
+		if (!senderAccess.allowed && (senderAccess.reasonCode === "group_policy_empty_allowlist" || senderAccess.reasonCode === "route_sender_empty")) {
+			params.log.info("dropping group message (groupPolicy: allowlist, no allowlist)", { conversationId: params.conversationId });
+			params.log.debug?.("dropping group message (groupPolicy: allowlist, no allowlist)", { conversationId: params.conversationId });
+			return null;
+		}
+		if (!senderAccess.allowed && senderAccess.reasonCode === "group_policy_not_allowlisted") {
+			const allowMatch = require_channel.resolveMSTeamsAllowlistMatch({
+				allowFrom: effectiveGroupAllowFrom,
+				senderId,
+				senderName,
+				allowNameMatching
+			});
+			params.log.debug?.("dropping group message (not in groupAllowFrom)", {
+				sender: senderId,
+				label: senderName,
+				allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
+			});
+			params.log.info("dropping group message (not in groupAllowFrom)", {
+				sender: senderId,
+				label: senderName,
+				allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
+			});
+			return null;
+		}
+	}
+	if (commandAccess.shouldBlockControlCommand) {
+		(0, openclaw_plugin_sdk_channel_inbound.logInboundDrop)({
+			log: params.logVerboseMessage,
+			channel: "msteams",
+			reason: "control command (unauthorized)",
+			target: senderId
+		});
+		return null;
+	}
+	params.conversationStore.upsert(params.conversationId, params.conversationRef).catch((err) => {
+		params.log.debug?.("failed to save conversation reference", { error: require_setup_surface.formatUnknownError(err) });
+	});
+	return {
+		...access,
+		allowTextCommands,
+		isControlCommand,
+		commandAuthorized: commandAccess.requested ? commandAccess.authorized : void 0,
+		effectiveDmAllowFrom,
+		effectiveGroupAllowFrom,
+		isChannel: params.isChannel
+	};
+}
 //#endregion
 //#region extensions/msteams/src/attachments/bot-framework.ts
 /**
@@ -933,10 +1098,13 @@ async function fetchGraphCollection(params) {
 	});
 	try {
 		const status = response.status;
-		if (!response.ok) return {
-			status,
-			items: []
-		};
+		if (!response.ok) {
+			await response.body?.cancel().catch(() => void 0);
+			return {
+				status,
+				items: []
+			};
+		}
 		try {
 			return {
 				status,
@@ -1237,145 +1405,291 @@ async function downloadMSTeamsGraphMedia(params) {
 	};
 }
 //#endregion
-//#region extensions/msteams/src/thread-parent-context.ts
-const PARENT_CACHE_TTL_MS = 300 * 1e3;
-const PARENT_CACHE_MAX = 100;
-const parentCache = /* @__PURE__ */ new Map();
-const INJECTED_MAX = 200;
-const injectedParents = /* @__PURE__ */ new Map();
-function touchLru(map, key, value, max) {
-	if (map.has(key)) map.delete(key);
-	else if (map.size >= max) {
-		const firstKey = map.keys().next().value;
-		if (firstKey !== void 0) map.delete(firstKey);
-	}
-	map.set(key, value);
+//#region extensions/msteams/src/monitor-handler/inbound-media.ts
+function shouldAttemptMSTeamsGraphMediaFallback(params) {
+	const conversationType = params.conversationType.trim().toLowerCase();
+	return params.graphMediaFallback === true && (conversationType === "channel" || conversationType === "groupchat") && (params.htmlSummary?.htmlAttachments ?? 0) > 0;
 }
-function buildParentCacheKey(groupId, channelId, parentId) {
-	return `${groupId}\u0000${channelId}\u0000${parentId}`;
+function resolveMSTeamsInboundMediaBody(params) {
+	const unavailableCount = params.materializedMedia.filter((media) => !media.path).length + Math.max(0, params.nativeMedia.length - params.materializedMedia.length);
+	if (unavailableCount === 0) return params.body;
+	return (0, openclaw_plugin_sdk_channel_inbound.formatInboundMediaUnavailableText)({
+		body: params.body,
+		notice: `[msteams ${unavailableCount > 1 ? `${unavailableCount} attachments` : "attachment"} unavailable]`
+	});
 }
-function resolveParentCacheExpiresAt(nowRaw) {
-	const nowMs = (0, openclaw_plugin_sdk_number_runtime.asDateTimestampMs)(nowRaw);
-	return nowMs === void 0 ? void 0 : (0, openclaw_plugin_sdk_number_runtime.resolveExpiresAtMsFromDurationMs)(PARENT_CACHE_TTL_MS, { nowMs });
+function hasDefinitiveContentType(media) {
+	const contentType = media.contentType?.split(";", 1)[0]?.trim().toLowerCase();
+	return Boolean(contentType && contentType !== "application/octet-stream" && contentType !== "binary/octet-stream");
 }
-/**
-* Fetch a channel parent message with an LRU+TTL cache.
-*
-* Uses the injected `fetchParent` (defaults to `fetchChannelMessage`) so
-* tests can swap in a stub without mocking the Graph transport.
-*/
-async function fetchParentMessageCached(token, groupId, channelId, parentId, fetchParent = require_messenger.fetchChannelMessage) {
-	const key = buildParentCacheKey(groupId, channelId, parentId);
-	const now = (0, openclaw_plugin_sdk_number_runtime.asDateTimestampMs)(Date.now());
-	const cached = parentCache.get(key);
-	const cachedExpiresAt = cached ? (0, openclaw_plugin_sdk_number_runtime.asDateTimestampMs)(cached.expiresAt) : void 0;
-	if (cached && now !== void 0 && cachedExpiresAt !== void 0 && cachedExpiresAt > now) {
-		parentCache.delete(key);
-		parentCache.set(key, cached);
-		return cached.message;
+function mergeMSTeamsMediaFacts(nativeMedia, materializedMedia, options = {}) {
+	const merged = [...nativeMedia];
+	const nativeSlotCount = nativeMedia.length;
+	const nativeIndexBySourceId = /* @__PURE__ */ new Map();
+	nativeMedia.forEach((media, index) => {
+		if (media.sourceId && !nativeIndexBySourceId.has(media.sourceId)) nativeIndexBySourceId.set(media.sourceId, index);
+	});
+	for (const [index, materialized] of materializedMedia.entries()) {
+		const sourceIndex = materialized.sourceId ? nativeIndexBySourceId.get(materialized.sourceId) : void 0;
+		const positionalIndex = options.positionallyAligned === false || index >= nativeMedia.length ? void 0 : index;
+		const mayUseFallbackOrder = options.positionallyAligned === false;
+		const isEligibleUnresolved = (media) => !media.path && !media.sourceId;
+		const sameKindUnresolvedIndexes = mayUseFallbackOrder ? merged.slice(0, nativeSlotCount).flatMap((media, mediaIndex) => isEligibleUnresolved(media) && media.kind === materialized.kind ? [mediaIndex] : []) : [];
+		const unresolvedIndexes = sameKindUnresolvedIndexes.length === 0 && mayUseFallbackOrder ? merged.slice(0, nativeSlotCount).flatMap((media, mediaIndex) => isEligibleUnresolved(media) ? [mediaIndex] : []) : [];
+		const fallbackIndex = sameKindUnresolvedIndexes.length > 0 ? sameKindUnresolvedIndexes[0] : unresolvedIndexes.length === 1 ? unresolvedIndexes[0] : void 0;
+		const targetIndex = sourceIndex ?? positionalIndex ?? fallbackIndex;
+		if (targetIndex === void 0) {
+			if (materialized.sourceId) nativeIndexBySourceId.set(materialized.sourceId, merged.length);
+			merged.push(materialized);
+		} else {
+			if (materialized.sourceId) nativeIndexBySourceId.set(materialized.sourceId, targetIndex);
+			const current = merged[targetIndex];
+			if (materialized.path) merged[targetIndex] = materialized;
+			else if (!current?.path) merged[targetIndex] = {
+				...current,
+				...materialized,
+				kind: hasDefinitiveContentType(materialized) || !current?.kind ? materialized.kind : current.kind
+			};
+		}
 	}
-	if (cached) parentCache.delete(key);
-	const message = await fetchParent(token, groupId, channelId, parentId);
-	const expiresAt = resolveParentCacheExpiresAt(Date.now());
-	if (expiresAt !== void 0) touchLru(parentCache, key, {
-		message,
-		expiresAt
-	}, PARENT_CACHE_MAX);
-	return message;
-}
-const PARENT_TEXT_MAX_CHARS = 400;
-/**
-* Extract a compact summary (sender + plain-text body) from a Graph parent
-* message. Returns undefined when the parent cannot be summarized (missing
-* or blank body).
-*/
-function summarizeParentMessage(message) {
-	if (!message) return;
-	const sender = message.from?.user?.displayName ?? message.from?.application?.displayName ?? "unknown";
-	const contentType = message.body?.contentType ?? "text";
-	const raw = message.body?.content ?? "";
-	const text = contentType === "html" ? require_messenger.stripHtmlFromTeamsMessage(raw) : raw.replace(/\s+/g, " ").trim();
-	if (!text) return;
-	return {
-		sender,
-		text: text.length > PARENT_TEXT_MAX_CHARS ? `${(0, openclaw_plugin_sdk_text_utility_runtime.truncateUtf16Safe)(text, PARENT_TEXT_MAX_CHARS - 1)}…` : text
-	};
-}
-/**
-* Build the single-line `Replying to @sender: body` system event text.
-* Callers should pass this text to `enqueueSystemEvent` together with a
-* stable contextKey derived from the parent id.
-*/
-function formatParentContextEvent(summary) {
-	return `Replying to @${summary.sender}: ${summary.text}`;
-}
-/**
-* Decide whether a parent context event should be enqueued for the current
-* session. Returns `false` when we already injected the same parent for this
-* session recently (prevents re-prepending identical context on every reply
-* in the thread).
-*/
-function shouldInjectParentContext(sessionKey, parentId) {
-	const key = sessionKey;
-	return injectedParents.get(key) !== parentId;
-}
-/**
-* Record that `parentId` was just injected for `sessionKey` so subsequent
-* replies with the same parent can short-circuit via `shouldInjectParentContext`.
-*/
-function markParentContextInjected(sessionKey, parentId) {
-	touchLru(injectedParents, sessionKey, parentId, INJECTED_MAX);
+	return merged;
 }
-//#endregion
-//#region extensions/msteams/src/reply-stream-controller.ts
-function isStreamCancelledError(err) {
-	return err instanceof Error && err.name === "StreamCancelledError";
+function hasMaterializedMedia(media) {
+	return media.some((entry) => Boolean(entry.path));
 }
-/**
-* Bridges openclaw's reply pipeline callbacks to the SDK's `ctx.stream`.
-* Streaming is enabled for personal (DM) conversations only; group/channel
-* messages fall through to block delivery.
-*
-* Streaming modes (resolved from `cfg.channels.msteams.streaming.preview`):
-* - "partial" (default): per-token streaming via `stream.emit(text)`. Each
-*   chunk goes onto the live preview card in Teams.
-* - "progress": no per-token streaming; the preview card carries an
-*   informative status that updates as tools run (e.g. "Looking up the
-*   schema..." → "Generating SQL..."). When tool-progress streaming is also
-*   enabled, raw tool names appear as bullets above the label.
-* - "block": disable native streaming entirely; the reply lands as a regular
-*   block message. We bypass the controller in that case.
-*/
-function createTeamsReplyStreamController(params) {
-	const isPersonal = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(params.conversationType) === "personal";
-	const streamMode = (0, openclaw_plugin_sdk_channel_outbound.resolveChannelPreviewStreamMode)(params.msteamsConfig, "partial");
-	const shouldUseNativeStream = isPersonal && (streamMode === "partial" || streamMode === "progress");
-	const shouldStreamPreviewToolProgress = streamMode === "progress" && (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingPreviewToolProgress)(params.msteamsConfig);
-	const stream = shouldUseNativeStream ? params.context.stream : void 0;
-	let tokensEmitted = false;
-	let streamFinalizationPending = false;
-	let canceledLocally = false;
-	let streamFailed = false;
-	let lastInformativeText = "";
-	let progressLines = [];
-	let latestPlan;
-	let latestPlanExplanation;
-	let pendingFinalPayload;
-	let emittedText = "";
-	const wasCanceled = () => canceledLocally || Boolean(stream?.canceled);
-	const fallbackPayloadForSuppressedFinal = (payload) => {
-		return Boolean(payload.mediaUrl || payload.mediaUrls?.length) ? {
-			...payload,
-			mediaUrl: void 0,
-			mediaUrls: void 0
-		} : payload;
-	};
-	/**
-	* Render the current informative status line into the streaming card. Pulls
-	* the rotating "Thinking..." label from msteams config (or the plugin-sdk
-	* default) and prepends collected tool-progress lines when configured.
-	*/
-	const renderInformativeUpdate = () => {
+async function resolveMSTeamsInboundMedia(params) {
+	const { attachments, htmlSummary, maxBytes, tokenProvider, allowHosts, conversationType, conversationId, conversationMessageId, teamAadGroupId, serviceUrl, activity, log, preserveFilenames } = params;
+	let mediaList = await downloadMSTeamsAttachments({
+		attachments,
+		maxBytes,
+		tokenProvider,
+		allowHosts,
+		authAllowHosts: params.authAllowHosts,
+		preserveFilenames,
+		deadline: params.deadline,
+		logger: log
+	});
+	if (!hasMaterializedMedia(mediaList)) {
+		const attachmentIds = extractMSTeamsHtmlAttachmentIds(attachments);
+		const hasHtmlFileAttachment = attachmentIds.length > 0;
+		const hasChannelOrGroupHtml = shouldAttemptMSTeamsGraphMediaFallback({
+			conversationType,
+			htmlSummary,
+			graphMediaFallback: params.graphMediaFallback
+		});
+		const shouldFetchGraphMessage = hasHtmlFileAttachment || hasChannelOrGroupHtml;
+		const isBotFrameworkPersonalChat = isBotFrameworkPersonalChatId(conversationId);
+		if (hasHtmlFileAttachment && isBotFrameworkPersonalChat) if (!serviceUrl) log.debug?.("bot framework attachment skipped (missing serviceUrl)", {
+			conversationType,
+			conversationId
+		});
+		else {
+			const bfMedia = await downloadMSTeamsBotFrameworkAttachments({
+				serviceUrl,
+				attachmentIds,
+				tokenProvider,
+				maxBytes,
+				allowHosts,
+				authAllowHosts: params.authAllowHosts,
+				preserveFilenames,
+				deadline: params.deadline
+			});
+			if (bfMedia.media.length > 0) mediaList = mergeMSTeamsMediaFacts(mediaList, bfMedia.media, { positionallyAligned: false });
+			if (!hasMaterializedMedia(bfMedia.media)) log.debug?.("bot framework attachments fetch empty", {
+				conversationType,
+				attachmentCount: bfMedia.attachmentCount ?? attachmentIds.length
+			});
+		}
+		if (shouldFetchGraphMessage && !hasMaterializedMedia(mediaList) && !isBotFrameworkPersonalChat) {
+			const graphTeamAadGroupId = conversationType.trim().toLowerCase() === "channel" && !teamAadGroupId ? await params.resolveTeamAadGroupId?.() : teamAadGroupId;
+			const messageUrl = buildMSTeamsGraphMessageUrl({
+				conversationType,
+				conversationId,
+				messageId: activity.id ?? void 0,
+				threadRootMessageId: conversationMessageId ?? activity.replyToId,
+				teamAadGroupId: graphTeamAadGroupId,
+				channelId: activity.channelData?.channel?.id
+			});
+			if (!messageUrl) log.debug?.("graph message url unavailable", {
+				conversationType,
+				hasChannelData: Boolean(activity.channelData),
+				messageId: activity.id ?? void 0,
+				replyToId: activity.replyToId ?? void 0
+			});
+			else {
+				const graphMedia = await downloadMSTeamsGraphMedia({
+					messageUrl,
+					tokenProvider,
+					maxBytes,
+					allowHosts,
+					authAllowHosts: params.authAllowHosts,
+					preserveFilenames,
+					deadline: params.deadline,
+					logger: log
+				});
+				if (graphMedia.media.length > 0) mediaList = mergeMSTeamsMediaFacts(mediaList, graphMedia.media, { positionallyAligned: false });
+				if (!hasMaterializedMedia(mediaList)) log.debug?.("graph media fetch empty", {
+					messageUrl,
+					hostedStatus: graphMedia.hostedStatus,
+					attachmentStatus: graphMedia.attachmentStatus,
+					hostedCount: graphMedia.hostedCount,
+					attachmentCount: graphMedia.attachmentCount,
+					tokenError: graphMedia.tokenError,
+					attachmentIdCount: attachmentIds.length
+				});
+			}
+		}
+	}
+	const materializedCount = mediaList.filter((media) => Boolean(media.path)).length;
+	if (materializedCount > 0) log.debug?.("downloaded attachments", { count: materializedCount });
+	else if (htmlSummary?.imgTags) log.debug?.("inline images detected but none downloaded", {
+		imgTags: htmlSummary.imgTags,
+		srcHosts: htmlSummary.srcHosts,
+		dataImages: htmlSummary.dataImages,
+		cidImages: htmlSummary.cidImages
+	});
+	return mediaList;
+}
+//#endregion
+//#region extensions/msteams/src/monitor-handler/inbound-content.ts
+async function prepareMSTeamsInboundContent(params) {
+	const activity = params.entry.context.activity;
+	const mayRecoverGraphMedia = Boolean(params.htmlSummary?.attachmentIds.length) || shouldAttemptMSTeamsGraphMediaFallback({
+		conversationType: params.conversationType,
+		htmlSummary: params.htmlSummary,
+		graphMediaFallback: params.graphMediaFallback
+	});
+	if (!params.rawBody && params.advertisedMedia.length === 0 && !mayRecoverGraphMedia) {
+		params.log.debug?.("skipping empty message after stripping mentions");
+		return null;
+	}
+	let mediaList = [];
+	try {
+		mediaList = await require_resolve_allowlist.withMSTeamsRequestDeadline({
+			deadline: params.deadline,
+			label: "MS Teams inbound media",
+			work: () => resolveMSTeamsInboundMedia({
+				attachments: params.entry.attachments,
+				htmlSummary: params.htmlSummary,
+				maxBytes: params.mediaMaxBytes,
+				tokenProvider: params.tokenProvider,
+				allowHosts: params.mediaAllowHosts,
+				authAllowHosts: params.mediaAuthAllowHosts,
+				graphMediaFallback: params.graphMediaFallback,
+				conversationType: params.conversationType,
+				conversationId: params.conversationId,
+				conversationMessageId: params.conversationMessageId,
+				teamAadGroupId: params.teamAadGroupId,
+				resolveTeamAadGroupId: params.resolveTeamAadGroupId,
+				serviceUrl: activity.serviceUrl,
+				activity: {
+					id: activity.id,
+					replyToId: activity.replyToId,
+					channelData: activity.channelData
+				},
+				log: params.log,
+				deadline: params.deadline,
+				preserveFilenames: false
+			})
+		});
+	} catch (err) {
+		params.log.debug?.("failed to resolve inbound Teams media", { error: require_setup_surface.formatUnknownError(err) });
+	}
+	const inboundMedia = mergeMSTeamsMediaFacts(params.advertisedMedia, mediaList);
+	const nativeMediaForComparison = [...params.advertisedMedia, ...mediaList.slice(params.advertisedMedia.length).map((media) => ({
+		contentType: media.contentType,
+		kind: media.kind
+	}))];
+	const agentBody = resolveMSTeamsInboundMediaBody({
+		body: params.rawBody,
+		nativeMedia: nativeMediaForComparison,
+		materializedMedia: inboundMedia
+	});
+	if (!agentBody && inboundMedia.length === 0) {
+		params.log.debug?.("skipping empty message after Graph media recovery");
+		return null;
+	}
+	return {
+		agentBody,
+		inboundMedia
+	};
+}
+//#endregion
+//#region extensions/msteams/src/reply-stream-controller.ts
+function isStreamCancelledError(err) {
+	return err instanceof Error && err.name === "StreamCancelledError";
+}
+/**
+* Bridges openclaw's reply pipeline callbacks to the SDK's `ctx.stream`.
+* Streaming is enabled for personal (DM) conversations only; group/channel
+* messages fall through to block delivery.
+*
+* Streaming modes (resolved from `cfg.channels.msteams.streaming.preview`):
+* - "partial" (default): per-token streaming via `stream.emit(text)`. Each
+*   chunk goes onto the live preview card in Teams.
+* - "progress": no per-token streaming; the preview card carries an
+*   informative status that updates as tools run (e.g. "Looking up the
+*   schema..." → "Generating SQL..."). When tool-progress streaming is also
+*   enabled, raw tool names appear as bullets above the label.
+* - "block": disable native streaming entirely; the reply lands as a regular
+*   block message. We bypass the controller in that case.
+*/
+function createTeamsReplyStreamController(params) {
+	const isPersonal = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(params.conversationType) === "personal";
+	const streamMode = (0, openclaw_plugin_sdk_channel_outbound.resolveChannelPreviewStreamMode)(params.msteamsConfig, "partial");
+	const shouldUseNativeStream = params.allowProviderPreview && isPersonal && (streamMode === "partial" || streamMode === "progress");
+	const shouldStreamPreviewToolProgress = streamMode === "progress" && (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingPreviewToolProgress)(params.msteamsConfig, true, streamMode);
+	const stream = shouldUseNativeStream ? params.context.stream : void 0;
+	let tokensEmitted = false;
+	let nativeDispatchStarted = false;
+	let nativeDeliveryClaimed = false;
+	let streamFinalizationPending = false;
+	let canceledLocally = false;
+	let streamFailed = false;
+	let lastInformativeText = "";
+	let progressLines = [];
+	let latestPlan;
+	let latestPlanExplanation;
+	let pendingFinalPayload;
+	let emittedText = "";
+	let acknowledgedText = "";
+	let acknowledgedStreamId;
+	const streamEvents = stream?.events;
+	let streamChunkSubscription;
+	if (typeof streamEvents?.on === "function" && typeof streamEvents.off === "function") streamChunkSubscription = streamEvents.on("chunk", (activity) => {
+		if (activity.type !== "typing" || activity.channelData?.streamType !== "streaming" || !activity.id || !activity.text || acknowledgedStreamId !== void 0 && activity.id !== acknowledgedStreamId || !activity.text.startsWith(acknowledgedText) || !emittedText.startsWith(activity.text)) return;
+		acknowledgedStreamId = activity.id;
+		acknowledgedText = activity.text;
+	});
+	const wasCanceled = () => canceledLocally || Boolean(stream?.canceled);
+	const releaseStreamChunkSubscription = () => {
+		if (streamChunkSubscription === void 0) return;
+		streamEvents?.off(streamChunkSubscription);
+		streamChunkSubscription = void 0;
+	};
+	const fallbackPayloadAfterAcknowledgedText = (payload) => {
+		if (!acknowledgedText || typeof payload.text !== "string" || !payload.text.startsWith(acknowledgedText)) return payload;
+		const remainingText = payload.text.slice(acknowledgedText.length);
+		const hasMedia = Boolean(payload.mediaUrl || payload.mediaUrls?.length);
+		if (!remainingText && !hasMedia) return;
+		return {
+			...payload,
+			text: remainingText || void 0
+		};
+	};
+	const fallbackPayloadForSuppressedFinal = (payload) => {
+		return Boolean(payload.mediaUrl || payload.mediaUrls?.length) ? {
+			...payload,
+			mediaUrl: void 0,
+			mediaUrls: void 0
+		} : payload;
+	};
+	/**
+	* Render the current informative status line into the streaming card. Pulls
+	* the rotating "Thinking..." label from msteams config (or the plugin-sdk
+	* default) and prepends collected tool-progress lines when configured.
+	*/
+	const renderInformativeUpdate = () => {
 		if (!stream || wasCanceled() || streamFinalizationPending) return;
 		const informativeText = (0, openclaw_plugin_sdk_channel_outbound.formatChannelProgressDraftText)({
 			entry: params.msteamsConfig,
@@ -1418,6 +1732,7 @@ function createTeamsReplyStreamController(params) {
 				stream.emit(delta);
 				emittedText = fullText;
 				tokensEmitted = true;
+				nativeDispatchStarted = true;
 			} catch (err) {
 				if (isStreamCancelledError(err)) {
 					canceledLocally = true;
@@ -1476,8 +1791,17 @@ function createTeamsReplyStreamController(params) {
 					text: void 0
 				} : void 0;
 			}
+			if (streamFailed) {
+				const fallback = fallbackPayloadAfterAcknowledgedText(payload);
+				pendingFinalPayload = void 0;
+				acknowledgedText = "";
+				acknowledgedStreamId = void 0;
+				releaseStreamChunkSubscription();
+				return fallback;
+			}
 			if (streamMode === "progress" && payload.text) try {
 				stream.emit(payload.text);
+				nativeDispatchStarted = true;
 				pendingFinalPayload = fallbackPayloadForSuppressedFinal(payload);
 				streamFinalizationPending = true;
 				return Boolean(payload.mediaUrl || payload.mediaUrls?.length) ? {
@@ -1493,18 +1817,39 @@ function createTeamsReplyStreamController(params) {
 			}
 			return payload;
 		},
+		claimNativeDelivery() {
+			if (!nativeDispatchStarted || nativeDeliveryClaimed) return false;
+			nativeDeliveryClaimed = true;
+			return true;
+		},
 		async finalize() {
 			progressDraftGate.cancel();
-			if (!stream || !streamFinalizationPending || wasCanceled()) return;
-			const finalEntities = [{
-				type: "https://schema.org/Message",
-				"@type": "Message",
-				"@context": "https://schema.org",
-				"@id": "",
-				additionalType: ["AIGeneratedContent"]
-			}];
-			const finalChannelData = params.feedbackLoopEnabled ? { feedbackLoopEnabled: true } : {};
+			if (!stream || !nativeDispatchStarted) {
+				releaseStreamChunkSubscription();
+				return { visibleReplySent: false };
+			}
+			const content = wasCanceled() ? acknowledgedText || void 0 : pendingFinalPayload?.text ?? (emittedText || void 0);
 			try {
+				if (wasCanceled()) {
+					pendingFinalPayload = void 0;
+					streamFinalizationPending = false;
+					return {
+						visibleReplySent: content !== void 0,
+						...content === void 0 ? {} : { content }
+					};
+				}
+				if (!streamFinalizationPending) return {
+					visibleReplySent: true,
+					...content === void 0 ? {} : { content }
+				};
+				const finalEntities = [{
+					type: "https://schema.org/Message",
+					"@type": "Message",
+					"@context": "https://schema.org",
+					"@id": "",
+					additionalType: ["AIGeneratedContent"]
+				}];
+				const finalChannelData = params.feedbackLoopEnabled ? { feedbackLoopEnabled: true } : {};
 				stream.emit({
 					type: "message",
 					entities: finalEntities,
@@ -1515,23 +1860,43 @@ function createTeamsReplyStreamController(params) {
 				if (!result) {
 					const fallback = pendingFinalPayload;
 					pendingFinalPayload = void 0;
-					return fallback;
+					const fallbackPayload = fallback && !wasCanceled() ? fallbackPayloadAfterAcknowledgedText(fallback) : void 0;
+					return {
+						visibleReplySent: true,
+						...content === void 0 ? {} : { content },
+						...fallbackPayload ? { fallbackPayload } : {}
+					};
 				}
 				pendingFinalPayload = void 0;
-				return;
+				const messageId = require_messenger.extractMessageId(result) ?? void 0;
+				return {
+					visibleReplySent: true,
+					...content === void 0 ? {} : { content },
+					...messageId ? { messageId } : {}
+				};
 			} catch (err) {
 				if (isStreamCancelledError(err)) {
 					canceledLocally = true;
 					pendingFinalPayload = void 0;
 					streamFinalizationPending = false;
-					return;
+					return {
+						visibleReplySent: true,
+						...content === void 0 ? {} : { content }
+					};
 				}
 				streamFailed = true;
 				streamFinalizationPending = false;
 				params.log?.warn?.(`msteams stream finalize failed: ${err instanceof Error ? err.message : String(err)}`);
 				const fallback = pendingFinalPayload;
 				pendingFinalPayload = void 0;
-				return fallback;
+				const fallbackPayload = fallback ? fallbackPayloadAfterAcknowledgedText(fallback) : void 0;
+				return {
+					visibleReplySent: true,
+					...content === void 0 ? {} : { content },
+					...fallbackPayload ? { fallbackPayload } : {}
+				};
+			} finally {
+				releaseStreamChunkSubscription();
 			}
 		},
 		hasStream() {
@@ -1616,7 +1981,9 @@ function createMSTeamsReplyDispatcher(params) {
 		resolveChannelLimitMb: ({ cfg }) => cfg.channels?.msteams?.mediaMaxMb
 	});
 	const feedbackLoopEnabled = params.cfg.channels?.msteams?.feedbackEnabled !== false;
+	const hookRunner = (0, openclaw_plugin_sdk_plugin_runtime.getGlobalHookRunner)();
 	const streamController = createTeamsReplyStreamController({
+		allowProviderPreview: !((hookRunner?.hasHooks("reply_payload_sending") ?? false) || (hookRunner?.hasHooks("message_sending") ?? false)),
 		conversationType,
 		context: params.context,
 		feedbackLoopEnabled,
@@ -1630,7 +1997,7 @@ function createMSTeamsReplyDispatcher(params) {
 	const blockStreamingResolved = teamsStreamMode === "block" ? true : (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingBlockEnabled)(msteamsCfg);
 	const blockStreamingEnabled = blockStreamingResolved ?? false;
 	const typingIndicatorEnabled = typeof msteamsCfg?.typingIndicator === "boolean" ? msteamsCfg.typingIndicator : true;
-	const pendingMessages = [];
+	const pendingDeliveries = [];
 	const sendMessages = async (messages) => {
 		return require_messenger.sendMSTeamsMessages({
 			replyStyle: params.replyStyle,
@@ -1669,33 +2036,71 @@ function createMSTeamsReplyDispatcher(params) {
 			contextKey: `msteams:delivery-failure:${params.conversationRef.conversation?.id ?? "unknown"}`
 		});
 	};
-	const queueReplyPayload = (payload) => {
-		const messages = require_messenger.renderReplyPayloadsToMessages([payload], {
+	const renderReplyPayload = (payload) => {
+		return require_messenger.renderReplyPayloadsToMessages([payload], {
 			textChunkLimit: params.textLimit,
 			chunkText: true,
 			mediaMode: "split",
 			tableMode,
 			chunkMode
 		});
-		pendingMessages.push(...messages);
+	};
+	const deliveryOutcome = (delivery) => {
+		const messageIds = [...delivery.nativeMessageId ? [delivery.nativeMessageId] : [], ...delivery.messageIds];
+		return {
+			visibleReplySent: delivery.visibleReplySent,
+			...messageIds.length > 0 ? { messageIds } : {},
+			...delivery.visibleReplySent && delivery.content !== void 0 ? { content: delivery.content } : {}
+		};
+	};
+	const settlePendingDelivery = (delivery) => {
+		if (delivery.settled || !delivery.blockSettled || delivery.native && !delivery.nativeSettled) return;
+		delivery.settled = true;
+		const outcome = deliveryOutcome(delivery);
+		if (delivery.errors.length === 0) {
+			delivery.finalization.resolve(outcome);
+			return;
+		}
+		const error = delivery.errors.find((candidate) => !(candidate instanceof openclaw_plugin_sdk_error_runtime.PlatformMessageNotDispatchedError)) ?? delivery.errors[0];
+		delivery.finalization.reject(delivery.visibleReplySent ? (0, openclaw_plugin_sdk_channel_inbound.createChannelPartialDeliveryError)(error, {
+			...outcome,
+			visibleReplySent: true
+		}) : error);
+	};
+	const queueReplyPayload = (payload, messages, native) => {
+		const delivery = {
+			messages,
+			finalization: (0, openclaw_plugin_sdk_extension_shared.createDeferred)(),
+			content: payload.text,
+			native,
+			nativeSettled: !native,
+			blockSettled: messages.length === 0,
+			settled: false,
+			visibleReplySent: false,
+			messageIds: [],
+			errors: []
+		};
+		pendingDeliveries.push(delivery);
+		return delivery;
 	};
 	const flushPendingMessages = async () => {
-		if (pendingMessages.length === 0) return;
-		const toSend = pendingMessages.splice(0);
-		const total = toSend.length;
-		let ids;
-		try {
-			ids = await sendMessages(toSend);
-		} catch (batchError) {
-			ids = [];
+		for (const delivery of pendingDeliveries) {
+			if (delivery.blockSettled) continue;
+			const toSend = delivery.messages.splice(0);
+			const total = toSend.length;
 			let failed = 0;
-			let lastFailedError = batchError;
+			let lastFailedError;
+			const sentIds = [];
 			for (const msg of toSend) try {
 				const msgIds = await sendMessages([msg]);
-				ids.push(...msgIds);
+				delivery.visibleReplySent ||= msgIds.length > 0;
+				const validIds = msgIds.filter((id) => id.trim() && id !== "unknown");
+				delivery.messageIds.push(...validIds);
+				sentIds.push(...validIds);
 			} catch (msgError) {
 				failed += 1;
 				lastFailedError = msgError;
+				delivery.errors.push(msgError);
 				params.log.debug?.("individual message send failed, continuing with remaining blocks");
 			}
 			if (failed > 0) {
@@ -1709,8 +2114,14 @@ function createMSTeamsReplyDispatcher(params) {
 					error: lastFailedError
 				});
 			}
+			delivery.blockSettled = true;
+			settlePendingDelivery(delivery);
+			if (sentIds.length > 0) try {
+				params.onSentMessageIds?.(sentIds);
+			} catch (error) {
+				params.log.warn?.("failed to record sent Teams message ids", { error: require_setup_surface.formatUnknownError(error) });
+			}
 		}
-		if (ids.length > 0) params.onSentMessageIds?.(ids);
 	};
 	const dispatcherOptions = {
 		...replyPipeline,
@@ -1722,11 +2133,22 @@ function createMSTeamsReplyDispatcher(params) {
 		typingCallbacks
 	};
 	const delivery = {
+		observeMessageSent: true,
 		deliver: async (payload) => {
 			const preparedPayload = streamController.preparePayload(payload);
-			if (!preparedPayload) return;
-			queueReplyPayload(preparedPayload);
+			const native = streamController.claimNativeDelivery();
+			const messages = preparedPayload ? renderReplyPayload(preparedPayload) : [];
+			if (!native && messages.length === 0) return {
+				visibleReplySent: false,
+				suppression: { reason: "no_visible_result" }
+			};
+			const pending = queueReplyPayload(payload, messages, native);
 			if (blockStreamingEnabled) await flushPendingMessages();
+			settlePendingDelivery(pending);
+			return {
+				visibleReplySent: false,
+				finalization: pending.finalization.promise
+			};
 		},
 		onError: (err, info) => {
 			const errMsg = require_setup_surface.formatUnknownError(err);
@@ -1741,30 +2163,41 @@ function createMSTeamsReplyDispatcher(params) {
 			});
 		}
 	};
-	const settleDelivery = () => {
-		return flushPendingMessages().catch((err) => {
-			const errMsg = require_setup_surface.formatUnknownError(err);
-			const classification = require_setup_surface.classifyMSTeamsSendError(err);
-			const hint = require_setup_surface.formatMSTeamsSendErrorHint(classification);
-			params.runtime.error?.(`msteams flush reply failed: ${errMsg}${hint ? ` (${hint})` : ""}`);
-			params.log.error("flush reply failed", {
-				error: errMsg,
-				classification,
-				hint
-			});
-		}).then(async () => {
-			const fallbackPayload = await streamController.finalize().catch((err) => {
-				params.log.debug?.("stream finalize failed", { error: require_setup_surface.formatUnknownError(err) });
-			});
-			if (fallbackPayload) {
-				queueReplyPayload(fallbackPayload);
-				await flushPendingMessages();
-			}
-		});
+	const settleDelivery = async () => {
+		await flushPendingMessages();
+		const nativeDelivery = pendingDeliveries.find((candidate) => candidate.native && !candidate.nativeSettled);
+		if (!nativeDelivery) {
+			await streamController.finalize();
+			return;
+		}
+		let nativeResult;
+		try {
+			nativeResult = await streamController.finalize();
+		} catch (error) {
+			nativeDelivery.errors.push(error);
+			nativeDelivery.nativeSettled = true;
+			settlePendingDelivery(nativeDelivery);
+			return;
+		}
+		nativeDelivery.visibleReplySent ||= nativeResult.visibleReplySent;
+		nativeDelivery.nativeMessageId = nativeResult.messageId;
+		if (nativeResult.content !== void 0) nativeDelivery.content = nativeResult.content;
+		if (nativeResult.fallbackPayload) {
+			nativeDelivery.messages.push(...renderReplyPayload(nativeResult.fallbackPayload));
+			nativeDelivery.blockSettled = nativeDelivery.messages.length === 0;
+		}
+		nativeDelivery.nativeSettled = true;
+		if (!nativeDelivery.blockSettled) await flushPendingMessages();
+		settlePendingDelivery(nativeDelivery);
+		if (nativeResult.messageId) try {
+			params.onSentMessageIds?.([nativeResult.messageId]);
+		} catch (error) {
+			params.log.warn?.("failed to record sent Teams message id", { error: require_setup_surface.formatUnknownError(error) });
+		}
 	};
-	const previewToolProgressEnabled = (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingPreviewToolProgress)(msteamsCfg);
+	const previewToolProgressEnabled = (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingPreviewToolProgress)(msteamsCfg, true, teamsStreamMode);
 	const suppressDefaultToolProgressMessages = (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingSuppressDefaultToolProgressMessages)(msteamsCfg);
-	const shouldSuppressDefaultToolProgressMessages = teamsStreamMode === "progress" && suppressDefaultToolProgressMessages && previewToolProgressEnabled;
+	const shouldSuppressDefaultToolProgressMessages = streamController.hasStream() && teamsStreamMode === "progress" && suppressDefaultToolProgressMessages && previewToolProgressEnabled;
 	const progressCallbacks = streamController.hasStream() ? {
 		onReasoningStream: async (payload) => {
 			const text = typeof payload?.text === "string" ? payload.text : void 0;
@@ -1901,181 +2334,214 @@ async function wasMSTeamsMessageSentWithPersistence(params) {
 	return await sentMessages.lookup(makeKey(params.conversationId, params.messageId));
 }
 //#endregion
-//#region extensions/msteams/src/team-identity.ts
-const teamGroupIdCache = /* @__PURE__ */ new Map();
-const TEAM_GROUP_ID_CACHE_MAX_ENTRIES = 500;
-function cacheTeamGroupId(conversationTeamId, groupId) {
-	teamGroupIdCache.set(conversationTeamId, groupId);
-	(0, openclaw_plugin_sdk_collection_runtime.pruneMapToMaxSize)(teamGroupIdCache, TEAM_GROUP_ID_CACHE_MAX_ENTRIES);
-}
-/** Resolve the Graph team GUID without ever treating a Bot Framework team ID as equivalent. */
-async function resolveTeamGroupId(params) {
-	const activityGroupId = params.aadGroupId?.trim();
-	if (activityGroupId) {
-		cacheTeamGroupId(params.conversationTeamId, activityGroupId);
-		return activityGroupId;
-	}
-	const cached = teamGroupIdCache.get(params.conversationTeamId);
-	if (cached) return cached;
-	const getTeamDetails = params.getTeamDetails;
-	if (!getTeamDetails) return;
-	const groupId = (await require_resolve_allowlist.withMSTeamsRequestDeadline({
-		deadline: params.deadline,
-		label: "MS Teams team details",
-		work: () => getTeamDetails(params.conversationTeamId)
-	})).aadGroupId?.trim();
-	if (!groupId) return;
-	cacheTeamGroupId(params.conversationTeamId, groupId);
-	return groupId;
-}
-//#endregion
-//#region extensions/msteams/src/monitor-handler/inbound-media.ts
-function shouldAttemptMSTeamsGraphMediaFallback(params) {
-	const conversationType = params.conversationType.trim().toLowerCase();
-	return params.graphMediaFallback === true && (conversationType === "channel" || conversationType === "groupchat") && (params.htmlSummary?.htmlAttachments ?? 0) > 0;
-}
-function resolveMSTeamsInboundMediaBody(params) {
-	const unavailableCount = params.materializedMedia.filter((media) => !media.path).length + Math.max(0, params.nativeMedia.length - params.materializedMedia.length);
-	if (unavailableCount === 0) return params.body;
-	return (0, openclaw_plugin_sdk_channel_inbound.formatInboundMediaUnavailableText)({
-		body: params.body,
-		notice: `[msteams ${unavailableCount > 1 ? `${unavailableCount} attachments` : "attachment"} unavailable]`
+//#region extensions/msteams/src/monitor-handler/inbound-dispatch.ts
+async function dispatchMSTeamsInboundTurn(params) {
+	const core = require_runtime.getMSTeamsRuntime();
+	const { cfg, runtime, appId, app, tokenProvider, textLimit, log, logVerboseMessage, facts, admission, content, routing, thread, replyStyle, timestamp, contextVisibilityMode, conversationHistories, historyLimit } = params;
+	const { context, activity, rawBody, text, quoteInfo, conversationRef } = facts;
+	const { senderId, senderName, isDirectMessage, allowNameMatching, groupPolicy, commandAuthorized, effectiveGroupAllowFrom } = admission;
+	const { route } = routing;
+	const { agentBody, inboundMedia } = content;
+	const { teamAadGroupId, quoteBodyFull, quoteSenderId, quoteSenderName, threadContext } = thread;
+	const { conversationId, conversationType, isChannel, teamId, graphChannelId } = facts;
+	const teamsFrom = isDirectMessage ? `msteams:${senderId}` : isChannel ? `msteams:channel:${conversationId}` : `msteams:group:${conversationId}`;
+	const teamsTo = isDirectMessage ? `user:${senderId}` : `conversation:${conversationId}`;
+	const envelopeFrom = isDirectMessage ? senderName : conversationType;
+	const buildEnvelope = (0, openclaw_plugin_sdk_channel_inbound.createChannelInboundEnvelopeBuilder)({
+		cfg,
+		route
 	});
-}
-function hasDefinitiveContentType(media) {
-	const contentType = media.contentType?.split(";", 1)[0]?.trim().toLowerCase();
-	return Boolean(contentType && contentType !== "application/octet-stream" && contentType !== "binary/octet-stream");
-}
-function mergeMSTeamsMediaFacts(nativeMedia, materializedMedia, options = {}) {
-	const merged = [...nativeMedia];
-	const nativeSlotCount = nativeMedia.length;
-	const nativeIndexBySourceId = /* @__PURE__ */ new Map();
-	nativeMedia.forEach((media, index) => {
-		if (media.sourceId && !nativeIndexBySourceId.has(media.sourceId)) nativeIndexBySourceId.set(media.sourceId, index);
+	let combinedBody = buildEnvelope({
+		channel: "Teams",
+		from: envelopeFrom,
+		timestamp,
+		body: agentBody
 	});
-	for (const [index, materialized] of materializedMedia.entries()) {
-		const sourceIndex = materialized.sourceId ? nativeIndexBySourceId.get(materialized.sourceId) : void 0;
-		const positionalIndex = options.positionallyAligned === false || index >= nativeMedia.length ? void 0 : index;
-		const mayUseFallbackOrder = options.positionallyAligned === false;
-		const isEligibleUnresolved = (media) => !media.path && !media.sourceId;
-		const sameKindUnresolvedIndexes = mayUseFallbackOrder ? merged.slice(0, nativeSlotCount).flatMap((media, mediaIndex) => isEligibleUnresolved(media) && media.kind === materialized.kind ? [mediaIndex] : []) : [];
-		const unresolvedIndexes = sameKindUnresolvedIndexes.length === 0 && mayUseFallbackOrder ? merged.slice(0, nativeSlotCount).flatMap((media, mediaIndex) => isEligibleUnresolved(media) ? [mediaIndex] : []) : [];
-		const fallbackIndex = sameKindUnresolvedIndexes.length > 0 ? sameKindUnresolvedIndexes[0] : unresolvedIndexes.length === 1 ? unresolvedIndexes[0] : void 0;
-		const targetIndex = sourceIndex ?? positionalIndex ?? fallbackIndex;
-		if (targetIndex === void 0) {
-			if (materialized.sourceId) nativeIndexBySourceId.set(materialized.sourceId, merged.length);
-			merged.push(materialized);
-		} else {
-			if (materialized.sourceId) nativeIndexBySourceId.set(materialized.sourceId, targetIndex);
-			const current = merged[targetIndex];
-			if (materialized.path) merged[targetIndex] = materialized;
-			else if (!current?.path) merged[targetIndex] = {
-				...current,
-				...materialized,
-				kind: hasDefinitiveContentType(materialized) || !current?.kind ? materialized.kind : current.kind
-			};
+	const isRoomish = !isDirectMessage;
+	const historyKey = isRoomish ? conversationId : void 0;
+	if (isRoomish && historyKey) combinedBody = (0, openclaw_plugin_sdk_reply_history.createChannelHistoryWindow)({ historyMap: conversationHistories }).buildPendingContext({
+		historyKey,
+		limit: historyLimit,
+		currentMessage: combinedBody,
+		formatEntry: (entry) => buildEnvelope({
+			channel: "Teams",
+			from: conversationType,
+			timestamp: entry.timestamp,
+			previousTimestamp: null,
+			body: `${entry.sender}: ${entry.body}${entry.messageId ? ` [id:${entry.messageId}]` : ""}`
+		})
+	});
+	const inboundHistory = isRoomish && historyKey && historyLimit > 0 ? (0, openclaw_plugin_sdk_reply_history.createChannelHistoryWindow)({ historyMap: conversationHistories }).buildInboundHistory({
+		historyKey,
+		limit: historyLimit
+	}) : void 0;
+	const commandBody = text.trim();
+	const quoteSenderAllowed = quoteInfo && quoteInfo.sender ? (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSupplementalSenderAllowed)({
+		isGroup: !isDirectMessage,
+		groupPolicy,
+		allowFrom: effectiveGroupAllowFrom,
+		isSenderAllowed: (allowFrom) => require_channel.resolveMSTeamsAllowlistMatch({
+			allowFrom,
+			senderId: quoteSenderId ?? "",
+			senderName: quoteSenderName,
+			allowNameMatching
+		}).allowed
+	}) : true;
+	const bodyForAgent = threadContext ? `[Thread history]\n${threadContext}\n[/Thread history]\n\n${agentBody}` : agentBody;
+	const nativeChannelId = isChannel && teamAadGroupId ? `${teamAadGroupId}/${graphChannelId}` : void 0;
+	const ctxPayload = (0, openclaw_plugin_sdk_channel_inbound.buildChannelInboundEventContext)({
+		channel: "msteams",
+		contextVisibility: contextVisibilityMode,
+		supplemental: { quote: quoteInfo ? {
+			id: quoteInfo.id ?? activity.replyToId ?? void 0,
+			body: quoteBodyFull ?? quoteInfo.body,
+			sender: quoteInfo.sender,
+			senderAllowed: quoteSenderAllowed,
+			isQuote: true
+		} : void 0 },
+		media: await (0, openclaw_plugin_sdk_channel_inbound.toInboundMediaFactsWithMetadata)(inboundMedia),
+		messageId: activity.id,
+		timestamp: timestamp?.getTime() ?? Date.now(),
+		from: teamsFrom,
+		sender: {
+			id: senderId,
+			name: senderName
+		},
+		conversation: {
+			kind: isDirectMessage ? "direct" : isChannel ? "channel" : "group",
+			id: conversationId,
+			label: envelopeFrom,
+			spaceId: teamId,
+			nativeChannelId
+		},
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			accountId: route.accountId,
+			routeSessionKey: route.sessionKey
+		},
+		reply: {
+			to: teamsTo,
+			replyToId: activity.replyToId ?? void 0,
+			nativeChannelId
+		},
+		message: {
+			body: combinedBody,
+			bodyForAgent,
+			inboundHistory,
+			rawBody,
+			commandBody
+		},
+		sessionTranscript: { historyLimit: isRoomish ? historyLimit : 0 },
+		access: {
+			mentions: {
+				canDetectMention: !isDirectMessage,
+				wasMentioned: isDirectMessage || params.mentionWasEffective
+			},
+			commands: { authorized: commandAuthorized === true }
+		},
+		extra: {
+			GroupSubject: !isDirectMessage ? conversationType : void 0,
+			ReplyToIsQuote: quoteInfo ? true : void 0
 		}
-	}
-	return merged;
-}
-function hasMaterializedMedia(media) {
-	return media.some((entry) => Boolean(entry.path));
-}
-async function resolveMSTeamsInboundMedia(params) {
-	const { attachments, htmlSummary, maxBytes, tokenProvider, allowHosts, conversationType, conversationId, conversationMessageId, teamAadGroupId, serviceUrl, activity, log, preserveFilenames } = params;
-	let mediaList = await downloadMSTeamsAttachments({
-		attachments,
-		maxBytes,
+	});
+	const preview = (0, openclaw_plugin_sdk_text_utility_runtime.sliceUtf16Safe)(rawBody.replace(/\s+/g, " "), 0, 160);
+	logVerboseMessage(`msteams inbound: from=${ctxPayload.From} preview="${preview}"`);
+	const { dispatcherOptions, delivery, replyOptions } = createMSTeamsReplyDispatcher({
+		cfg,
+		agentId: route.agentId,
+		sessionKey: route.sessionKey,
+		accountId: route.accountId,
+		runtime,
+		log,
+		app,
+		appId,
+		conversationRef,
+		context,
+		replyStyle,
+		textLimit,
+		onSentMessageIds: (ids) => {
+			for (const id of ids) recordMSTeamsSentMessage(conversationId, id);
+		},
 		tokenProvider,
-		allowHosts,
-		authAllowHosts: params.authAllowHosts,
-		preserveFilenames,
-		deadline: params.deadline,
-		logger: log
+		sharePointSiteId: cfg.channels?.msteams?.sharePointSiteId
 	});
-	if (!hasMaterializedMedia(mediaList)) {
-		const attachmentIds = extractMSTeamsHtmlAttachmentIds(attachments);
-		const hasHtmlFileAttachment = attachmentIds.length > 0;
-		const hasChannelOrGroupHtml = shouldAttemptMSTeamsGraphMediaFallback({
-			conversationType,
-			htmlSummary,
-			graphMediaFallback: params.graphMediaFallback
-		});
-		const shouldFetchGraphMessage = hasHtmlFileAttachment || hasChannelOrGroupHtml;
-		const isBotFrameworkPersonalChat = isBotFrameworkPersonalChatId(conversationId);
-		if (hasHtmlFileAttachment && isBotFrameworkPersonalChat) if (!serviceUrl) log.debug?.("bot framework attachment skipped (missing serviceUrl)", {
-			conversationType,
-			conversationId
-		});
-		else {
-			const bfMedia = await downloadMSTeamsBotFrameworkAttachments({
-				serviceUrl,
-				attachmentIds,
-				tokenProvider,
-				maxBytes,
-				allowHosts,
-				authAllowHosts: params.authAllowHosts,
-				preserveFilenames,
-				deadline: params.deadline
-			});
-			if (bfMedia.media.length > 0) mediaList = mergeMSTeamsMediaFacts(mediaList, bfMedia.media, { positionallyAligned: false });
-			if (!hasMaterializedMedia(bfMedia.media)) log.debug?.("bot framework attachments fetch empty", {
-				conversationType,
-				attachmentCount: bfMedia.attachmentCount ?? attachmentIds.length
-			});
-		}
-		if (shouldFetchGraphMessage && !hasMaterializedMedia(mediaList) && !isBotFrameworkPersonalChat) {
-			const graphTeamAadGroupId = conversationType.trim().toLowerCase() === "channel" && !teamAadGroupId ? await params.resolveTeamAadGroupId?.() : teamAadGroupId;
-			const messageUrl = buildMSTeamsGraphMessageUrl({
-				conversationType,
-				conversationId,
-				messageId: activity.id ?? void 0,
-				threadRootMessageId: conversationMessageId ?? activity.replyToId,
-				teamAadGroupId: graphTeamAadGroupId,
-				channelId: activity.channelData?.channel?.id
-			});
-			if (!messageUrl) log.debug?.("graph message url unavailable", {
-				conversationType,
-				hasChannelData: Boolean(activity.channelData),
-				messageId: activity.id ?? void 0,
-				replyToId: activity.replyToId ?? void 0
-			});
-			else {
-				const graphMedia = await downloadMSTeamsGraphMedia({
-					messageUrl,
-					tokenProvider,
-					maxBytes,
-					allowHosts,
-					authAllowHosts: params.authAllowHosts,
-					preserveFilenames,
-					deadline: params.deadline,
-					logger: log
-				});
-				if (graphMedia.media.length > 0) mediaList = mergeMSTeamsMediaFacts(mediaList, graphMedia.media, { positionallyAligned: false });
-				if (!hasMaterializedMedia(mediaList)) log.debug?.("graph media fetch empty", {
-					messageUrl,
-					hostedStatus: graphMedia.hostedStatus,
-					attachmentStatus: graphMedia.attachmentStatus,
-					hostedCount: graphMedia.hostedCount,
-					attachmentCount: graphMedia.attachmentCount,
-					tokenError: graphMedia.tokenError,
-					attachmentIdCount: attachmentIds.length
-				});
+	const senderTimezone = (activity.entities?.find((entity) => entity.type === "clientInfo"))?.timezone || conversationRef.timezone;
+	const turnConfig = senderTimezone && !cfg.agents?.defaults?.userTimezone ? {
+		...cfg,
+		agents: {
+			...cfg.agents,
+			defaults: {
+				...cfg.agents?.defaults,
+				userTimezone: senderTimezone
 			}
 		}
+	} : cfg;
+	log.info("dispatching to agent", { sessionKey: route.sessionKey });
+	try {
+		const turnResult = await core.channel.inbound.run({
+			channel: "msteams",
+			accountId: route.accountId,
+			raw: context,
+			adapter: {
+				ingest: () => ({
+					id: activity.id ?? `${teamsFrom}:${Date.now()}`,
+					timestamp: timestamp?.getTime(),
+					rawText: rawBody,
+					textForAgent: bodyForAgent,
+					textForCommands: commandBody,
+					raw: activity
+				}),
+				resolveTurn: () => ({
+					cfg: turnConfig,
+					channel: "msteams",
+					accountId: route.accountId,
+					route: {
+						agentId: route.agentId,
+						sessionKey: route.sessionKey
+					},
+					ctxPayload,
+					record: { onRecordError: (err) => {
+						logVerboseMessage(`msteams: failed updating session meta: ${require_setup_surface.formatUnknownError(err)}`);
+					} },
+					history: {
+						isGroup: isRoomish,
+						historyKey,
+						historyMap: conversationHistories,
+						limit: historyLimit
+					},
+					dispatcherOptions,
+					delivery,
+					replyOptions: {
+						...replyOptions,
+						...facts.turnAdoptionLifecycle ? (0, openclaw_plugin_sdk_channel_outbound.bindIngressLifecycleToReplyOptions)(facts.turnAdoptionLifecycle) : {}
+					}
+				})
+			}
+		});
+		const dispatchResult = turnResult.dispatched ? turnResult.dispatchResult : void 0;
+		const counts = (0, openclaw_plugin_sdk_channel_inbound.resolveInboundReplyDispatchCounts)(dispatchResult);
+		log.info("dispatch complete", {
+			queuedFinal: dispatchResult?.queuedFinal ?? false,
+			counts
+		});
+		if ((0, openclaw_plugin_sdk_channel_inbound.hasFinalInboundReplyDispatch)(dispatchResult)) logVerboseMessage(`msteams: delivered ${counts.final} repl${counts.final === 1 ? "y" : "ies"} to ${teamsTo}`);
+		return {
+			kind: "completed",
+			finalResponses: counts.final
+		};
+	} catch (err) {
+		log.error("dispatch failed", { error: require_setup_surface.formatUnknownError(err) });
+		runtime.error(`msteams dispatch failed: ${require_setup_surface.formatUnknownError(err)}`);
+		if (facts.turnAdoptionLifecycle) throw err;
+		try {
+			await context.sendActivity("⚠️ Something went wrong. Please try again.");
+		} catch {}
+		return { kind: "failed" };
 	}
-	const materializedCount = mediaList.filter((media) => Boolean(media.path)).length;
-	if (materializedCount > 0) log.debug?.("downloaded attachments", { count: materializedCount });
-	else if (htmlSummary?.imgTags) log.debug?.("inline images detected but none downloaded", {
-		imgTags: htmlSummary.imgTags,
-		srcHosts: htmlSummary.srcHosts,
-		dataImages: htmlSummary.dataImages,
-		cidImages: htmlSummary.cidImages
-	});
-	return mediaList;
 }
 //#endregion
-//#region extensions/msteams/src/monitor-handler/message-handler.ts
+//#region extensions/msteams/src/monitor-handler/inbound-facts.ts
 function extractTextFromHtmlAttachments(attachments) {
 	for (const attachment of attachments) {
 		const raw = require_resolve_allowlist.extractHtmlFromAttachment(attachment);
@@ -2085,54 +2551,354 @@ function extractTextFromHtmlAttachments(attachments) {
 	}
 	return "";
 }
-function formatMSTeamsSenderReason(params) {
-	switch (params.reasonCode) {
-		case "dm_policy_open": return "dmPolicy=open";
-		case "dm_policy_disabled": return "dmPolicy=disabled";
-		case "dm_policy_pairing_required": return "dmPolicy=pairing (not allowlisted)";
-		case "dm_policy_allowlisted": return `dmPolicy=${params.dmPolicy ?? "allowlist"} (allowlisted)`;
-		case "dm_policy_not_allowlisted": return `dmPolicy=${params.dmPolicy ?? "allowlist"} (not allowlisted)`;
-		case "group_policy_disabled": return "groupPolicy=disabled";
-		case "group_policy_empty_allowlist":
-		case "route_sender_empty": return "groupPolicy=allowlist (empty allowlist)";
-		case "group_policy_not_allowlisted": return "groupPolicy=allowlist (not allowlisted)";
-		case "group_policy_open": return "groupPolicy=open";
-		case "group_policy_allowed": return `groupPolicy=${params.groupPolicy ?? "allowlist"}`;
-		default: return params.reasonCode;
+async function prepareMSTeamsDebounceEntry(params) {
+	const activity = params.context.activity;
+	const attachments = Array.isArray(activity.attachments) ? activity.attachments : [];
+	const rawText = activity.text?.trim() ?? "";
+	const htmlText = extractTextFromHtmlAttachments(attachments);
+	const valueText = rawText || htmlText ? "" : serializeMSTeamsAdaptiveCardActionValue(activity.value);
+	const text = require_resolve_allowlist.stripMSTeamsMentionTags(rawText || htmlText || valueText || "");
+	const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(activity.conversation?.id ?? "");
+	const replyToId = activity.replyToId ?? void 0;
+	const implicitMentionKinds = conversationId && replyToId && await wasMSTeamsMessageSentWithPersistence({
+		conversationId,
+		messageId: replyToId
+	}) ? ["reply_to_bot"] : [];
+	return {
+		context: params.context,
+		rawText,
+		text,
+		attachments,
+		wasMentioned: require_resolve_allowlist.wasMSTeamsBotMentioned(activity),
+		implicitMentionKinds,
+		turnAdoptionLifecycle: params.turnAdoptionLifecycle
+	};
+}
+function buildStoredConversationReference(params) {
+	const { activity, conversationId, conversationType, teamId, threadId } = params;
+	const from = activity.from;
+	const conversation = activity.conversation;
+	const clientInfo = activity.entities?.find((entity) => entity.type === "clientInfo");
+	const tenantId = activity.channelData?.tenant?.id ?? conversation?.tenantId;
+	const aadObjectId = from?.aadObjectId;
+	const serviceUrl = require_resolve_allowlist.tryNormalizeBotFrameworkServiceUrl(activity.serviceUrl);
+	return {
+		activityId: activity.id,
+		user: from ? {
+			id: from.id,
+			name: from.name,
+			aadObjectId: from.aadObjectId
+		} : void 0,
+		agent: activity.recipient,
+		conversation: {
+			id: conversationId,
+			conversationType,
+			tenantId
+		},
+		...tenantId ? { tenantId } : {},
+		...aadObjectId ? { aadObjectId } : {},
+		teamId,
+		channelId: activity.channelId,
+		...serviceUrl ? { serviceUrl } : {},
+		locale: activity.locale,
+		...clientInfo?.timezone ? { timezone: clientInfo.timezone } : {},
+		...threadId ? { threadId } : {}
+	};
+}
+function assembleMSTeamsInboundFacts(params) {
+	const { entry, mediaMaxBytes } = params;
+	const activity = entry.context.activity;
+	const conversation = activity.conversation;
+	const rawConversationId = conversation?.id ?? "";
+	const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(rawConversationId);
+	const conversationMessageId = require_resolve_allowlist.extractMSTeamsConversationMessageId(rawConversationId);
+	const conversationType = conversation?.conversationType ?? "personal";
+	const isChannel = conversationType === "channel";
+	const teamId = activity.channelData?.team?.id;
+	const threadId = isChannel ? conversationMessageId ?? activity.replyToId ?? void 0 : void 0;
+	const advertisedMedia = resolveMSTeamsAdvertisedMedia(entry.attachments, {
+		maxInlineBytes: mediaMaxBytes,
+		maxInlineTotalBytes: mediaMaxBytes
+	});
+	return {
+		...entry,
+		activity,
+		from: activity.from,
+		conversation,
+		rawBody: entry.text,
+		advertisedMedia,
+		quoteInfo: require_resolve_allowlist.extractMSTeamsQuoteInfo(entry.attachments),
+		attachmentTypes: entry.attachments.map((attachment) => typeof attachment.contentType === "string" ? attachment.contentType : void 0).filter(Boolean).slice(0, 3),
+		htmlSummary: summarizeMSTeamsHtmlAttachments(entry.attachments),
+		rawConversationId,
+		conversationId,
+		conversationMessageId,
+		conversationType,
+		isChannel,
+		teamId,
+		graphChannelId: activity.channelData?.channel?.id?.trim() || conversationId,
+		threadId,
+		conversationRef: buildStoredConversationReference({
+			activity,
+			conversationId,
+			conversationType,
+			teamId,
+			threadId
+		})
+	};
+}
+//#endregion
+//#region extensions/msteams/src/team-identity.ts
+const teamGroupIdCache = /* @__PURE__ */ new Map();
+const TEAM_GROUP_ID_CACHE_MAX_ENTRIES = 500;
+function cacheTeamGroupId(conversationTeamId, groupId) {
+	teamGroupIdCache.set(conversationTeamId, groupId);
+	(0, openclaw_plugin_sdk_collection_runtime.pruneMapToMaxSize)(teamGroupIdCache, TEAM_GROUP_ID_CACHE_MAX_ENTRIES);
+}
+/** Resolve the Graph team GUID without ever treating a Bot Framework team ID as equivalent. */
+async function resolveTeamGroupId(params) {
+	const activityGroupId = params.aadGroupId?.trim();
+	if (activityGroupId) {
+		cacheTeamGroupId(params.conversationTeamId, activityGroupId);
+		return activityGroupId;
+	}
+	const cached = teamGroupIdCache.get(params.conversationTeamId);
+	if (cached) return cached;
+	const getTeamDetails = params.getTeamDetails;
+	if (!getTeamDetails) return;
+	const groupId = (await require_resolve_allowlist.withMSTeamsRequestDeadline({
+		deadline: params.deadline,
+		label: "MS Teams team details",
+		work: () => getTeamDetails(params.conversationTeamId)
+	})).aadGroupId?.trim();
+	if (!groupId) return;
+	cacheTeamGroupId(params.conversationTeamId, groupId);
+	return groupId;
+}
+//#endregion
+//#region extensions/msteams/src/thread-parent-context.ts
+const PARENT_CACHE_TTL_MS = 300 * 1e3;
+const PARENT_CACHE_MAX = 100;
+const parentCache = /* @__PURE__ */ new Map();
+const INJECTED_MAX = 200;
+const injectedParents = /* @__PURE__ */ new Map();
+function touchLru(map, key, value, max) {
+	if (map.has(key)) map.delete(key);
+	else if (map.size >= max) {
+		const firstKey = map.keys().next().value;
+		if (firstKey !== void 0) map.delete(firstKey);
+	}
+	map.set(key, value);
+}
+function buildParentCacheKey(groupId, channelId, parentId) {
+	return `${groupId}\u0000${channelId}\u0000${parentId}`;
+}
+function resolveParentCacheExpiresAt(nowRaw) {
+	const nowMs = (0, openclaw_plugin_sdk_number_runtime.asDateTimestampMs)(nowRaw);
+	return nowMs === void 0 ? void 0 : (0, openclaw_plugin_sdk_number_runtime.resolveExpiresAtMsFromDurationMs)(PARENT_CACHE_TTL_MS, { nowMs });
+}
+/**
+* Fetch a channel parent message with an LRU+TTL cache.
+*
+* Uses the injected `fetchParent` (defaults to `fetchChannelMessage`) so
+* tests can swap in a stub without mocking the Graph transport.
+*/
+async function fetchParentMessageCached(token, groupId, channelId, parentId, fetchParent = require_messenger.fetchChannelMessage) {
+	const key = buildParentCacheKey(groupId, channelId, parentId);
+	const now = (0, openclaw_plugin_sdk_number_runtime.asDateTimestampMs)(Date.now());
+	const cached = parentCache.get(key);
+	const cachedExpiresAt = cached ? (0, openclaw_plugin_sdk_number_runtime.asDateTimestampMs)(cached.expiresAt) : void 0;
+	if (cached && now !== void 0 && cachedExpiresAt !== void 0 && cachedExpiresAt > now) {
+		parentCache.delete(key);
+		parentCache.set(key, cached);
+		return cached.message;
+	}
+	if (cached) parentCache.delete(key);
+	const message = await fetchParent(token, groupId, channelId, parentId);
+	const expiresAt = resolveParentCacheExpiresAt(Date.now());
+	if (expiresAt !== void 0) touchLru(parentCache, key, {
+		message,
+		expiresAt
+	}, PARENT_CACHE_MAX);
+	return message;
+}
+const PARENT_TEXT_MAX_CHARS = 400;
+/**
+* Extract a compact summary (sender + plain-text body) from a Graph parent
+* message. Returns undefined when the parent cannot be summarized (missing
+* or blank body).
+*/
+function summarizeParentMessage(message) {
+	if (!message) return;
+	const sender = message.from?.user?.displayName ?? message.from?.application?.displayName ?? "unknown";
+	const contentType = message.body?.contentType ?? "text";
+	const raw = message.body?.content ?? "";
+	const text = contentType === "html" ? require_messenger.stripHtmlFromTeamsMessage(raw) : raw.replace(/\s+/g, " ").trim();
+	if (!text) return;
+	return {
+		sender,
+		text: text.length > PARENT_TEXT_MAX_CHARS ? `${(0, openclaw_plugin_sdk_text_utility_runtime.truncateUtf16Safe)(text, PARENT_TEXT_MAX_CHARS - 1)}…` : text
+	};
+}
+/**
+* Build the single-line `Replying to @sender: body` system event text.
+* Callers should pass this text to `enqueueSystemEvent` together with a
+* stable contextKey derived from the parent id.
+*/
+function formatParentContextEvent(summary) {
+	return `Replying to @${summary.sender}: ${summary.text}`;
+}
+/**
+* Decide whether a parent context event should be enqueued for the current
+* session. Returns `false` when we already injected the same parent for this
+* session recently (prevents re-prepending identical context on every reply
+* in the thread).
+*/
+function shouldInjectParentContext(sessionKey, parentId) {
+	const key = sessionKey;
+	return injectedParents.get(key) !== parentId;
+}
+/**
+* Record that `parentId` was just injected for `sessionKey` so subsequent
+* replies with the same parent can short-circuit via `shouldInjectParentContext`.
+*/
+function markParentContextInjected(sessionKey, parentId) {
+	touchLru(injectedParents, sessionKey, parentId, INJECTED_MAX);
+}
+//#endregion
+//#region extensions/msteams/src/monitor-handler/thread-context.ts
+function prepareMSTeamsThreadRouting(params) {
+	const route = require_runtime.getMSTeamsRuntime().channel.routing.resolveAgentRoute({
+		cfg: params.cfg,
+		channel: "msteams",
+		teamId: params.teamId,
+		peer: {
+			kind: params.isDirectMessage ? "direct" : params.isChannel ? "channel" : "group",
+			id: params.isDirectMessage ? params.senderId : params.conversationId
+		}
+	});
+	route.sessionKey = require_channel.resolveMSTeamsRouteSessionKey({
+		baseSessionKey: route.sessionKey,
+		isChannel: params.isChannel,
+		conversationMessageId: params.conversationMessageId,
+		replyToId: params.context.activity.replyToId
+	});
+	const deadline = require_resolve_allowlist.createMSTeamsInboundDeadline();
+	let teamAadGroupId = params.context.activity.channelData?.team?.aadGroupId?.trim() || void 0;
+	const conversationTeamId = params.isChannel ? params.teamId : void 0;
+	let teamGroupIdPromise;
+	const resolveTeamAadGroupId = async () => {
+		if (!conversationTeamId) return;
+		teamGroupIdPromise ??= resolveTeamGroupId({
+			conversationTeamId,
+			aadGroupId: teamAadGroupId,
+			getTeamDetails: params.context.getTeamDetails,
+			deadline
+		}).catch((err) => {
+			params.log.debug?.("failed to resolve Teams AAD group ID", {
+				teamId: conversationTeamId,
+				error: require_setup_surface.formatUnknownError(err)
+			});
+		});
+		teamAadGroupId = await teamGroupIdPromise;
+		return teamAadGroupId;
+	};
+	return {
+		route,
+		deadline,
+		resolveTeamAadGroupId,
+		getTeamAadGroupId: () => teamAadGroupId
+	};
+}
+async function resolveMSTeamsThreadContext(params) {
+	const core = require_runtime.getMSTeamsRuntime();
+	const activity = params.context.activity;
+	const { route, deadline } = params.routing;
+	const teamAadGroupId = await params.routing.resolveTeamAadGroupId();
+	let quoteBodyFull;
+	let quoteSenderId;
+	let quoteSenderName;
+	const quoteMessageId = params.quoteInfo?.id;
+	if (quoteMessageId && params.isDirectMessage && params.conversationId.startsWith("19:")) try {
+		const graphToken = await require_resolve_allowlist.withMSTeamsRequestDeadline({
+			deadline,
+			label: "MS Teams quote token",
+			work: () => params.tokenProvider.getAccessToken("https://graph.microsoft.com")
+		});
+		quoteBodyFull = await require_resolve_allowlist.withMSTeamsRequestDeadline({
+			deadline,
+			label: "MS Teams quote lookup",
+			work: () => require_messenger.fetchChatMessageText(graphToken, params.conversationId, quoteMessageId, deadline)
+		});
+	} catch (err) {
+		params.log.debug?.("failed to fetch full quoted message text", { error: require_setup_surface.formatUnknownError(err) });
 	}
-}
-function buildStoredConversationReference(params) {
-	const { activity, conversationId, conversationType, teamId, threadId } = params;
-	const from = activity.from;
-	const conversation = activity.conversation;
-	const agent = activity.recipient;
-	const clientInfo = activity.entities?.find((e) => e.type === "clientInfo");
-	const tenantId = activity.channelData?.tenant?.id ?? conversation?.tenantId;
-	const aadObjectId = from?.aadObjectId;
-	const serviceUrl = require_resolve_allowlist.tryNormalizeBotFrameworkServiceUrl(activity.serviceUrl);
+	let threadContext;
+	const threadParentId = activity.replyToId;
+	if (threadParentId && params.isChannel && teamAadGroupId) try {
+		const graphToken = await require_resolve_allowlist.withMSTeamsRequestDeadline({
+			deadline,
+			label: "MS Teams thread token",
+			work: () => params.tokenProvider.getAccessToken("https://graph.microsoft.com")
+		});
+		const [parentResult, repliesResult] = await require_resolve_allowlist.withMSTeamsRequestDeadline({
+			deadline,
+			label: "MS Teams thread history",
+			work: () => Promise.allSettled([fetchParentMessageCached(graphToken, teamAadGroupId, params.conversationId, threadParentId, (token, groupId, requestedChannelId, messageId) => require_messenger.fetchChannelMessage(token, groupId, requestedChannelId, messageId, deadline)), require_messenger.fetchThreadReplies(graphToken, teamAadGroupId, params.conversationId, threadParentId, 50, deadline)])
+		});
+		const parentMsg = parentResult.status === "fulfilled" ? parentResult.value : void 0;
+		const replies = repliesResult.status === "fulfilled" ? repliesResult.value : [];
+		if (parentResult.status === "rejected") params.log.debug?.("failed to fetch parent message", { error: require_setup_surface.formatUnknownError(parentResult.reason) });
+		if (repliesResult.status === "rejected") params.log.debug?.("failed to fetch thread replies", { error: require_setup_surface.formatUnknownError(repliesResult.reason) });
+		const isThreadSenderAllowed = (message) => (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSupplementalSenderAllowed)({
+			isGroup: params.isChannel,
+			groupPolicy: params.groupPolicy,
+			allowFrom: params.effectiveGroupAllowFrom,
+			isSenderAllowed: (allowFrom) => require_channel.resolveMSTeamsAllowlistMatch({
+				allowFrom,
+				senderId: message.from?.user?.id ?? "",
+				senderName: message.from?.user?.displayName,
+				allowNameMatching: params.allowNameMatching
+			}).allowed
+		});
+		const parentSummary = summarizeParentMessage(parentMsg);
+		const visibleParentMessages = parentMsg ? (0, openclaw_plugin_sdk_context_visibility_runtime.filterSupplementalContextItems)({
+			items: [parentMsg],
+			mode: params.contextVisibilityMode,
+			kind: "thread",
+			isSenderAllowed: isThreadSenderAllowed
+		}).items : [];
+		if (parentSummary && visibleParentMessages.length > 0 && shouldInjectParentContext(route.sessionKey, threadParentId)) {
+			core.system.enqueueSystemEvent(formatParentContextEvent(parentSummary), {
+				sessionKey: route.sessionKey,
+				contextKey: `msteams:thread-parent:${params.conversationId}:${threadParentId}`
+			});
+			markParentContextInjected(route.sessionKey, threadParentId);
+		}
+		const allMessages = parentMsg ? [parentMsg, ...replies] : replies;
+		quoteSenderId = parentMsg?.from?.user?.id ?? parentMsg?.from?.application?.id ?? void 0;
+		quoteSenderName = parentMsg?.from?.user?.displayName ?? parentMsg?.from?.application?.displayName ?? params.quoteInfo?.sender;
+		const { items: threadMessages } = (0, openclaw_plugin_sdk_context_visibility_runtime.filterSupplementalContextItems)({
+			items: allMessages,
+			mode: params.contextVisibilityMode,
+			kind: "thread",
+			isSenderAllowed: isThreadSenderAllowed
+		});
+		threadContext = require_messenger.formatThreadContext(threadMessages, activity.id) || void 0;
+	} catch (err) {
+		params.log.debug?.("failed to fetch thread history", { error: require_setup_surface.formatUnknownError(err) });
+	}
+	quoteSenderName ??= params.quoteInfo?.sender;
 	return {
-		activityId: activity.id,
-		user: from ? {
-			id: from.id,
-			name: from.name,
-			aadObjectId: from.aadObjectId
-		} : void 0,
-		agent,
-		conversation: {
-			id: conversationId,
-			conversationType,
-			tenantId
-		},
-		...tenantId ? { tenantId } : {},
-		...aadObjectId ? { aadObjectId } : {},
-		teamId,
-		channelId: activity.channelId,
-		...serviceUrl ? { serviceUrl } : {},
-		locale: activity.locale,
-		...clientInfo?.timezone ? { timezone: clientInfo.timezone } : {},
-		...threadId ? { threadId } : {}
+		teamAadGroupId,
+		quoteBodyFull,
+		quoteSenderId,
+		quoteSenderName,
+		threadContext
 	};
 }
+//#endregion
+//#region extensions/msteams/src/monitor-handler/message-handler.ts
 function createMSTeamsMessageHandler(deps) {
 	const { cfg, runtime, appId, app, tokenProvider, textLimit, mediaMaxBytes, conversationStore, pollStore, log } = deps;
 	const core = require_runtime.getMSTeamsRuntime();
@@ -2151,24 +2917,12 @@ function createMSTeamsMessageHandler(deps) {
 		channel: "msteams"
 	});
 	const handleTeamsMessageNow = async (params) => {
-		const context = params.context;
-		const activity = context.activity;
-		const rawText = params.rawText;
-		const text = params.text;
-		const attachments = params.attachments;
-		const advertisedMedia = resolveMSTeamsAdvertisedMedia(attachments, {
-			maxInlineBytes: mediaMaxBytes,
-			maxInlineTotalBytes: mediaMaxBytes
-		});
-		const rawBody = text;
+		const facts = assembleMSTeamsInboundFacts({
+			entry: params,
+			mediaMaxBytes
+		});
+		const { context, activity, rawText, text, attachments, advertisedMedia, rawBody, quoteInfo, from, conversation, attachmentTypes, htmlSummary, conversationId, conversationMessageId, conversationType, isChannel, teamId, conversationRef } = facts;
 		const historyBody = [text, (0, openclaw_plugin_sdk_channel_inbound.formatMediaPlaceholderText)(advertisedMedia)].filter(Boolean).join("\n");
-		const quoteInfo = require_channel.extractMSTeamsQuoteInfo(attachments);
-		let quoteSenderId;
-		let quoteSenderName;
-		const from = activity.from;
-		const conversation = activity.conversation;
-		const attachmentTypes = attachments.map((att) => typeof att.contentType === "string" ? att.contentType : void 0).filter(Boolean).slice(0, 3);
-		const htmlSummary = summarizeMSTeamsHtmlAttachments(attachments);
 		log.info("received message", {
 			rawText: (0, openclaw_plugin_sdk_text_utility_runtime.truncateUtf16Safe)(rawText, 50),
 			text: (0, openclaw_plugin_sdk_text_utility_runtime.truncateUtf16Safe)(text, 50),
@@ -2182,138 +2936,19 @@ function createMSTeamsMessageHandler(deps) {
 			log.debug?.("skipping message without from.id");
 			return;
 		}
-		const rawConversationId = conversation?.id ?? "";
-		const conversationId = require_channel.normalizeMSTeamsConversationId(rawConversationId);
-		const conversationMessageId = require_channel.extractMSTeamsConversationMessageId(rawConversationId);
-		const conversationType = conversation?.conversationType ?? "personal";
-		const teamId = activity.channelData?.team?.id;
-		const graphChannelId = activity.channelData?.channel?.id?.trim() || conversationId;
-		const conversationRef = buildStoredConversationReference({
-			activity,
-			conversationId,
-			conversationType,
-			teamId,
-			threadId: conversationType === "channel" ? conversationMessageId ?? activity.replyToId ?? void 0 : void 0
-		});
-		const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-			cfg,
-			surface: "msteams"
-		});
-		const isControlCommand = allowTextCommands && core.channel.commands.isControlCommandMessage(text, cfg);
-		const { dmPolicy, senderId, senderName, pairing, isDirectMessage, channelGate, senderAccess, commandAccess, allowNameMatching, groupPolicy } = await resolveMSTeamsSenderAccess({
+		const admission = await admitMSTeamsMessage({
 			cfg,
 			activity,
-			hasControlCommand: isControlCommand
-		});
-		const commandAuthorized = commandAccess.requested ? commandAccess.authorized : void 0;
-		const effectiveDmAllowFrom = senderAccess.effectiveAllowFrom;
-		const effectiveGroupAllowFrom = senderAccess.effectiveGroupAllowFrom;
-		const isChannel = conversationType === "channel";
-		if (isDirectMessage && msteamsCfg && senderAccess.decision !== "allow") {
-			if (senderAccess.reasonCode === "dm_policy_disabled") {
-				log.info("dropping dm (dms disabled)", {
-					sender: senderId,
-					label: senderName
-				});
-				log.debug?.("dropping dm (dms disabled)");
-				return;
-			}
-			const allowMatch = require_channel.resolveMSTeamsAllowlistMatch({
-				allowFrom: effectiveDmAllowFrom,
-				senderId,
-				senderName,
-				allowNameMatching
-			});
-			if (senderAccess.decision === "pairing") {
-				conversationStore.upsert(conversationId, conversationRef).catch((err) => {
-					log.debug?.("failed to save conversation reference", { error: require_setup_surface.formatUnknownError(err) });
-				});
-				if (await pairing.upsertPairingRequest({
-					id: senderId,
-					meta: { name: senderName }
-				})) log.info("msteams pairing request created", {
-					sender: senderId,
-					label: senderName
-				});
-			}
-			log.debug?.("dropping dm (not allowlisted)", {
-				sender: senderId,
-				label: senderName,
-				allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
-			});
-			log.info("dropping dm (not allowlisted)", {
-				sender: senderId,
-				label: senderName,
-				dmPolicy,
-				reason: formatMSTeamsSenderReason({
-					reasonCode: senderAccess.reasonCode,
-					dmPolicy,
-					groupPolicy
-				}),
-				allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
-			});
-			return;
-		}
-		if (!isDirectMessage && msteamsCfg) {
-			if (channelGate.allowlistConfigured && !channelGate.allowed) {
-				log.info("dropping group message (not in team/channel allowlist)", {
-					conversationId,
-					teamKey: channelGate.teamKey ?? "none",
-					channelKey: channelGate.channelKey ?? "none",
-					channelMatchKey: channelGate.channelMatchKey ?? "none",
-					channelMatchSource: channelGate.channelMatchSource ?? "none"
-				});
-				log.debug?.("dropping group message (not in team/channel allowlist)", {
-					conversationId,
-					teamKey: channelGate.teamKey ?? "none",
-					channelKey: channelGate.channelKey ?? "none",
-					channelMatchKey: channelGate.channelMatchKey ?? "none",
-					channelMatchSource: channelGate.channelMatchSource ?? "none"
-				});
-				return;
-			}
-			if (!senderAccess.allowed && senderAccess.reasonCode === "group_policy_disabled") {
-				log.info("dropping group message (groupPolicy: disabled)", { conversationId });
-				log.debug?.("dropping group message (groupPolicy: disabled)", { conversationId });
-				return;
-			}
-			if (!senderAccess.allowed && (senderAccess.reasonCode === "group_policy_empty_allowlist" || senderAccess.reasonCode === "route_sender_empty")) {
-				log.info("dropping group message (groupPolicy: allowlist, no allowlist)", { conversationId });
-				log.debug?.("dropping group message (groupPolicy: allowlist, no allowlist)", { conversationId });
-				return;
-			}
-			if (!senderAccess.allowed && senderAccess.reasonCode === "group_policy_not_allowlisted") {
-				const allowMatch = require_channel.resolveMSTeamsAllowlistMatch({
-					allowFrom: effectiveGroupAllowFrom,
-					senderId,
-					senderName,
-					allowNameMatching
-				});
-				log.debug?.("dropping group message (not in groupAllowFrom)", {
-					sender: senderId,
-					label: senderName,
-					allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
-				});
-				log.info("dropping group message (not in groupAllowFrom)", {
-					sender: senderId,
-					label: senderName,
-					allowlistMatch: (0, openclaw_plugin_sdk_allow_from.formatAllowlistMatchMeta)(allowMatch)
-				});
-				return;
-			}
-		}
-		if (commandAccess.shouldBlockControlCommand) {
-			(0, openclaw_plugin_sdk_channel_inbound.logInboundDrop)({
-				log: logVerboseMessage,
-				channel: "msteams",
-				reason: "control command (unauthorized)",
-				target: senderId
-			});
-			return;
-		}
-		conversationStore.upsert(conversationId, conversationRef).catch((err) => {
-			log.debug?.("failed to save conversation reference", { error: require_setup_surface.formatUnknownError(err) });
+			text,
+			conversationId,
+			conversationRef,
+			isChannel,
+			conversationStore,
+			log,
+			logVerboseMessage
 		});
+		if (!admission) return;
+		const { senderId, senderName, isDirectMessage, channelGate, allowNameMatching, groupPolicy, commandAuthorized, effectiveGroupAllowFrom, allowTextCommands, isControlCommand } = admission;
 		const pollVote = require_polls.extractMSTeamsPollVote(activity);
 		if (pollVote) {
 			try {
@@ -2335,33 +2970,18 @@ function createMSTeamsMessageHandler(deps) {
 			}
 			return;
 		}
-		const mayRecoverGraphMedia = Boolean(htmlSummary?.attachmentIds.length) || shouldAttemptMSTeamsGraphMediaFallback({
-			conversationType,
-			htmlSummary: htmlSummary ?? void 0,
-			graphMediaFallback: msteamsCfg?.graphMediaFallback
-		});
-		if (!rawBody && advertisedMedia.length === 0 && !mayRecoverGraphMedia) {
-			log.debug?.("skipping empty message after stripping mentions");
-			return;
-		}
-		const teamsFrom = isDirectMessage ? `msteams:${senderId}` : isChannel ? `msteams:channel:${conversationId}` : `msteams:group:${conversationId}`;
-		const teamsTo = isDirectMessage ? `user:${senderId}` : `conversation:${conversationId}`;
-		const route = core.channel.routing.resolveAgentRoute({
+		const threadRouting = prepareMSTeamsThreadRouting({
 			cfg,
-			channel: "msteams",
-			teamId,
-			peer: {
-				kind: isDirectMessage ? "direct" : isChannel ? "channel" : "group",
-				id: isDirectMessage ? senderId : conversationId
-			}
-		});
-		route.sessionKey = require_channel.resolveMSTeamsRouteSessionKey({
-			baseSessionKey: route.sessionKey,
+			context,
+			isDirectMessage,
 			isChannel,
-			conversationMessageId,
-			replyToId: activity.replyToId
+			senderId,
+			conversationId,
+			conversationMessageId: conversationMessageId ?? void 0,
+			teamId,
+			log
 		});
-		const preview = (0, openclaw_plugin_sdk_text_utility_runtime.sliceUtf16Safe)(rawBody.replace(/\s+/g, " "), 0, 160);
+		const { route, deadline: preprocessingDeadline } = threadRouting;
 		const inboundLabel = isDirectMessage ? `Teams DM from ${senderName}` : `Teams message in ${conversationType} from ${senderName}`;
 		const enqueuePrimaryMessageSystemEvent = () => core.system.enqueueSystemEvent(inboundLabel, {
 			sessionKey: route.sessionKey,
@@ -2375,7 +2995,7 @@ function createMSTeamsMessageHandler(deps) {
 			teamConfig,
 			channelConfig
 		});
-		const timestamp = require_channel.parseMSTeamsActivityTimestamp(activity.timestamp);
+		const timestamp = require_resolve_allowlist.parseMSTeamsActivityTimestamp(activity.timestamp);
 		const mentionDecision = (0, openclaw_plugin_sdk_channel_inbound.resolveInboundMentionDecision)({
 			facts: {
 				canDetectMention: true,
@@ -2415,379 +3035,66 @@ function createMSTeamsMessageHandler(deps) {
 				return;
 			}
 		}
-		const preprocessingDeadline = require_resolve_allowlist.createMSTeamsInboundDeadline();
-		let teamAadGroupId = activity.channelData?.team?.aadGroupId?.trim() || void 0;
-		const conversationTeamId = isChannel ? teamId : void 0;
-		let teamGroupIdPromise;
-		const resolveChannelTeamGroupId = async () => {
-			if (!conversationTeamId) return;
-			teamGroupIdPromise ??= resolveTeamGroupId({
-				conversationTeamId,
-				aadGroupId: teamAadGroupId,
-				getTeamDetails: context.getTeamDetails,
-				deadline: preprocessingDeadline
-			}).catch((err) => {
-				log.debug?.("failed to resolve Teams AAD group ID", {
-					teamId: conversationTeamId,
-					error: require_setup_surface.formatUnknownError(err)
-				});
-			});
-			teamAadGroupId = await teamGroupIdPromise;
-			return teamAadGroupId;
-		};
-		let mediaList = [];
-		try {
-			mediaList = await require_resolve_allowlist.withMSTeamsRequestDeadline({
-				deadline: preprocessingDeadline,
-				label: "MS Teams inbound media",
-				work: () => resolveMSTeamsInboundMedia({
-					attachments,
-					htmlSummary: htmlSummary ?? void 0,
-					maxBytes: mediaMaxBytes,
-					tokenProvider,
-					allowHosts: msteamsCfg?.mediaAllowHosts,
-					authAllowHosts: msteamsCfg?.mediaAuthAllowHosts,
-					graphMediaFallback: msteamsCfg?.graphMediaFallback,
-					conversationType,
-					conversationId,
-					conversationMessageId: conversationMessageId ?? void 0,
-					teamAadGroupId,
-					resolveTeamAadGroupId: resolveChannelTeamGroupId,
-					serviceUrl: activity.serviceUrl,
-					activity: {
-						id: activity.id,
-						replyToId: activity.replyToId,
-						channelData: activity.channelData
-					},
-					log,
-					deadline: preprocessingDeadline,
-					preserveFilenames: false
-				})
-			});
-		} catch (err) {
-			log.debug?.("failed to resolve inbound Teams media", { error: require_setup_surface.formatUnknownError(err) });
-		}
-		const inboundMedia = mergeMSTeamsMediaFacts(advertisedMedia, mediaList);
-		const agentBody = resolveMSTeamsInboundMediaBody({
-			body: rawBody,
-			nativeMedia: [...advertisedMedia, ...mediaList.slice(advertisedMedia.length).map((media) => ({
-				contentType: media.contentType,
-				kind: media.kind
-			}))],
-			materializedMedia: inboundMedia
-		});
-		if (!agentBody && inboundMedia.length === 0) {
-			log.debug?.("skipping empty message after Graph media recovery");
-			return;
-		}
-		enqueuePrimaryMessageSystemEvent();
-		teamAadGroupId = await resolveChannelTeamGroupId();
-		let quoteBodyFull;
-		const quoteMessageId = quoteInfo?.id;
-		if (quoteMessageId && isDirectMessage && conversationId.startsWith("19:")) try {
-			const graphToken = await require_resolve_allowlist.withMSTeamsRequestDeadline({
-				deadline: preprocessingDeadline,
-				label: "MS Teams quote token",
-				work: () => tokenProvider.getAccessToken("https://graph.microsoft.com")
-			});
-			quoteBodyFull = await require_resolve_allowlist.withMSTeamsRequestDeadline({
-				deadline: preprocessingDeadline,
-				label: "MS Teams quote lookup",
-				work: () => require_messenger.fetchChatMessageText(graphToken, conversationId, quoteMessageId, preprocessingDeadline)
-			});
-		} catch (err) {
-			log.debug?.("failed to fetch full quoted message text", { error: require_setup_surface.formatUnknownError(err) });
-		}
-		let threadContext;
-		const threadParentId = activity.replyToId;
-		const channelGroupId = teamAadGroupId;
-		if (threadParentId && isChannel && channelGroupId) try {
-			const graphToken = await require_resolve_allowlist.withMSTeamsRequestDeadline({
-				deadline: preprocessingDeadline,
-				label: "MS Teams thread token",
-				work: () => tokenProvider.getAccessToken("https://graph.microsoft.com")
-			});
-			const [parentResult, repliesResult] = await require_resolve_allowlist.withMSTeamsRequestDeadline({
-				deadline: preprocessingDeadline,
-				label: "MS Teams thread history",
-				work: () => Promise.allSettled([fetchParentMessageCached(graphToken, channelGroupId, conversationId, threadParentId, (token, groupId, requestedChannelId, messageId) => require_messenger.fetchChannelMessage(token, groupId, requestedChannelId, messageId, preprocessingDeadline)), require_messenger.fetchThreadReplies(graphToken, channelGroupId, conversationId, threadParentId, 50, preprocessingDeadline)])
-			});
-			const parentMsg = parentResult.status === "fulfilled" ? parentResult.value : void 0;
-			const replies = repliesResult.status === "fulfilled" ? repliesResult.value : [];
-			if (parentResult.status === "rejected") log.debug?.("failed to fetch parent message", { error: require_setup_surface.formatUnknownError(parentResult.reason) });
-			if (repliesResult.status === "rejected") log.debug?.("failed to fetch thread replies", { error: require_setup_surface.formatUnknownError(repliesResult.reason) });
-			const isThreadSenderAllowed = (msg) => (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSupplementalSenderAllowed)({
-				isGroup: isChannel,
-				groupPolicy,
-				allowFrom: effectiveGroupAllowFrom,
-				isSenderAllowed: (allowFrom) => require_channel.resolveMSTeamsAllowlistMatch({
-					allowFrom,
-					senderId: msg.from?.user?.id ?? "",
-					senderName: msg.from?.user?.displayName,
-					allowNameMatching
-				}).allowed
-			});
-			const parentSummary = summarizeParentMessage(parentMsg);
-			const visibleParentMessages = parentMsg ? (0, openclaw_plugin_sdk_context_visibility_runtime.filterSupplementalContextItems)({
-				items: [parentMsg],
-				mode: contextVisibilityMode,
-				kind: "thread",
-				isSenderAllowed: isThreadSenderAllowed
-			}).items : [];
-			if (parentSummary && visibleParentMessages.length > 0 && shouldInjectParentContext(route.sessionKey, threadParentId)) {
-				core.system.enqueueSystemEvent(formatParentContextEvent(parentSummary), {
-					sessionKey: route.sessionKey,
-					contextKey: `msteams:thread-parent:${conversationId}:${threadParentId}`
-				});
-				markParentContextInjected(route.sessionKey, threadParentId);
-			}
-			const allMessages = parentMsg ? [parentMsg, ...replies] : replies;
-			quoteSenderId = parentMsg?.from?.user?.id ?? parentMsg?.from?.application?.id ?? void 0;
-			quoteSenderName = parentMsg?.from?.user?.displayName ?? parentMsg?.from?.application?.displayName ?? quoteInfo?.sender;
-			const { items: threadMessages } = (0, openclaw_plugin_sdk_context_visibility_runtime.filterSupplementalContextItems)({
-				items: allMessages,
-				mode: contextVisibilityMode,
-				kind: "thread",
-				isSenderAllowed: isThreadSenderAllowed
-			});
-			const formatted = require_messenger.formatThreadContext(threadMessages, activity.id);
-			if (formatted) threadContext = formatted;
-		} catch (err) {
-			log.debug?.("failed to fetch thread history", { error: require_setup_surface.formatUnknownError(err) });
-		}
-		quoteSenderName ??= quoteInfo?.sender;
-		const envelopeFrom = isDirectMessage ? senderName : conversationType;
-		const buildEnvelope = (0, openclaw_plugin_sdk_channel_inbound.createChannelInboundEnvelopeBuilder)({
-			cfg,
-			route
-		});
-		let combinedBody = buildEnvelope({
-			channel: "Teams",
-			from: envelopeFrom,
-			timestamp,
-			body: agentBody
-		});
-		const isRoomish = !isDirectMessage;
-		const historyKey = isRoomish ? conversationId : void 0;
-		if (isRoomish && historyKey) combinedBody = (0, openclaw_plugin_sdk_reply_history.createChannelHistoryWindow)({ historyMap: conversationHistories }).buildPendingContext({
-			historyKey,
-			limit: historyLimit,
-			currentMessage: combinedBody,
-			formatEntry: (entry) => buildEnvelope({
-				channel: "Teams",
-				from: conversationType,
-				timestamp: entry.timestamp,
-				previousTimestamp: null,
-				body: `${entry.sender}: ${entry.body}${entry.messageId ? ` [id:${entry.messageId}]` : ""}`
-			})
+		const content = await prepareMSTeamsInboundContent({
+			entry: params,
+			rawBody,
+			advertisedMedia,
+			htmlSummary: htmlSummary ?? void 0,
+			conversationType,
+			conversationId,
+			conversationMessageId: conversationMessageId ?? void 0,
+			teamAadGroupId: threadRouting.getTeamAadGroupId(),
+			resolveTeamAadGroupId: threadRouting.resolveTeamAadGroupId,
+			mediaMaxBytes,
+			tokenProvider,
+			mediaAllowHosts: msteamsCfg?.mediaAllowHosts,
+			mediaAuthAllowHosts: msteamsCfg?.mediaAuthAllowHosts,
+			graphMediaFallback: msteamsCfg?.graphMediaFallback,
+			deadline: preprocessingDeadline,
+			log
 		});
-		const inboundHistory = isRoomish && historyKey && historyLimit > 0 ? (0, openclaw_plugin_sdk_reply_history.createChannelHistoryWindow)({ historyMap: conversationHistories }).buildInboundHistory({
-			historyKey,
-			limit: historyLimit
-		}) : void 0;
-		const commandBody = text.trim();
-		const quoteSenderAllowed = quoteInfo && quoteInfo.sender ? (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSupplementalSenderAllowed)({
-			isGroup: !isDirectMessage,
+		if (!content) return;
+		enqueuePrimaryMessageSystemEvent();
+		const thread = await resolveMSTeamsThreadContext({
+			routing: threadRouting,
+			context,
+			tokenProvider,
+			quoteInfo,
+			isDirectMessage,
+			isChannel,
+			conversationId,
+			contextVisibilityMode,
 			groupPolicy,
-			allowFrom: effectiveGroupAllowFrom,
-			isSenderAllowed: (allowFrom) => require_channel.resolveMSTeamsAllowlistMatch({
-				allowFrom,
-				senderId: quoteSenderId ?? "",
-				senderName: quoteSenderName,
-				allowNameMatching
-			}).allowed
-		}) : true;
-		const bodyForAgent = threadContext ? `[Thread history]\n${threadContext}\n[/Thread history]\n\n${agentBody}` : agentBody;
-		const nativeChannelId = isChannel && teamAadGroupId ? `${teamAadGroupId}/${graphChannelId}` : void 0;
-		const ctxPayload = (0, openclaw_plugin_sdk_channel_inbound.buildChannelInboundEventContext)({
-			channel: "msteams",
-			contextVisibility: contextVisibilityMode,
-			supplemental: { quote: quoteInfo ? {
-				id: quoteInfo.id ?? activity.replyToId ?? void 0,
-				body: quoteBodyFull ?? quoteInfo.body,
-				sender: quoteInfo.sender,
-				senderAllowed: quoteSenderAllowed,
-				isQuote: true
-			} : void 0 },
-			media: (0, openclaw_plugin_sdk_channel_inbound.toInboundMediaFacts)(inboundMedia),
-			messageId: activity.id,
-			timestamp: timestamp?.getTime() ?? Date.now(),
-			from: teamsFrom,
-			sender: {
-				id: senderId,
-				name: senderName
-			},
-			conversation: {
-				kind: isDirectMessage ? "direct" : isChannel ? "channel" : "group",
-				id: conversationId,
-				label: envelopeFrom,
-				spaceId: teamId,
-				nativeChannelId
-			},
-			route: {
-				agentId: route.agentId,
-				dmScope: route.dmScope,
-				accountId: route.accountId,
-				routeSessionKey: route.sessionKey
-			},
-			reply: {
-				to: teamsTo,
-				replyToId: activity.replyToId ?? void 0,
-				nativeChannelId
-			},
-			message: {
-				body: combinedBody,
-				bodyForAgent,
-				inboundHistory,
-				rawBody,
-				commandBody
-			},
-			sessionTranscript: { historyLimit: isRoomish ? historyLimit : 0 },
-			access: {
-				mentions: {
-					canDetectMention: !isDirectMessage,
-					wasMentioned: isDirectMessage || mentionDecision.effectiveWasMentioned
-				},
-				commands: { authorized: commandAuthorized === true }
-			},
-			extra: {
-				GroupSubject: !isDirectMessage ? conversationType : void 0,
-				ReplyToIsQuote: quoteInfo ? true : void 0
-			}
+			effectiveGroupAllowFrom,
+			allowNameMatching,
+			log
 		});
-		logVerboseMessage(`msteams inbound: from=${ctxPayload.From} preview="${preview}"`);
-		const sharePointSiteId = msteamsCfg?.sharePointSiteId;
-		const { dispatcherOptions, delivery, replyOptions } = createMSTeamsReplyDispatcher({
+		await dispatchMSTeamsInboundTurn({
 			cfg,
-			agentId: route.agentId,
-			sessionKey: route.sessionKey,
-			accountId: route.accountId,
 			runtime,
-			log,
-			app,
 			appId,
-			conversationRef,
-			context,
-			replyStyle,
-			textLimit,
-			onSentMessageIds: (ids) => {
-				for (const id of ids) recordMSTeamsSentMessage(conversationId, id);
-			},
+			app,
 			tokenProvider,
-			sharePointSiteId
-		});
-		const senderTimezone = (activity.entities?.find((e) => e.type === "clientInfo"))?.timezone || conversationRef.timezone;
-		const turnConfig = senderTimezone && !cfg.agents?.defaults?.userTimezone ? {
-			...cfg,
-			agents: {
-				...cfg.agents,
-				defaults: {
-					...cfg.agents?.defaults,
-					userTimezone: senderTimezone
-				}
-			}
-		} : cfg;
-		log.info("dispatching to agent", { sessionKey: route.sessionKey });
-		try {
-			const turnResult = await core.channel.inbound.run({
-				channel: "msteams",
-				accountId: route.accountId,
-				raw: context,
-				adapter: {
-					ingest: () => ({
-						id: activity.id ?? `${teamsFrom}:${Date.now()}`,
-						timestamp: timestamp?.getTime(),
-						rawText: rawBody,
-						textForAgent: bodyForAgent,
-						textForCommands: commandBody,
-						raw: activity
-					}),
-					resolveTurn: () => ({
-						cfg: turnConfig,
-						channel: "msteams",
-						accountId: route.accountId,
-						route: {
-							agentId: route.agentId,
-							sessionKey: route.sessionKey
-						},
-						ctxPayload,
-						record: { onRecordError: (err) => {
-							logVerboseMessage(`msteams: failed updating session meta: ${require_setup_surface.formatUnknownError(err)}`);
-						} },
-						history: {
-							isGroup: isRoomish,
-							historyKey,
-							historyMap: conversationHistories,
-							limit: historyLimit
-						},
-						dispatcherOptions,
-						delivery,
-						replyOptions: {
-							...replyOptions,
-							...params.turnAdoptionLifecycle ? (0, openclaw_plugin_sdk_channel_outbound.bindIngressLifecycleToReplyOptions)(params.turnAdoptionLifecycle) : {}
-						}
-					})
-				}
-			});
-			const dispatchResult = turnResult.dispatched ? turnResult.dispatchResult : void 0;
-			const queuedFinal = dispatchResult?.queuedFinal ?? false;
-			const counts = (0, openclaw_plugin_sdk_channel_inbound.resolveInboundReplyDispatchCounts)(dispatchResult);
-			const hasFinalResponse = (0, openclaw_plugin_sdk_channel_inbound.hasFinalInboundReplyDispatch)(dispatchResult);
-			log.info("dispatch complete", {
-				queuedFinal,
-				counts
-			});
-			if (!hasFinalResponse) return;
-			const finalCount = counts.final;
-			logVerboseMessage(`msteams: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${teamsTo}`);
-		} catch (err) {
-			log.error("dispatch failed", { error: require_setup_surface.formatUnknownError(err) });
-			runtime.error(`msteams dispatch failed: ${require_setup_surface.formatUnknownError(err)}`);
-			if (params.turnAdoptionLifecycle) throw err;
-			try {
-				await context.sendActivity("⚠️ Something went wrong. Please try again.");
-			} catch {}
-		}
+			textLimit,
+			log,
+			logVerboseMessage,
+			facts,
+			admission,
+			content,
+			routing: threadRouting,
+			thread,
+			replyStyle,
+			timestamp,
+			contextVisibilityMode,
+			mentionWasEffective: mentionDecision.effectiveWasMentioned,
+			conversationHistories,
+			historyLimit
+		});
 	};
-	function buildFlushIngressLifecycle(entries) {
-		const lifecycles = entries.map((entry) => entry.turnAdoptionLifecycle).filter((lifecycle) => lifecycle !== void 0);
-		const [firstLifecycle] = lifecycles;
-		if (!firstLifecycle) return {
-			lifecycle: void 0,
-			settle: async () => {}
-		};
-		let handedOff = false;
-		const adoptAll = async () => {
-			for (const lifecycle of lifecycles) await lifecycle.onAdopted();
-		};
-		return {
-			lifecycle: {
-				abortSignal: lifecycles.length === 1 ? firstLifecycle.abortSignal : AbortSignal.any(lifecycles.map((lifecycle) => lifecycle.abortSignal)),
-				onAdopted: async () => {
-					handedOff = true;
-					await adoptAll();
-				},
-				onDeferred: () => {
-					handedOff = true;
-					for (const lifecycle of lifecycles) lifecycle.onDeferred();
-				},
-				onAdoptionFinalizing: () => {
-					for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
-				},
-				onAbandoned: async () => {
-					handedOff = true;
-					for (const lifecycle of lifecycles) await lifecycle.onAbandoned();
-				}
-			},
-			settle: async () => {
-				if (!handedOff) await adoptAll();
-			}
-		};
-	}
 	const inboundDebouncer = core.channel.debounce.createInboundDebouncer({
 		debounceMs: inboundDebounceMs,
 		buildKey: (entry) => {
-			const conversationId = require_channel.normalizeMSTeamsConversationId(entry.context.activity.conversation?.id ?? "");
+			const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(entry.context.activity.conversation?.id ?? "");
 			const senderId = entry.context.activity.from?.aadObjectId ?? entry.context.activity.from?.id ?? "";
 			if (!senderId || !conversationId) return null;
 			return `msteams:${appId}:${conversationId}:${senderId}`;
@@ -2797,65 +3104,53 @@ function createMSTeamsMessageHandler(deps) {
 			if (entry.attachments.length > 0) return false;
 			return !core.channel.commands.isControlCommandMessage(entry.text, cfg);
 		},
-		onFlush: async (entries) => {
+		onFlush: (entries, createFlush) => {
 			const last = entries.at(-1);
-			if (!last) return;
-			const { lifecycle, settle } = buildFlushIngressLifecycle(entries);
-			try {
-				if (entries.length === 1) await handleTeamsMessageNow(lifecycle ? {
-					...last,
-					turnAdoptionLifecycle: lifecycle
-				} : last);
-				else {
-					const combinedText = entries.map((entry) => entry.text).filter(Boolean).join("\n");
-					if (combinedText.trim()) {
-						const combinedRawText = entries.map((entry) => entry.rawText).filter(Boolean).join("\n");
-						const wasMentioned = entries.some((entry) => entry.wasMentioned);
-						const implicitMentionKinds = entries.flatMap((entry) => entry.implicitMentionKinds);
-						await handleTeamsMessageNow({
-							context: last.context,
-							rawText: combinedRawText,
-							text: combinedText,
-							attachments: [],
-							wasMentioned,
-							implicitMentionKinds,
-							...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {}
+			const { lifecycle, settle } = (0, openclaw_plugin_sdk_channel_ingress_runtime.fanInChannelIngressLifecycles)(entries.map((entry) => entry.turnAdoptionLifecycle));
+			return createFlush({
+				lifecycle,
+				dispatch: async (admissionLifecycle) => {
+					if (!last) return;
+					try {
+						if (entries.length === 1) await handleTeamsMessageNow({
+							...last,
+							turnAdoptionLifecycle: admissionLifecycle
 						});
+						else {
+							const combinedText = entries.map((entry) => entry.text).filter(Boolean).join("\n");
+							if (combinedText.trim()) {
+								const combinedRawText = entries.map((entry) => entry.rawText).filter(Boolean).join("\n");
+								const wasMentioned = entries.some((entry) => entry.wasMentioned);
+								const implicitMentionKinds = entries.flatMap((entry) => entry.implicitMentionKinds);
+								await handleTeamsMessageNow({
+									context: last.context,
+									rawText: combinedRawText,
+									text: combinedText,
+									attachments: [],
+									wasMentioned,
+									implicitMentionKinds,
+									turnAdoptionLifecycle: admissionLifecycle
+								});
+							}
+						}
+						await settle();
+					} catch (err) {
+						await admissionLifecycle.onAbandoned();
+						throw err;
 					}
 				}
-				await settle();
-			} catch (err) {
-				await lifecycle?.onAbandoned();
-				throw err;
-			}
+			});
 		},
 		onError: (err) => {
 			runtime.error(`msteams debounce flush failed: ${require_setup_surface.formatUnknownError(err)}`);
 		}
 	});
 	return async function handleTeamsMessage(context, turnAdoptionLifecycle) {
-		const activity = context.activity;
-		const attachments = Array.isArray(activity.attachments) ? activity.attachments : [];
-		const rawText = activity.text?.trim() ?? "";
-		const htmlText = extractTextFromHtmlAttachments(attachments);
-		const valueText = rawText || htmlText ? "" : serializeMSTeamsAdaptiveCardActionValue(activity.value);
-		const text = require_channel.stripMSTeamsMentionTags(rawText || htmlText || valueText || "");
-		const wasMentioned = require_channel.wasMSTeamsBotMentioned(activity);
-		const conversationId = require_channel.normalizeMSTeamsConversationId(activity.conversation?.id ?? "");
-		const replyToId = activity.replyToId ?? void 0;
-		const implicitMentionKinds = conversationId && replyToId && await wasMSTeamsMessageSentWithPersistence({
-			conversationId,
-			messageId: replyToId
-		}) ? ["reply_to_bot"] : [];
-		await inboundDebouncer.enqueue({
+		const entry = await prepareMSTeamsDebounceEntry({
 			context,
-			rawText,
-			text,
-			attachments,
-			wasMentioned,
-			implicitMentionKinds,
 			turnAdoptionLifecycle
 		});
+		await inboundDebouncer.enqueue(entry);
 		if (turnAdoptionLifecycle) return { kind: "deferred" };
 	};
 }
@@ -2881,7 +3176,7 @@ function createMSTeamsReactionHandler(deps) {
 			log.debug?.("reaction activity missing from.id; skipping");
 			return;
 		}
-		const conversationId = require_channel.normalizeMSTeamsConversationId(activity.conversation?.id ?? "");
+		const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(activity.conversation?.id ?? "");
 		const conversationType = activity.conversation?.conversationType ?? "personal";
 		const isGroupChat = conversationType === "groupChat" || activity.conversation?.isGroup === true;
 		const isChannel = conversationType === "channel";
@@ -3177,7 +3472,7 @@ async function runMSTeamsFeedbackInvokeHandler(context, deps) {
 		userComment = JSON.parse(value.actionValue.feedback).feedbackText || void 0;
 	} catch {}
 	const rawConversationId = activity.conversation?.id ?? "unknown";
-	const conversationId = require_channel.normalizeMSTeamsConversationId(rawConversationId);
+	const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(rawConversationId);
 	const senderId = activity.from?.aadObjectId ?? activity.from?.id ?? "unknown";
 	const messageId = value.replyToId ?? activity.replyToId ?? "unknown";
 	const isNegative = reaction === "dislike";
@@ -3192,7 +3487,7 @@ async function runMSTeamsFeedbackInvokeHandler(context, deps) {
 			id: isDirectMessage ? senderId : conversationId
 		}
 	});
-	const feedbackThreadId = isChannel ? require_channel.extractMSTeamsConversationMessageId(rawConversationId) ?? activity.replyToId ?? void 0 : void 0;
+	const feedbackThreadId = isChannel ? require_resolve_allowlist.extractMSTeamsConversationMessageId(rawConversationId) ?? activity.replyToId ?? void 0 : void 0;
 	if (feedbackThreadId) route.sessionKey = (0, openclaw_plugin_sdk_routing.resolveThreadSessionKeys)({
 		baseSessionKey: route.sessionKey,
 		threadId: feedbackThreadId,
@@ -3274,8 +3569,8 @@ async function handleMSTeamsFileConsentInvoke(context, log) {
 	const fsFile = inMemoryFile ? void 0 : await require_messenger.getPendingUploadFs(uploadId);
 	const pendingFile = inMemoryFile ?? fsFile;
 	if (pendingFile) {
-		const pendingConversationId = require_channel.normalizeMSTeamsConversationId(pendingFile.conversationId);
-		const invokeConversationId = require_channel.normalizeMSTeamsConversationId(activity.conversation?.id ?? "");
+		const pendingConversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(pendingFile.conversationId);
+		const invokeConversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(activity.conversation?.id ?? "");
 		if (!invokeConversationId || pendingConversationId !== invokeConversationId) {
 			log.info("file consent conversation mismatch", {
 				uploadId,
@@ -3370,27 +3665,15 @@ const MSTEAMS_INGRESS_VERSION = 1;
 const MSTEAMS_INGRESS_DRAIN_INTERVAL_MS = 500;
 const MSTEAMS_INGRESS_MAX_CONCURRENT_DELIVERIES = 8;
 const MSTEAMS_INGRESS_SCAN_LIMIT = 100;
-const MSTEAMS_INGRESS_TOMBSTONE_TTL_MS = 720 * 60 * 6e4;
-const MSTEAMS_INGRESS_COMPLETED_MAX_ENTRIES = 2e4;
-const MSTEAMS_INGRESS_FAILED_MAX_ENTRIES = 4096;
-var MSTeamsIngressPayloadError = class extends Error {
-	constructor(reason, message, options) {
-		super(message, options);
-		this.reason = reason;
-		this.name = "MSTeamsIngressPayloadError";
-	}
-};
-function nonEmptyString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : null;
-}
+const MSTeamsIngressPayloadError = (0, openclaw_plugin_sdk_channel_outbound.createChannelIngressError)("MSTeamsIngressPayloadError", { withReason: true });
 function isDispatchableActivity(activity) {
 	return activity.type === "message" || activity.type === "invoke" && activity.name === "adaptiveCard/action";
 }
 function inspectMSTeamsIngressActivity(activity) {
 	if (!isDispatchableActivity(activity)) return null;
-	const eventId = nonEmptyString(activity.id);
+	const eventId = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeNullableString)(activity.id);
 	if (!eventId) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams dispatchable activity is missing activity.id.");
-	const laneKey = nonEmptyString(activity.conversation?.id);
+	const laneKey = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeNullableString)(activity.conversation?.id);
 	if (!laneKey) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams dispatchable activity is missing conversation.id.");
 	return {
 		eventId,
@@ -3449,10 +3732,7 @@ function createMSTeamsIngress(options) {
 		pollIntervalMs: MSTEAMS_INGRESS_DRAIN_INTERVAL_MS,
 		retention: {
 			pruneIntervalMs: 0,
-			completedTtlMs: MSTEAMS_INGRESS_TOMBSTONE_TTL_MS,
-			completedMaxEntries: MSTEAMS_INGRESS_COMPLETED_MAX_ENTRIES,
-			failedTtlMs: MSTEAMS_INGRESS_TOMBSTONE_TTL_MS,
-			failedMaxEntries: MSTEAMS_INGRESS_FAILED_MAX_ENTRIES
+			failedMaxEntries: 4096
 		},
 		appendRetryDelaysMs: [0],
 		waitForDeliveryIdleBeforeRepump: false,
@@ -3564,13 +3844,13 @@ async function monitorMSTeamsProvider(opts) {
 	const configuredAllowFrom = msteamsCfg.allowFrom;
 	const configuredGroupAllowFrom = msteamsCfg.groupAllowFrom;
 	let allowFrom = require_resolve_allowlist.projectStableMSTeamsUserAllowlist(configuredAllowFrom);
-	let groupAllowFrom = require_resolve_allowlist.projectStableMSTeamsUserAllowlist(configuredGroupAllowFrom);
+	let groupAllowFrom = require_resolve_allowlist.projectStableMSTeamsGroupAllowlist(configuredGroupAllowFrom ?? configuredAllowFrom);
 	let teamsConfig = require_resolve_allowlist.projectStableMSTeamsTeamsConfig(msteamsCfg.teams);
 	const allowNameMatching = (0, openclaw_plugin_sdk_dangerous_name_runtime.isDangerousNameMatchingEnabled)(msteamsCfg);
 	const cleanAllowEntry = (entry) => entry.replace(/^(msteams|teams):/i, "").replace(/^user:/i, "").trim();
 	const isStableUserId = (entry) => /^[0-9a-fA-F-]{16,}$/.test(entry);
 	const cleanAllowEntries = (entries) => entries?.map((entry) => cleanAllowEntry(entry)).filter((entry) => entry && entry !== "*") ?? [];
-	const isMutableUserEntry = (entry) => !isStableUserId(entry) && !/^accessGroup:/i.test(entry);
+	const isMutableUserEntry = (entry) => !isStableUserId(entry) && !/^accessGroup:/i.test(entry) && !require_resolve_allowlist.looksLikeMSTeamsConversationId(require_resolve_allowlist.normalizeMSTeamsConversationId(entry));
 	const resolveAllowlistUsers = async (label, entries) => {
 		if (entries.length === 0) return {
 			additions: [],
@@ -3623,6 +3903,10 @@ async function monitorMSTeamsProvider(opts) {
 	} catch (err) {
 		runtime.error?.(`msteams resolve failed; mutable allowlist entries are disabled. ${require_setup_surface.formatUnknownError(err)}`);
 	}
+	if (configuredGroupAllowFrom == null && groupAllowFrom) groupAllowFrom = (0, openclaw_plugin_sdk_allow_from.mergeAllowlist)({
+		existing: groupAllowFrom,
+		additions: allowFrom ?? []
+	});
 	msteamsCfg = {
 		...msteamsCfg,
 		allowFrom,
@@ -3732,8 +4016,8 @@ async function monitorMSTeamsProvider(opts) {
 							value: "Poll not found."
 						};
 					}
-					const pollConversationId = existingPoll.conversationId ? require_channel.normalizeMSTeamsConversationId(existingPoll.conversationId) : void 0;
-					const activityConversationId = require_channel.normalizeMSTeamsConversationId(activity?.conversation?.id ?? "");
+					const pollConversationId = existingPoll.conversationId ? require_resolve_allowlist.normalizeMSTeamsConversationId(existingPoll.conversationId) : void 0;
+					const activityConversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(activity?.conversation?.id ?? "");
 					if (pollConversationId && pollConversationId !== activityConversationId) {
 						log.info("poll vote ignored (conversation mismatch)", {
 							pollId: vote.pollId,
@@ -3965,9 +4249,9 @@ function buildActivityHandler() {
 }
 function createMSTeamsReplayContext(activity, app, serviceUrlBoundary) {
 	const rawConversationId = activity.conversation?.id ?? "";
-	const conversationId = require_channel.normalizeMSTeamsConversationId(rawConversationId);
+	const conversationId = require_resolve_allowlist.normalizeMSTeamsConversationId(rawConversationId);
 	const conversationType = activity.conversation?.conversationType ?? "personal";
-	const threadActivityId = conversationType.toLowerCase() === "channel" ? require_channel.extractMSTeamsConversationMessageId(rawConversationId) ?? activity.replyToId : void 0;
+	const threadActivityId = conversationType.toLowerCase() === "channel" ? require_resolve_allowlist.extractMSTeamsConversationMessageId(rawConversationId) ?? activity.replyToId : void 0;
 	const tenantId = activity.channelData?.tenant?.id ?? activity.conversation?.tenantId;
 	const reference = {
 		activityId: activity.id,