@openclaw/msteams 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/{src-CsXzz0x2.cjs → src-Bz9wY0Mr.cjs}

@@ -1,12 +1,12 @@
-const require_delegated_state = require("./delegated-state-DOSCHaAB.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
 const require_runtime = require("./runtime-gZTAuFux.cjs");
 require("./runtime-api.cjs");
-const require_resolve_allowlist = require("./resolve-allowlist-Dr_1sOJh.cjs");
-const require_channel = require("./channel-DtZFlwhL.cjs");
-const require_setup_surface = require("./setup-surface-xVejKCJV.cjs");
-const require_polls = require("./polls-CWExq2xZ.cjs");
-const require_sso_token_store = require("./sso-token-store-OSg229re.cjs");
-const require_messenger = require("./messenger-BJ0KM2sD.cjs");
+const require_resolve_allowlist = require("./resolve-allowlist-C6YcNC9a.cjs");
+const require_channel = require("./channel-DfCbi0d_.cjs");
+const require_setup_surface = require("./setup-surface-DAhGL2h8.cjs");
+const require_polls = require("./polls-DvuJvaDG.cjs");
+const require_sso_token_store = require("./sso-token-store-ChhO1f4i.cjs");
+const require_messenger = require("./messenger-BqA8G3pY.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");
@@ -15,16 +15,21 @@ let openclaw_plugin_sdk_ssrf_runtime = require("openclaw/plugin-sdk/ssrf-runtime
 let openclaw_plugin_sdk_provider_http = require("openclaw/plugin-sdk/provider-http");
 let openclaw_plugin_sdk_number_runtime = require("openclaw/plugin-sdk/number-runtime");
 let openclaw_plugin_sdk_text_utility_runtime = require("openclaw/plugin-sdk/text-utility-runtime");
+let openclaw_plugin_sdk_error_runtime = require("openclaw/plugin-sdk/error-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_rolldown_runtime.__toESM(node_crypto, 1);
 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_plugin_state_runtime = require("openclaw/plugin-sdk/plugin-state-runtime");
 let openclaw_plugin_sdk_collection_runtime = require("openclaw/plugin-sdk/collection-runtime");
+let openclaw_plugin_sdk_gateway_runtime = require("openclaw/plugin-sdk/gateway-runtime");
 let openclaw_plugin_sdk_channel_pairing = require("openclaw/plugin-sdk/channel-pairing");
 let openclaw_plugin_sdk_account_id = require("openclaw/plugin-sdk/account-id");
 let openclaw_plugin_sdk_runtime_group_policy = require("openclaw/plugin-sdk/runtime-group-policy");
@@ -168,20 +173,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";
@@ -205,47 +240,53 @@ async function resolveMSTeamsSenderAccess(params) {
 		channelName: activity.channelData?.channel?.name,
 		allowNameMatching
 	});
-	return {
-		...await (0, openclaw_plugin_sdk_channel_ingress_runtime.resolveStableChannelMessageIngress)({
-			channelId: "msteams",
-			accountId: pairing.accountId,
-			identity: msteamsIngressIdentity,
-			cfg: params.cfg,
-			readStoreAllowFrom: pairing.readAllowFromStore,
-			subject: {
-				stableId: senderId,
-				aliases: { "sender-name": senderName }
-			},
-			conversation: {
-				kind: isDirectMessage ? "direct" : convType === "channel" ? "channel" : "group",
-				id: conversationId,
-				parentId: activity.channelData?.team?.id
-			},
-			route: (0, openclaw_plugin_sdk_channel_ingress_runtime.channelIngressRoutes)(!isDirectMessage && channelGate.allowlistConfigured && {
-				id: "msteams:team-channel",
-				kind: "nestedAllowlist",
-				allowed: channelGate.allowed,
-				precedence: 0,
-				matchId: "msteams-route",
-				...channelGate.allowed && groupPolicy === "allowlist" ? {
-					senderPolicy: "deny-when-empty",
-					senderAllowFromSource: "effective-group"
-				} : {}
-			}),
-			dmPolicy,
-			groupPolicy,
-			policy: {
-				groupAllowFromFallbackToAllowFrom: true,
-				mutableIdentifierMatching: allowNameMatching ? "enabled" : "disabled"
-			},
-			allowFrom: configuredDmAllowFrom,
-			groupAllowFrom,
-			command: {
-				allowTextCommands: true,
-				hasControlCommand: params.hasControlCommand === true,
-				directGroupAllowFrom: isDirectMessage ? "effective" : "none"
+	const resolved = await (0, openclaw_plugin_sdk_channel_ingress_runtime.resolveStableChannelMessageIngress)({
+		channelId: "msteams",
+		accountId: pairing.accountId,
+		identity: msteamsIngressIdentity,
+		cfg: params.cfg,
+		readStoreAllowFrom: pairing.readAllowFromStore,
+		subject: {
+			stableId: senderId,
+			aliases: {
+				"sender-name": senderName,
+				...!isDirectMessage ? { "conversation-id": conversationId } : {}
 			}
+		},
+		conversation: {
+			kind: isDirectMessage ? "direct" : convType === "channel" ? "channel" : "group",
+			id: conversationId,
+			threadId: params.conversationThreadId
+		},
+		...params.contextBinding ? { contextBinding: params.contextBinding } : {},
+		route: (0, openclaw_plugin_sdk_channel_ingress_runtime.channelIngressRoutes)(!isDirectMessage && channelGate.allowlistConfigured && {
+			id: "msteams:team-channel",
+			kind: "nestedAllowlist",
+			allowed: channelGate.allowed,
+			precedence: 0,
+			matchId: "msteams-route",
+			...channelGate.allowed && groupPolicy === "allowlist" ? {
+				senderPolicy: "deny-when-empty",
+				senderAllowFromSource: "effective-group"
+			} : {}
 		}),
+		dmPolicy,
+		groupPolicy,
+		policy: {
+			groupAllowFromFallbackToAllowFrom: true,
+			mutableIdentifierMatching: allowNameMatching ? "enabled" : "disabled"
+		},
+		allowFrom: configuredDmAllowFrom,
+		groupAllowFrom,
+		command: {
+			allowTextCommands: true,
+			hasControlCommand: params.hasControlCommand === true,
+			directGroupAllowFrom: isDirectMessage ? "effective" : "none"
+		}
+	});
+	return {
+		...resolved,
+		channelIngress: resolved,
 		pairing,
 		isDirectMessage,
 		conversationId,
@@ -258,6 +299,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) {
+			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
 /**
@@ -308,7 +479,7 @@ async function fetchBotFrameworkAttachmentInfo(params) {
 			timeoutMs: require_resolve_allowlist.resolveMSTeamsRequestTimeoutMs(params.deadline)
 		});
 	} catch (err) {
-		params.logger?.warn?.("msteams botFramework attachmentInfo fetch failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams botFramework attachmentInfo fetch failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return;
 	}
 	if (!response.ok) {
@@ -319,7 +490,7 @@ async function fetchBotFrameworkAttachmentInfo(params) {
 	try {
 		return await (0, openclaw_plugin_sdk_provider_http.readProviderJsonResponse)(response, "msteams botFramework attachmentInfo");
 	} catch (err) {
-		params.logger?.warn?.("msteams botFramework attachmentInfo parse failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams botFramework attachmentInfo parse failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return;
 	}
 }
@@ -341,7 +512,7 @@ async function saveBotFrameworkAttachmentView(params) {
 			timeoutMs: require_resolve_allowlist.resolveMSTeamsRequestTimeoutMs(params.deadline)
 		});
 	} catch (err) {
-		params.logger?.warn?.("msteams botFramework attachmentView fetch failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams botFramework attachmentView fetch failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return;
 	}
 	if (!response.ok) {
@@ -354,7 +525,7 @@ async function saveBotFrameworkAttachmentView(params) {
 		contentLength = (0, openclaw_plugin_sdk_media_runtime.parseMediaContentLength)(response.headers.get("content-length"));
 	} catch (err) {
 		await response.body?.cancel().catch(() => void 0);
-		params.logger?.warn?.("msteams botFramework attachmentView invalid content-length", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams botFramework attachmentView invalid content-length", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return;
 	}
 	if (contentLength !== null && contentLength > params.maxBytes) {
@@ -371,7 +542,7 @@ async function saveBotFrameworkAttachmentView(params) {
 			originalFilename: params.preserveFilenames ? params.fileNameHint : void 0
 		});
 	} catch (err) {
-		params.logger?.warn?.("msteams botFramework attachmentView save failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams botFramework attachmentView save failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return;
 	} finally {
 		await response.body?.cancel().catch(() => void 0);
@@ -399,7 +570,7 @@ async function downloadMSTeamsBotFrameworkAttachment(params) {
 			work: () => tokenProvider.getAccessToken(BOT_FRAMEWORK_SCOPE)
 		});
 	} catch (err) {
-		params.logger?.warn?.("msteams botFramework token acquisition failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams botFramework token acquisition failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return;
 	}
 	if (!accessToken) return;
@@ -500,7 +671,7 @@ async function downloadMSTeamsBotFrameworkAttachments(params) {
 			sourceId: attachmentId
 		});
 		params.logger?.warn?.("msteams botFramework attachment download failed", {
-			error: err instanceof Error ? err.message : String(err),
+			error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err),
 			attachmentId
 		});
 	}
@@ -713,9 +884,6 @@ function scopeCandidatesForUrl(url) {
 		return ["https://api.botframework.com", "https://graph.microsoft.com"];
 	}
 }
-function isRedirectStatus(status) {
-	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
 async function resolveInlineDataImageMime(inline) {
 	const mime = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(await require_runtime.getMSTeamsRuntime().media.detectMime({
 		buffer: inline.data,
@@ -738,7 +906,7 @@ async function fetchWithAuthFallback(params) {
 	const tokenProvider = params.tokenProvider;
 	if (firstAttempt.status !== 401 && firstAttempt.status !== 403) return firstAttempt;
 	if (!require_resolve_allowlist.isUrlAllowed(params.url, params.policy.authAllowHosts)) return firstAttempt;
-	await firstAttempt.body?.cancel();
+	let fallbackAttempt = firstAttempt;
 	const scopes = scopeCandidatesForUrl(params.url);
 	const fetchFn = params.fetchFn ?? fetch;
 	for (const scope of scopes) try {
@@ -761,15 +929,11 @@ async function fetchWithAuthFallback(params) {
 			resolveFn: params.resolveFn,
 			timeoutMs: require_resolve_allowlist.resolveMSTeamsRequestTimeoutMs(params.deadline)
 		});
-		if (authAttempt.ok) return authAttempt;
-		if (isRedirectStatus(authAttempt.status)) return authAttempt;
-		if (authAttempt.status !== 401 && authAttempt.status !== 403) {
-			await authAttempt.body?.cancel();
-			continue;
-		}
-		await authAttempt.body?.cancel();
+		await fallbackAttempt.body?.cancel().catch(() => void 0);
+		if (authAttempt.ok || require_resolve_allowlist.isRedirectStatus(authAttempt.status)) return authAttempt;
+		fallbackAttempt = authAttempt;
 	} catch {}
-	return firstAttempt;
+	return fallbackAttempt;
 }
 /**
 * Download all file attachments from a Teams message (images, documents, etc.).
@@ -850,7 +1014,7 @@ async function downloadMSTeamsAttachments(params) {
 				}, candidate.sourceId));
 			} catch (err) {
 				out.push(withSourceId({ kind: candidate.mediaKind }, candidate.sourceId));
-				params.logger?.warn?.("msteams inline attachment decode failed", { error: err instanceof Error ? err.message : String(err) });
+				params.logger?.warn?.("msteams inline attachment decode failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 			}
 			continue;
 		}
@@ -882,7 +1046,7 @@ async function downloadMSTeamsAttachments(params) {
 			out.push(withSourceId(media, candidate.sourceId));
 		} catch (err) {
 			out.push(withSourceId({ kind: candidate.mediaKind }, candidate.sourceId));
-			const msg = err instanceof Error ? err.message : String(err);
+			const msg = (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err);
 			params.logger?.warn?.(`msteams attachment download failed host=${safeHostForLog(candidate.url)} error=${msg}`);
 		}
 	}
@@ -921,6 +1085,10 @@ function buildMSTeamsGraphMessageUrl(params) {
 	if (!chatId) return;
 	return `${require_resolve_allowlist.GRAPH_ROOT}/chats/${encodeURIComponent(chatId)}/messages/${encodeURIComponent(messageId)}`;
 }
+async function releaseGraphResponse(response, release) {
+	if (!response.bodyUsed) response.body?.cancel().catch(() => void 0);
+	await release();
+}
 async function fetchGraphCollection(params) {
 	const fetchFn = params.fetchFn ?? fetch;
 	const { response, release } = await (0, openclaw_plugin_sdk_ssrf_runtime.fetchWithSsrFGuard)({
@@ -949,7 +1117,7 @@ async function fetchGraphCollection(params) {
 			};
 		}
 	} finally {
-		await release();
+		await releaseGraphResponse(response, release);
 	}
 }
 function normalizeGraphAttachment(att) {
@@ -981,7 +1149,7 @@ async function downloadGraphHostedContent(params) {
 			deadline: params.deadline
 		});
 	} catch (err) {
-		params.logger?.warn?.("msteams graph hostedContents fetch failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams graph hostedContents fetch failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return {
 			media: [],
 			count: 0
@@ -1026,11 +1194,11 @@ async function downloadGraphHostedContent(params) {
 					sourceId: item.id
 				});
 			} finally {
-				await release();
+				await releaseGraphResponse(valRes, release);
 			}
 		} catch (err) {
 			out.push(createGraphHostedContentFact(item));
-			params.logger?.warn?.("msteams graph hostedContent value fetch failed", { error: err instanceof Error ? err.message : String(err) });
+			params.logger?.warn?.("msteams graph hostedContent value fetch failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 			continue;
 		}
 	}
@@ -1059,9 +1227,9 @@ async function downloadMSTeamsGraphMedia(params) {
 	} catch (err) {
 		params.logger?.debug?.("graph media token acquisition failed", {
 			messageUrl,
-			error: err instanceof Error ? err.message : String(err)
+			error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)
 		});
-		params.logger?.warn?.("msteams graph token acquisition failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams graph token acquisition failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 		return {
 			media: [],
 			messageUrl,
@@ -1092,10 +1260,10 @@ async function downloadMSTeamsGraphMedia(params) {
 				} catch (err) {
 					params.logger?.debug?.("graph media message parse failed", {
 						messageUrl,
-						error: err instanceof Error ? err.message : String(err)
+						error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)
 					});
 					params.logger?.warn?.("msteams graph message parse failed", {
-						error: err instanceof Error ? err.message : String(err),
+						error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err),
 						messageUrl
 					});
 					msgData = {};
@@ -1107,14 +1275,14 @@ async function downloadMSTeamsGraphMedia(params) {
 				status: messageStatus
 			});
 		} finally {
-			await release();
+			await releaseGraphResponse(msgRes, release);
 		}
 	} catch (err) {
 		params.logger?.debug?.("graph media message fetch failed", {
 			messageUrl,
-			error: err instanceof Error ? err.message : String(err)
+			error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)
 		});
-		params.logger?.warn?.("msteams graph message fetch failed", { error: err instanceof Error ? err.message : String(err) });
+		params.logger?.warn?.("msteams graph message fetch failed", { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err) });
 	}
 	for (const att of referenceAttachments) {
 		const name = att.name ?? "file";
@@ -1180,7 +1348,7 @@ async function downloadMSTeamsGraphMedia(params) {
 		} catch (err) {
 			sharePointMedia.push(unavailableMedia);
 			params.logger?.warn?.("msteams SharePoint reference download failed", {
-				error: err instanceof Error ? err.message : String(err),
+				error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err),
 				name
 			});
 		}
@@ -1219,7 +1387,7 @@ async function downloadMSTeamsGraphMedia(params) {
 		});
 	} catch (err) {
 		params.logger?.warn?.("msteams graph attachment download failed", {
-			error: err instanceof Error ? err.message : String(err),
+			error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err),
 			messageUrl
 		});
 	}
@@ -1237,132 +1405,296 @@ 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 = "";
+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;
+	let replacementFinalPending = false;
+	let replacementEmitFailed = false;
+	let replacementSettlementPending = false;
+	let replacementTextAwaitingAcknowledgement;
+	let deferredReplacementEntries = [];
+	let finalMetadataQueued = false;
+	let failedSegmentFallbackPrepared = false;
+	const streamEvents = stream?.events;
+	let streamChunkSubscription;
+	if (typeof streamEvents?.on === "function" && typeof streamEvents.off === "function") streamChunkSubscription = streamEvents.on("chunk", (activity) => {
+		const replacementAcknowledgementPending = replacementTextAwaitingAcknowledgement !== void 0;
+		const replacementAcknowledgement = typeof activity.text === "string" && replacementAcknowledgementPending && activity.text === replacementTextAwaitingAcknowledgement;
+		if (activity.type !== "typing" || activity.channelData?.streamType !== "streaming" || !activity.id || !activity.text || acknowledgedStreamId !== void 0 && activity.id !== acknowledgedStreamId || (replacementAcknowledgementPending ? !replacementAcknowledgement : !activity.text.startsWith(acknowledgedText)) || !emittedText.startsWith(activity.text)) return;
+		acknowledgedStreamId = activity.id;
+		acknowledgedText = activity.text;
+		if (activity.text === replacementTextAwaitingAcknowledgement) replacementTextAwaitingAcknowledgement = void 0;
+	});
 	const wasCanceled = () => canceledLocally || Boolean(stream?.canceled);
+	const releaseStreamChunkSubscription = () => {
+		if (streamChunkSubscription === void 0) return;
+		streamEvents?.off(streamChunkSubscription);
+		streamChunkSubscription = void 0;
+	};
+	const acknowledgedNativeDelivery = () => {
+		if (!acknowledgedStreamId || !acknowledgedText) return { visibleReplySent: false };
+		return {
+			visibleReplySent: true,
+			content: acknowledgedText,
+			messageId: acknowledgedStreamId
+		};
+	};
+	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,
@@ -1370,6 +1702,35 @@ function createTeamsReplyStreamController(params) {
 			mediaUrls: void 0
 		} : payload;
 	};
+	const finalStreamActivity = (text) => ({
+		type: "message",
+		...text ? { text } : {},
+		entities: [{
+			type: "https://schema.org/Message",
+			"@type": "Message",
+			"@context": "https://schema.org",
+			"@id": "",
+			additionalType: ["AIGeneratedContent"]
+		}],
+		channelData: params.feedbackLoopEnabled ? { feedbackLoopEnabled: true } : {}
+	});
+	const deferredReplacementLogicalContent = () => {
+		return deferredReplacementEntries.map((entry) => entry.payload.text).filter((text) => Boolean(text)).join("\n") || void 0;
+	};
+	const takeDeferredReplacementPayloads = (replacementFallback) => {
+		const payloads = deferredReplacementEntries.flatMap((entry) => {
+			if (entry.kind === "payload") return [entry.payload];
+			const hasMedia = Boolean(entry.payload.mediaUrl || entry.payload.mediaUrls?.length);
+			const text = replacementFallback?.text;
+			if (!text && !hasMedia) return [];
+			return [{
+				...entry.payload,
+				text: text || void 0
+			}];
+		});
+		deferredReplacementEntries = [];
+		return payloads;
+	};
 	/**
 	* Render the current informative status line into the streaming card. Pulls
 	* the rotating "Thinking..." label from msteams config (or the plugin-sdk
@@ -1394,14 +1755,19 @@ function createTeamsReplyStreamController(params) {
 				canceledLocally = true;
 				return;
 			}
-			params.log?.debug?.(`stream informative update failed: ${err instanceof Error ? err.message : String(err)}`);
+			params.log?.debug?.(`stream informative update failed: ${(0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)}`);
 		}
 	};
 	const progressDraftGate = (0, openclaw_plugin_sdk_channel_outbound.createChannelProgressDraftGate)({ onStart: renderInformativeUpdate });
 	return {
 		async onReplyStart() {},
 		onPartialReply(payload) {
-			if (!stream || !payload.text || wasCanceled() || streamMode !== "partial" || streamFinalizationPending) return;
+			if (!stream || !payload.text || wasCanceled() || streamMode !== "partial") return;
+			if (replacementSettlementPending && replacementFinalPending) {
+				pendingFinalPayload = { text: payload.text };
+				return;
+			}
+			if (streamFinalizationPending) return;
 			const fullText = payload.text;
 			let prefixLength = 0;
 			while (prefixLength < emittedText.length && prefixLength < fullText.length && emittedText[prefixLength] === fullText[prefixLength]) prefixLength += 1;
@@ -1410,7 +1776,13 @@ function createTeamsReplyStreamController(params) {
 			if (!delta) return;
 			if (previousRemainder.trim()) {
 				stream.clearText();
-				streamFailed = true;
+				if (streamFailed) {
+					streamFinalizationPending = true;
+					return;
+				}
+				replacementFinalPending = true;
+				replacementSettlementPending = true;
+				pendingFinalPayload = { text: fullText };
 				streamFinalizationPending = true;
 				return;
 			}
@@ -1418,13 +1790,14 @@ function createTeamsReplyStreamController(params) {
 				stream.emit(delta);
 				emittedText = fullText;
 				tokensEmitted = true;
+				nativeDispatchStarted = true;
 			} catch (err) {
 				if (isStreamCancelledError(err)) {
 					canceledLocally = true;
 					return;
 				}
 				streamFailed = true;
-				params.log?.warn?.(`msteams stream emit failed, falling back to block delivery: ${err instanceof Error ? err.message : String(err)}`);
+				params.log?.warn?.(`msteams stream emit failed, falling back to block delivery: ${(0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)}`);
 			}
 		},
 		/**
@@ -1466,6 +1839,49 @@ function createTeamsReplyStreamController(params) {
 		preparePayload(payload) {
 			if (!stream) return payload;
 			if (wasCanceled()) return;
+			if (replacementSettlementPending) {
+				if (!replacementFinalPending) {
+					deferredReplacementEntries.push({
+						kind: "payload",
+						payload
+					});
+					return;
+				}
+				if (!payload.text) {
+					deferredReplacementEntries.push({
+						kind: "payload",
+						payload
+					});
+					return;
+				}
+				replacementFinalPending = false;
+				deferredReplacementEntries.push({
+					kind: "replacement",
+					payload
+				});
+				pendingFinalPayload = fallbackPayloadForSuppressedFinal(payload);
+				try {
+					replacementTextAwaitingAcknowledgement = payload.text;
+					stream.emit(finalStreamActivity(payload.text));
+					finalMetadataQueued = true;
+					emittedText = payload.text;
+					tokensEmitted = false;
+					return;
+				} catch (err) {
+					replacementTextAwaitingAcknowledgement = void 0;
+					tokensEmitted = false;
+					if (isStreamCancelledError(err)) {
+						canceledLocally = true;
+						pendingFinalPayload = void 0;
+						deferredReplacementEntries = [];
+						return;
+					}
+					streamFailed = true;
+					replacementEmitFailed = true;
+					params.log?.warn?.(`msteams stream replacement failed, falling back to block delivery: ${(0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)}`);
+					return;
+				}
+			}
 			if (tokensEmitted && !streamFailed) {
 				const hasMedia = Boolean(payload.mediaUrl || payload.mediaUrls?.length);
 				pendingFinalPayload = fallbackPayloadForSuppressedFinal(payload);
@@ -1476,8 +1892,15 @@ function createTeamsReplyStreamController(params) {
 					text: void 0
 				} : void 0;
 			}
+			if (streamFailed) {
+				const fallback = failedSegmentFallbackPrepared ? payload : fallbackPayloadAfterAcknowledgedText(payload);
+				failedSegmentFallbackPrepared = true;
+				pendingFinalPayload = void 0;
+				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) ? {
@@ -1489,49 +1912,104 @@ function createTeamsReplyStreamController(params) {
 					canceledLocally = true;
 					return;
 				}
-				params.log?.debug?.(`progress-mode finalize failed: ${err instanceof Error ? err.message : String(err)}`);
+				params.log?.debug?.(`progress-mode finalize failed: ${(0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)}`);
 			}
 			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 };
+			}
+			let logicalContent;
 			try {
-				stream.emit({
-					type: "message",
-					entities: finalEntities,
-					channelData: finalChannelData
-				});
+				if (wasCanceled()) {
+					pendingFinalPayload = void 0;
+					deferredReplacementEntries = [];
+					streamFinalizationPending = false;
+					return acknowledgedNativeDelivery();
+				}
+				if (!streamFinalizationPending) return acknowledgedNativeDelivery();
+				if (replacementSettlementPending && replacementFinalPending && pendingFinalPayload?.text) {
+					replacementFinalPending = false;
+					deferredReplacementEntries.push({
+						kind: "replacement",
+						payload: pendingFinalPayload
+					});
+					replacementTextAwaitingAcknowledgement = pendingFinalPayload.text;
+					logicalContent = deferredReplacementLogicalContent();
+					stream.emit(finalStreamActivity(pendingFinalPayload.text));
+					finalMetadataQueued = true;
+					emittedText = pendingFinalPayload.text;
+				}
+				logicalContent ??= replacementSettlementPending ? deferredReplacementLogicalContent() : void 0;
+				const content = pendingFinalPayload?.text ?? (emittedText || void 0);
+				if (!finalMetadataQueued) stream.emit(finalStreamActivity());
 				const result = await stream.close();
 				streamFinalizationPending = false;
 				if (!result) {
 					const fallback = pendingFinalPayload;
 					pendingFinalPayload = void 0;
-					return fallback;
+					const canceled = wasCanceled();
+					const replacementFallback = replacementSettlementPending && fallback && !canceled ? fallbackPayloadAfterAcknowledgedText(fallback) : void 0;
+					const fallbackPayload = !replacementSettlementPending && fallback && !canceled ? fallbackPayloadAfterAcknowledgedText(fallback) : void 0;
+					const postNativePayloads = replacementSettlementPending && !canceled ? takeDeferredReplacementPayloads(replacementFallback) : [];
+					if (canceled) deferredReplacementEntries = [];
+					return {
+						...acknowledgedNativeDelivery(),
+						...!canceled && logicalContent ? { logicalContent } : {},
+						...fallbackPayload ? { fallbackPayload } : {},
+						...postNativePayloads.length > 0 ? { postNativePayloads } : {}
+					};
 				}
+				const replacementFallback = replacementSettlementPending && replacementEmitFailed && pendingFinalPayload ? fallbackPayloadAfterAcknowledgedText(pendingFinalPayload) : void 0;
 				pendingFinalPayload = void 0;
-				return;
+				const messageId = require_messenger.extractMessageId(result) ?? acknowledgedStreamId;
+				const postNativePayloads = replacementSettlementPending ? takeDeferredReplacementPayloads(replacementFallback) : [];
+				const nativeContent = replacementEmitFailed ? acknowledgedText || void 0 : content;
+				return {
+					visibleReplySent: replacementEmitFailed ? Boolean(nativeContent) : true,
+					...nativeContent === void 0 ? {} : { content: nativeContent },
+					...logicalContent ? { logicalContent } : {},
+					...messageId && (!replacementEmitFailed || nativeContent) ? { messageId } : {},
+					...postNativePayloads.length > 0 ? { postNativePayloads } : {}
+				};
 			} catch (err) {
 				if (isStreamCancelledError(err)) {
 					canceledLocally = true;
 					pendingFinalPayload = void 0;
+					deferredReplacementEntries = [];
 					streamFinalizationPending = false;
-					return;
+					return acknowledgedNativeDelivery();
 				}
 				streamFailed = true;
 				streamFinalizationPending = false;
-				params.log?.warn?.(`msteams stream finalize failed: ${err instanceof Error ? err.message : String(err)}`);
+				params.log?.warn?.(`msteams stream finalize failed: ${(0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(err)}`);
 				const fallback = pendingFinalPayload;
 				pendingFinalPayload = void 0;
-				return fallback;
+				const replacementFallback = replacementSettlementPending && fallback ? fallbackPayloadAfterAcknowledgedText(fallback) : void 0;
+				const fallbackPayload = !replacementSettlementPending && fallback ? fallbackPayloadAfterAcknowledgedText(fallback) : void 0;
+				const postNativePayloads = replacementSettlementPending ? takeDeferredReplacementPayloads(replacementFallback) : [];
+				return {
+					...acknowledgedNativeDelivery(),
+					...logicalContent ? { logicalContent } : {},
+					...fallbackPayload ? { fallbackPayload } : {},
+					...postNativePayloads.length > 0 ? { postNativePayloads } : {}
+				};
+			} finally {
+				finalMetadataQueued = false;
+				replacementEmitFailed = false;
+				replacementFinalPending = false;
+				replacementSettlementPending = false;
+				replacementTextAwaitingAcknowledgement = void 0;
+				deferredReplacementEntries = [];
+				releaseStreamChunkSubscription();
 			}
 		},
 		hasStream() {
@@ -1616,7 +2094,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 +2110,8 @@ 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 joinAcceptedContents = (contents) => contents.filter((content) => Boolean(content)).join("\n");
 	const sendMessages = async (messages) => {
 		return require_messenger.sendMSTeamsMessages({
 			replyStyle: params.replyStyle,
@@ -1669,33 +2150,74 @@ 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 acceptedParts = [...delivery.nativeResult ? [delivery.nativeResult] : [], ...delivery.blockResults];
+		const messageIds = acceptedParts.flatMap((part) => part.messageIds);
+		const content = delivery.errors.length > 0 ? joinAcceptedContents(acceptedParts.map((part) => part.content)) : delivery.content;
+		return {
+			visibleReplySent: acceptedParts.length > 0,
+			...messageIds.length > 0 ? { messageIds } : {},
+			...acceptedParts.length > 0 && content !== void 0 ? { 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(outcome.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,
+			blockResults: [],
+			native,
+			nativeSettled: !native,
+			blockSettled: messages.length === 0,
+			settled: false,
+			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);
+				const validIds = msgIds.filter((id) => id.trim() && id !== "unknown");
+				if (msgIds.length > 0) delivery.blockResults.push({
+					messageIds: validIds,
+					...msg.text ? { content: msg.text } : {}
+				});
+				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 +2231,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 +2250,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,37 +2280,53 @@ 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;
+		}
+		if (nativeResult.visibleReplySent) nativeDelivery.nativeResult = {
+			messageIds: nativeResult.messageId ? [nativeResult.messageId] : [],
+			...nativeResult.content !== void 0 ? { content: nativeResult.content } : {}
+		};
+		const hasPostNativePayloads = Boolean(nativeResult.postNativePayloads?.length);
+		if (nativeResult.logicalContent !== void 0) nativeDelivery.content = nativeResult.logicalContent;
+		else if (nativeResult.content !== void 0 && (!nativeResult.fallbackPayload && !hasPostNativePayloads || nativeDelivery.content === void 0)) nativeDelivery.content = nativeResult.content;
+		const afterNativePayloads = [...nativeResult.fallbackPayload ? [nativeResult.fallbackPayload] : [], ...nativeResult.postNativePayloads ?? []];
+		if (afterNativePayloads.length > 0) {
+			nativeDelivery.messages.push(...afterNativePayloads.flatMap((payload) => renderReplyPayload(payload)));
+			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;
-			if (!text) return;
+			if (!text) return false;
 			if (payload?.isReasoningSnapshot !== true) {
 				await streamController.pushProgressLine(text);
-				return;
+				return false;
 			}
 			await streamController.pushProgressLine((0, openclaw_plugin_sdk_channel_outbound.buildChannelProgressDraftLine)({
 				event: "item",
@@ -1780,6 +2335,7 @@ function createMSTeamsReplyDispatcher(params) {
 				title: "Reasoning",
 				progressText: text
 			}));
+			return false;
 		},
 		onToolStart: async (payload) => {
 			const name = typeof payload?.name === "string" ? payload.name : void 0;
@@ -1792,6 +2348,7 @@ function createMSTeamsReplyDispatcher(params) {
 				...typeof payload?.phase === "string" ? { phase: payload.phase } : {},
 				...payload?.args && typeof payload.args === "object" ? { args: payload.args } : {}
 			}, detailMode === "explain" || detailMode === "raw" ? { detailMode } : void 0), name ? { toolName: name } : void 0);
+			return false;
 		},
 		onItemEvent: async (payload) => {
 			await streamController.pushProgressLine((0, openclaw_plugin_sdk_channel_outbound.buildChannelProgressDraftLineForEntry)(msteamsCfg, {
@@ -1807,13 +2364,15 @@ function createMSTeamsReplyDispatcher(params) {
 				...typeof payload?.progressText === "string" ? { progressText: payload.progressText } : {},
 				...typeof payload?.meta === "string" ? { meta: payload.meta } : {}
 			}));
+			return false;
 		},
 		onPlanUpdate: async (payload) => {
-			if (payload?.phase !== "update") return;
+			if (payload?.phase !== "update") return false;
 			await streamController.pushPlanProgress((0, openclaw_plugin_sdk_channel_outbound.normalizeAgentPlanSteps)(payload.steps), { explanation: typeof payload.explanation === "string" ? payload.explanation : void 0 });
+			return false;
 		},
 		onApprovalEvent: async (payload) => {
-			if (payload?.phase !== "requested") return;
+			if (payload?.phase !== "requested") return false;
 			await streamController.pushProgressLine((0, openclaw_plugin_sdk_channel_outbound.buildChannelProgressDraftLine)({
 				event: "approval",
 				phase: payload.phase,
@@ -1822,10 +2381,11 @@ function createMSTeamsReplyDispatcher(params) {
 				...typeof payload?.reason === "string" ? { reason: payload.reason } : {},
 				...typeof payload?.message === "string" ? { message: payload.message } : {}
 			}));
+			return false;
 		},
 		onCommandOutput: async (payload) => {
-			if (payload?.phase !== "end") return;
-			await streamController.pushProgressLine((0, openclaw_plugin_sdk_channel_outbound.buildChannelProgressDraftLine)({
+			if (payload?.phase !== "end") return false;
+			await streamController.pushProgressLine((0, openclaw_plugin_sdk_channel_outbound.buildChannelProgressDraftLineForEntry)(msteamsCfg, {
 				event: "command-output",
 				...typeof payload?.itemId === "string" ? { itemId: payload.itemId } : {},
 				...typeof payload?.toolCallId === "string" ? { toolCallId: payload.toolCallId } : {},
@@ -1835,9 +2395,10 @@ function createMSTeamsReplyDispatcher(params) {
 				...typeof payload?.status === "string" ? { status: payload.status } : {},
 				...typeof payload?.exitCode === "number" ? { exitCode: payload.exitCode } : {}
 			}));
+			return false;
 		},
 		onPatchSummary: async (payload) => {
-			if (payload?.phase !== "end") return;
+			if (payload?.phase !== "end") return false;
 			await streamController.pushProgressLine((0, openclaw_plugin_sdk_channel_outbound.buildChannelProgressDraftLine)({
 				event: "patch",
 				...typeof payload?.itemId === "string" ? { itemId: payload.itemId } : {},
@@ -1850,6 +2411,7 @@ function createMSTeamsReplyDispatcher(params) {
 				...Array.isArray(payload?.deleted) && payload.deleted.every((s) => typeof s === "string") ? { deleted: payload.deleted } : {},
 				...typeof payload?.summary === "string" ? { summary: payload.summary } : {}
 			}));
+			return false;
 		}
 	} : {};
 	return {
@@ -1859,7 +2421,10 @@ function createMSTeamsReplyDispatcher(params) {
 		},
 		delivery,
 		replyOptions: {
-			...streamController.hasStream() ? { onPartialReply: (payload) => streamController.onPartialReply(payload) } : {},
+			...streamController.hasStream() ? { onPartialReply: (payload) => {
+				streamController.onPartialReply(payload);
+				return false;
+			} } : {},
 			...progressCallbacks,
 			...shouldSuppressDefaultToolProgressMessages ? { suppressDefaultToolProgressMessages: true } : {},
 			disableBlockStreaming: blockStreamingResolved == null ? void 0 : !blockStreamingResolved,
@@ -1877,14 +2442,7 @@ const sentMessages = (0, openclaw_plugin_sdk_dedupe_runtime.createPersistentDedu
 		namespace: "msteams.sent-messages",
 		maxEntries: 1e3,
 		openStore: (options) => require_runtime.getOptionalMSTeamsRuntime()?.state.openKeyedStore(options),
-		logError: (error) => {
-			try {
-				require_runtime.getOptionalMSTeamsRuntime()?.logging.getChildLogger({
-					plugin: "msteams",
-					feature: "sent-message-state"
-				}).warn("Microsoft Teams persistent sent-message state failed", { error: String(error) });
-			} catch {}
-		},
+		logError: (0, openclaw_plugin_sdk_plugin_state_runtime.createPluginStateErrorReporter)(require_runtime.getOptionalMSTeamsRuntime, "msteams", "sent-message-state", "Microsoft Teams persistent sent-message state failed"),
 		readTimestamp: (record) => record.sentAt
 	}
 });
@@ -1901,21 +2459,351 @@ 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);
+//#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
+	});
+	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 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 boundIngress = await resolveMSTeamsSenderAccess({
+		cfg,
+		activity,
+		hasControlCommand: admission.isControlCommand,
+		conversationThreadId: facts.threadId,
+		contextBinding: {
+			agentId: route.agentId,
+			sessionKey: route.sessionKey,
+			...activity.id ? { messageId: activity.id } : {},
+			...nativeChannelId ? { nativeChannelId } : {},
+			inboundEventKind: "user_request"
+		}
+	});
+	const ctxPayload = core.channel.inbound.buildContext({
+		channelIngress: boundIngress.channelIngress,
+		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,
+			originatingTo: `conversation:${conversationId}`,
+			messageThreadId: facts.threadId ?? void 0,
+			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
+		}
+	});
+	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,
+		sharePointSiteId: cfg.channels?.msteams?.sharePointSiteId
+	});
+	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" };
+	}
+}
+//#endregion
+//#region extensions/msteams/src/monitor-handler/inbound-facts.ts
+function extractTextFromHtmlAttachments(attachments) {
+	for (const attachment of attachments) {
+		const raw = require_resolve_allowlist.extractHtmlFromAttachment(attachment);
+		if (!raw) continue;
+		const text = raw.replace(/<at[^>]*>.*?<\/at>/gis, " ").replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gis, "$2 $1").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/\s+/g, " ").trim();
+		if (text) return text;
+	}
+	return "";
+}
+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;
@@ -1929,210 +2817,229 @@ async function resolveTeamGroupId(params) {
 	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;
+//#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 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 buildParentCacheKey(groupId, channelId, parentId) {
+	return `${groupId}\u0000${channelId}\u0000${parentId}`;
 }
-function hasDefinitiveContentType(media) {
-	const contentType = media.contentType?.split(";", 1)[0]?.trim().toLowerCase();
-	return Boolean(contentType && contentType !== "application/octet-stream" && contentType !== "binary/octet-stream");
+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 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
-			};
-		}
+/**
+* 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;
 	}
-	return merged;
+	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;
 }
-function hasMaterializedMedia(media) {
-	return media.some((entry) => Boolean(entry.path));
+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
+	};
 }
-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
-				});
-			}
+/**
+* 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
 		}
-	}
-	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;
+	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
+	};
 }
-//#endregion
-//#region extensions/msteams/src/monitor-handler/message-handler.ts
-function extractTextFromHtmlAttachments(attachments) {
-	for (const attachment of attachments) {
-		const raw = require_resolve_allowlist.extractHtmlFromAttachment(attachment);
-		if (!raw) continue;
-		const text = raw.replace(/<at[^>]*>.*?<\/at>/gis, " ").replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gis, "$2 $1").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/\s+/g, " ").trim();
-		if (text) return text;
+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) });
 	}
-	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;
+	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) });
 	}
-}
-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);
+	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 +3058,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 +3077,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 +3111,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 +3136,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,344 +3176,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
+		});
 	};
 	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}`;
@@ -2762,65 +3245,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 } = (0, openclaw_plugin_sdk_channel_ingress_runtime.fanInChannelIngressLifecycles)(entries.map((entry) => entry.turnAdoptionLifecycle));
-			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 } : {}
+			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" };
 	};
 }
@@ -2846,7 +3317,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";
@@ -3142,7 +3613,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";
@@ -3157,7 +3628,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,
@@ -3239,8 +3710,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,
@@ -3330,32 +3801,38 @@ async function runMSTeamsFileConsentInvokeHandler(context, log) {
 	}
 }
 //#endregion
+//#region extensions/msteams/src/monitor-status.ts
+function publishMSTeamsBlocked(statusSink, lastError) {
+	statusSink?.((0, openclaw_plugin_sdk_gateway_runtime.channelBlockedPatch)(lastError, { running: true }));
+}
+function publishMSTeamsReady(statusSink, now = Date.now()) {
+	statusSink?.((0, openclaw_plugin_sdk_gateway_runtime.channelReadyPatch)({ lastConnectedAt: now }));
+}
+function publishMSTeamsRecovering(statusSink, lastError) {
+	statusSink?.({
+		connected: false,
+		lifecycle: "recovering",
+		lastError
+	});
+}
+function publishMSTeamsStopped(statusSink) {
+	statusSink?.((0, openclaw_plugin_sdk_gateway_runtime.channelStoppedPatch)());
+}
+//#endregion
 //#region extensions/msteams/src/msteams-ingress.ts
 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,
@@ -3377,9 +3854,6 @@ function parseClaimedActivity(payload, claimedId) {
 	if (facts.eventId !== claimedId) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams activity id changed after durable admission.");
 	return parsed;
 }
-function errorText(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 function createMSTeamsIngress(options) {
 	const queue = options.queue ?? require_runtime.getMSTeamsRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
 	const liveContexts = /* @__PURE__ */ new Map();
@@ -3414,10 +3888,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,
@@ -3433,13 +3904,13 @@ function createMSTeamsIngress(options) {
 				};
 				return require_setup_surface.classifyMSTeamsSendError(error).kind === "auth" ? {
 					reason: "authentication-failed",
-					message: errorText(error)
+					message: (0, openclaw_plugin_sdk_error_runtime.formatErrorMessage)(error)
 				} : null;
 			},
 			onLog: (message) => options.runtime.error?.(`msteams: ${message}`)
 		},
 		createStoppedError: () => /* @__PURE__ */ new Error("Microsoft Teams ingress stopped."),
-		onError: (error) => options.runtime.error?.(`msteams ingress drain failed: ${errorText(error)}`)
+		onError: (error) => options.runtime.error?.(`msteams ingress drain failed: ${(0, openclaw_plugin_sdk_error_runtime.formatErrorMessage)(error)}`)
 	});
 	let stopTask;
 	return {
@@ -3505,6 +3976,7 @@ async function monitorMSTeamsProvider(opts) {
 	let msteamsCfg = cfg.channels?.msteams;
 	if (!msteamsCfg?.enabled) {
 		log.debug?.("msteams provider disabled");
+		publishMSTeamsBlocked(opts.statusSink, "Microsoft Teams provider is disabled");
 		return {
 			app: null,
 			shutdown: async () => {}
@@ -3513,6 +3985,7 @@ async function monitorMSTeamsProvider(opts) {
 	const creds = require_resolve_allowlist.resolveMSTeamsCredentials(msteamsCfg);
 	if (!creds) {
 		log.error("msteams credentials not configured");
+		publishMSTeamsBlocked(opts.statusSink, "Microsoft Teams credentials are not configured");
 		return {
 			app: null,
 			shutdown: async () => {}
@@ -3529,13 +4002,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: [],
@@ -3588,6 +4061,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,
@@ -3603,9 +4080,10 @@ async function monitorMSTeamsProvider(opts) {
 	};
 	const port = msteamsCfg.webhook?.port ?? 3978;
 	const textLimit = core.channel.text.resolveTextChunkLimit(cfg, "msteams");
-	const MB = 1024 * 1024;
-	const agentDefaults = cfg.agents?.defaults;
-	const mediaMaxBytes = typeof agentDefaults?.mediaMaxMb === "number" && agentDefaults.mediaMaxMb > 0 ? Math.floor(agentDefaults.mediaMaxMb * MB) : 8 * MB;
+	const mediaMaxBytes = (0, openclaw_plugin_sdk_media_runtime.resolveChannelMediaMaxBytes)({
+		cfg,
+		resolveChannelLimitMb: ({ cfg: channelCfg }) => channelCfg.channels?.msteams?.mediaMaxMb
+	}) ?? 8 * 1024 * 1024;
 	const conversationStore = opts.conversationStore ?? require_polls.createMSTeamsConversationStoreState();
 	const pollStore = opts.pollStore ?? require_polls.createMSTeamsPollStoreState();
 	log.info(`starting provider (port ${port})`);
@@ -3697,8 +4175,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,
@@ -3852,17 +4330,21 @@ async function monitorMSTeamsProvider(opts) {
 	});
 	await app.initialize();
 	ingress.start();
+	const privateQaRuntime = require_resolve_allowlist.resolveMSTeamsPrivateQaRuntime();
 	const httpServer = await new Promise((resolve, reject) => {
-		const server = expressApp.listen(port, (err) => err ? reject(err) : resolve(server));
+		const onListen = (err) => err ? reject(err) : resolve(server);
+		const server = privateQaRuntime ? expressApp.listen(port, privateQaRuntime.listenHost, onListen) : expressApp.listen(port, onListen);
 	}).catch(async (err) => {
 		log.error("msteams server error", { error: require_setup_surface.formatUnknownError(err) });
 		await ingress.stop();
 		throw err;
 	});
 	log.info(`msteams provider started on port ${port}`);
+	publishMSTeamsReady(opts.statusSink);
 	applyMSTeamsWebhookTimeouts(httpServer);
 	httpServer.on("error", (err) => {
 		log.error("msteams server error", { error: require_setup_surface.formatUnknownError(err) });
+		publishMSTeamsRecovering(opts.statusSink, require_setup_surface.formatUnknownError(err));
 	});
 	const shutdown = async () => {
 		log.info("shutting down msteams provider");
@@ -3873,6 +4355,7 @@ async function monitorMSTeamsProvider(opts) {
 			});
 		});
 		await ingress.stop();
+		publishMSTeamsStopped(opts.statusSink);
 	};
 	await (0, openclaw_plugin_sdk_channel_outbound.keepHttpServerTaskAlive)({
 		server: httpServer,
@@ -3930,9 +4413,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,