@openclaw/slack 2026.7.1 → 2026.7.2-beta.2

package/dist/{pipeline.runtime-rpVpay59.js → pipeline.runtime-DofAvTtb.js}

@@ -1,33 +1,33 @@
 import { u as resolveSlackReplyToMode } from "./accounts-BOJJiHSr.js";
-import { r as parseSlackTarget } from "./target-parsing-3jYH8LfB.js";
-import "./targets-Dll4NJgs.js";
-import { a as SLACK_TEXT_LIMIT, b as truncateSlackText, c as formatSlackError, d as normalizeAllowListLower, f as normalizeSlackAllowOwnerEntry, m as resolveSlackAllowListMatch } from "./reply-blocks-BGQ6zSqM.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-CXpT-vA_.js";
-import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-DjlgH-Be.js";
-import { c as recordSlackThreadParticipation, r as sendMessageSlack, s as hasSlackThreadParticipationWithPersistence } from "./send-DKDXoeoV.js";
-import { C as buildSlackEditTextPayload, S as formatSlackFileReference, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, y as chooseSlackPrimaryText } from "./actions-DMpDmKEA.js";
-import { n as normalizeSlackOutboundText } from "./format-YCNoNkM2.js";
-import { C as stripSlackMentionsForCommandDetection, _ as readSessionUpdatedAt, b as resolveStorePath, c as recordInboundSession, d as resolveSlackCommandIngress, f as resolveSlackEffectiveAllowFrom, g as resolveSlackChatType, h as normalizeSlackChannelType, i as authorizeSlackDirectMessage, l as resolveConversationLabel$1, m as parseSlackAssistantThreadMetadata, p as buildSlackAssistantThreadMetadata, r as resolveSlackRoomContextHints, s as escapeSlackMrkdwn, u as authorizeSlackBotRoomMessage, v as resolveChannelContextVisibilityMode, x as updateLastRoute, y as resolveChannelResetConfig } from "./provider-C1-DFSpw.js";
-import { n as resolveSlackChannelConfig } from "./policy-Dj-puVPb.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-DpF38e1y.js";
+import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
+import "./targets-KmjP2E8s.js";
+import { A as buildSlackBlocksFallbackText, B as truncateSlackText, I as SLACK_TEXT_LIMIT, P as SLACK_EDIT_TEXT_LIMIT, c as normalizeAllowListLower, d as resolveSlackAllowListMatch, i as formatSlackError, k as normalizeSlackOutboundText, l as normalizeSlackAllowOwnerEntry, q as escapeSlackMrkdwn, v as resolveSlackReplyRenderPlan, w as hasSlackNativeDataBlock } from "./group-policy-85UWiriS.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-BilWUdcI.js";
+import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-3_X-21wW.js";
+import { S as buildSlackEditTextPayload, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, x as formatSlackFileReference, y as chooseSlackPrimaryText } from "./actions-BZiuSTIq.js";
+import { c as recordSlackThreadParticipation, l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, s as hasSlackThreadParticipationWithPersistence } from "./send-DYp8ca-l.js";
+import { S as updateLastRoute, _ as resolveSlackChatType, b as resolveChannelResetConfig, d as authorizeSlackBotRoomMessage, f as resolveSlackCommandIngress, g as normalizeSlackChannelType, h as parseSlackAssistantThreadMetadata, l as recordInboundSession, m as buildSlackAssistantThreadMetadata, o as authorizeSlackDirectMessage, p as resolveSlackEffectiveAllowFrom, r as resolveSlackRoomContextHints, u as resolveConversationLabel$1, v as readSessionUpdatedAt, w as stripSlackMentionsForCommandDetection, x as resolveStorePath, y as resolveChannelContextVisibilityMode } from "./provider-CmeoUiIM.js";
+import { n as resolveSlackChannelConfig } from "./policy-BVs4LiSa.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-CJJCp6qz.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftGate, createDraftStreamLoop, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, isChannelProgressDraftWorkToolName, mergeChannelProgressDraftLine, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelProgressDraftMaxLines, resolveChannelProgressDraftRender, resolveChannelStreamingBlockEnabled, resolveChannelStreamingNativeTransport, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftGate, createDraftStreamLoop, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, mergeChannelProgressDraftLine, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelProgressDraftMaxLines, resolveChannelProgressDraftRender, resolveChannelStreamingBlockEnabled, resolveChannelStreamingNativeTransport, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingProgressCommentary, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { danger, logVerbose, shouldLogVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
 import { stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundReply, formatInboundEnvelope, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundReply, formatInboundEnvelope, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
 import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, removeAckReactionAfterReply, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { dispatchReplyWithBufferedBlockDispatcher } from "openclaw/plugin-sdk/reply-runtime";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
@@ -69,6 +69,7 @@ function createSlackDraftStream(params) {
 					cfg: params.cfg,
 					token: params.token,
 					accountId: params.accountId,
+					...params.eventScope ? { client: params.eventScope.client } : {},
 					...blocks ? { blocks } : {}
 				});
 				return;
@@ -79,6 +80,10 @@ function createSlackDraftStream(params) {
 				accountId: params.accountId,
 				threadTs: params.resolveThreadTs?.(),
 				identity: params.identity,
+				...params.eventScope ? {
+					client: params.eventScope.client,
+					enterpriseEventScope: params.eventScope
+				} : {},
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
@@ -120,7 +125,8 @@ function createSlackDraftStream(params) {
 		try {
 			await remove(channelId, messageId, {
 				token: params.token,
-				accountId: params.accountId
+				accountId: params.accountId,
+				...params.eventScope ? { client: params.eventScope.client } : {}
 			});
 		} catch (err) {
 			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
@@ -215,6 +221,11 @@ function stableTaskIdPart(value) {
 	return `${slugTaskIdPart(value)}_${suffix}`;
 }
 function buildPlanTasks(params) {
+	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
+		id: `plan_step_${index + 1}`,
+		title: compactTitle(entry.step),
+		status: entry.status === "completed" ? "complete" : entry.status
+	}));
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
 	return params.lines.slice(-50).map((line, index) => ({
 		id: line.id ? stableTaskIdPart(line.id) : `${slugTaskIdPart(line.toolName ?? line.kind ?? line.label)}_${index + 1}`,
@@ -228,6 +239,7 @@ function resolvePlanTitle(params) {
 function buildSlackProgressStreamChunks(params) {
 	const tasks = buildPlanTasks({
 		lines: params.lines,
+		plan: params.plan,
 		maxLineChars: params.maxLineChars
 	});
 	if (tasks.length === 0) return;
@@ -248,15 +260,63 @@ function buildSlackProgressStreamChunks(params) {
 function buildSlackProgressDraftBlocks(params) {
 	const label = params.label?.trim() || params.title?.trim();
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS);
-	const renderedBlocks = [...label ? [{
-		type: "section",
-		text: field(`*${escapeSlackMrkdwn(label)}*`)
-	}] : [], ...params.lines.map((line) => ({
+	const planLines = formatPlanChecklistLines(params.plan ?? [], {
+		maxLines: 50,
+		maxLineChars
+	});
+	const narration = params.narration?.replace(/\s+/g, " ").trim();
+	const headBlocks = [
+		...label ? [{
+			type: "section",
+			text: field(`*${escapeSlackMrkdwn(label)}*`)
+		}] : [],
+		...narration ? [{
+			type: "section",
+			text: field(`_${escapeSlackMrkdwn(narration)}_`)
+		}] : [],
+		...planLines.length > 0 ? [{
+			type: "section",
+			text: field(planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"))
+		}] : []
+	].slice(0, 50);
+	const lineBudget = Math.max(0, 50 - headBlocks.length);
+	const renderedBlocks = [...headBlocks, ...params.lines.slice(-lineBudget).map((line) => ({
 		type: "section",
 		fields: [field(legacyLineTitle(line)), field(legacyLineDetail(line, maxLineChars))]
-	}))].slice(-50);
+	}))];
 	return renderedBlocks.length ? renderedBlocks : void 0;
 }
+/**
+* Slack native streams key task rows by persistent id with no removal chunk.
+* When the task source switches representation (tool lines <-> typed plan) or
+* a snapshot drops ids, previously emitted non-terminal rows must receive a
+* final update or they linger in_progress forever.
+*/
+function reconcileSlackNativeTaskChunks(params) {
+	const nextTasks = /* @__PURE__ */ new Map();
+	for (const chunk of params.chunks ?? []) if (chunk.type === "task_update") nextTasks.set(chunk.id, {
+		title: chunk.title,
+		status: chunk.status
+	});
+	const terminalized = [...params.previousTasks].filter(([id, task]) => !nextTasks.has(id) && task.status !== "complete" && task.status !== "error").map(([id, task]) => {
+		const entry = {
+			title: task.title,
+			status: "complete"
+		};
+		nextTasks.set(id, entry);
+		return {
+			type: "task_update",
+			id,
+			title: task.title,
+			status: "complete"
+		};
+	});
+	for (const [id, task] of params.previousTasks) if (!nextTasks.has(id)) nextTasks.set(id, task);
+	return {
+		chunks: params.chunks?.length ? [...params.chunks, ...terminalized] : terminalized.length ? terminalized : params.chunks,
+		tasks: nextTasks
+	};
+}
 function buildSlackProgressStreamStartChunks(params) {
 	return buildSlackProgressStreamChunks(params);
 }
@@ -503,7 +563,7 @@ function resolveSlackThreadContext(params) {
 	const messageTs = params.message.ts ?? eventTs;
 	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
 	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
-	const replyToId = incomingThreadTs ?? messageTs;
+	const replyToId = isThreadReply ? incomingThreadTs : void 0;
 	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
 	return {
 		incomingThreadTs,
@@ -533,12 +593,44 @@ function resolveSlackThreadTargets(params) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
 function buildExpectedSlackEditText(params) {
-	return buildSlackEditTextPayload(params.text, params.blocks);
+	const trimmedText = params.text.trim();
+	if (trimmedText) return normalizeSlackOutboundText(trimmedText);
+	if (params.blocks?.length) return normalizeSlackOutboundText(buildSlackBlocksFallbackText(params.blocks));
+	return " ";
+}
+function buildAcceptedSlackEditTexts(params) {
+	const expected = buildExpectedSlackEditText(params);
+	const texts = /* @__PURE__ */ new Set([
+		expected,
+		normalizeSlackOutboundText(truncateSlackText(expected, SLACK_EDIT_TEXT_LIMIT)),
+		normalizeSlackOutboundText(buildSlackEditTextPayload(params.text, params.blocks))
+	]);
+	if (params.blocks?.length && hasSlackNativeDataBlock(params.blocks)) {
+		const fallbackPlan = buildSlackNativeDataDeliveryPlan({
+			baseText: params.text,
+			blocks: params.blocks
+		});
+		for (const message of fallbackPlan.fallbackMessages) texts.add(normalizeSlackOutboundText(message.text));
+	}
+	return texts;
 }
 function blocksMatch(expected, actual) {
 	if (!expected?.length) return !actual?.length;
-	if (!actual?.length) return false;
-	return JSON.stringify(expected) === JSON.stringify(actual);
+	if (!actual?.length) {
+		if (!hasSlackNativeDataBlock(expected)) return false;
+		return buildSlackNativeDataDeliveryPlan({ blocks: expected }).fallbackMessages.every((message) => !message.blocks?.length);
+	}
+	if (JSON.stringify(expected) === JSON.stringify(actual)) return true;
+	if (!hasSlackNativeDataBlock(expected)) return false;
+	try {
+		const fallbackPlan = buildSlackNativeDataDeliveryPlan({ blocks: expected });
+		const fallbackBlocks = fallbackPlan.fallbackMessages.flatMap((message) => message.blocks ?? []);
+		if (JSON.stringify(fallbackBlocks) === JSON.stringify(actual)) return true;
+		const fallbackText = fallbackPlan.fallbackMessages.map((message) => message.text).filter(Boolean).join("\n\n");
+		return normalizeSlackOutboundText(buildSlackBlocksFallbackText(actual)) === normalizeSlackOutboundText(fallbackText);
+	} catch {
+		return false;
+	}
 }
 async function readSlackMessageAfterEditError(params) {
 	if (params.threadTs) return ((await params.client.conversations.replies({
@@ -567,8 +659,12 @@ async function didSlackPreviewEditApplyAfterError(params) {
 		text: params.text,
 		blocks: params.blocks
 	});
+	const acceptedTexts = buildAcceptedSlackEditTexts({
+		text: params.text,
+		blocks: params.blocks
+	});
 	const actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
-	if (params.blocks?.length) return actualText === expectedText && blocksMatch(params.blocks, readback.blocks);
+	if (params.blocks?.length) return acceptedTexts.has(actualText) && blocksMatch(params.blocks, readback.blocks);
 	return actualText === expectedText;
 }
 async function finalizeSlackPreviewEdit(params) {
@@ -679,16 +775,26 @@ function resolveSlackStreamingThreadHint(params) {
 	});
 }
 const SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
-const slackStreamRecipientTeamCache = /* @__PURE__ */ new Map();
+const slackStreamRecipientTeamCaches = /* @__PURE__ */ new WeakMap();
+function getSlackStreamRecipientTeamCache(client) {
+	const existing = slackStreamRecipientTeamCaches.get(client);
+	if (existing) return existing;
+	const cache = /* @__PURE__ */ new Map();
+	slackStreamRecipientTeamCaches.set(client, cache);
+	return cache;
+}
 function buildSlackEventDeliveryKey(params) {
 	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
-	const slackBlocks = readSlackReplyBlocks(params.payload);
-	if (!reply.hasContent && !slackBlocks?.length) return null;
+	const renderPlan = resolveSlackReplyRenderPlan(params.payload, params.textOverride ?? params.payload.text);
+	const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
+	const slackBlocks = readSlackReplyBlocks(params.payload) ?? plannedBlocks;
+	const renderedText = renderPlan.mode === "single" ? renderPlan.text : renderPlan.fallbackText;
+	if (!reply.hasContent && !slackBlocks?.length && !renderedText.trim()) return null;
 	return JSON.stringify({
 		kind: params.kind,
 		threadTs: params.threadTs ?? "",
 		replyToId: params.payload.replyToId ?? null,
-		text: reply.trimmedText,
+		text: renderedText || reply.trimmedText,
 		mediaUrls: reply.mediaUrls,
 		blocks: slackBlocks ?? null
 	});
@@ -696,20 +802,22 @@ function buildSlackEventDeliveryKey(params) {
 function readSlackStreamRecipientTeamCache(params) {
 	if (!params.fallbackTeamId || !params.userId) return;
 	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
-	const cached = slackStreamRecipientTeamCache.get(cacheKey);
+	const cache = getSlackStreamRecipientTeamCache(params.client);
+	const cached = cache.get(cacheKey);
 	if (!cached) return;
-	slackStreamRecipientTeamCache.delete(cacheKey);
-	slackStreamRecipientTeamCache.set(cacheKey, cached);
+	cache.delete(cacheKey);
+	cache.set(cacheKey, cached);
 	return cached;
 }
 function rememberSlackStreamRecipientTeam(params) {
 	if (!params.fallbackTeamId || !params.userId) return;
 	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
-	if (slackStreamRecipientTeamCache.has(cacheKey)) slackStreamRecipientTeamCache.delete(cacheKey);
-	slackStreamRecipientTeamCache.set(cacheKey, params.teamId);
-	if (slackStreamRecipientTeamCache.size > SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX) {
-		const oldest = slackStreamRecipientTeamCache.keys().next().value;
-		if (oldest) slackStreamRecipientTeamCache.delete(oldest);
+	const cache = getSlackStreamRecipientTeamCache(params.client);
+	if (cache.has(cacheKey)) cache.delete(cacheKey);
+	cache.set(cacheKey, params.teamId);
+	if (cache.size > SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX) {
+		const oldest = cache.keys().next().value;
+		if (oldest) cache.delete(oldest);
 	}
 }
 function normalizeSlackReasoningProgressLine(text) {
@@ -793,6 +901,8 @@ async function resolveSlackStreamRecipientTeamId(params) {
 }
 async function dispatchPreparedSlackMessage(prepared) {
 	const { ctx, account, message, route } = prepared;
+	const slackClient = prepared.eventScope?.client ?? ctx.app.client;
+	const slackStreamFallbackTeamId = prepared.eventScope?.teamId ?? ctx.teamId;
 	const cfg = ctx.cfg;
 	const runtime = ctx.runtime;
 	const outboundIdentity = resolveAgentOutboundIdentity(cfg, route.agentId);
@@ -841,6 +951,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		ctx: prepared.ctxPayload
 	});
 	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	const suppressRoomEventTyping = prepared.ctxPayload.InboundEventKind === "room_event";
 	const messageSentHookTarget = prepared.ctxPayload.OriginatingTo ?? prepared.ctxPayload.To ?? prepared.replyTarget;
 	const messageSentHookContext = {
 		sessionKeyForInternalHooks: prepared.ctxPayload.SessionKey ?? route.sessionKey,
@@ -860,7 +971,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		setReaction: async (emoji) => {
 			await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
 				token: ctx.botToken,
-				client: ctx.app.client
+				client: slackClient
 			}).catch((err) => {
 				if (formatErrorMessage(err).includes("already_reacted")) return;
 				throw err;
@@ -869,7 +980,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		removeReaction: async (emoji) => {
 			await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
 				token: ctx.botToken,
-				client: ctx.app.client
+				client: slackClient
 			}).catch((err) => {
 				if (formatErrorMessage(err).includes("no_reaction")) return;
 				throw err;
@@ -925,12 +1036,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 					channelId: message.channel,
 					threadTs: statusThreadTs,
 					status: "is typing...",
-					loadingMessages: SLACK_THREAD_LOADING_MESSAGES
+					loadingMessages: SLACK_THREAD_LOADING_MESSAGES,
+					eventScope: prepared.eventScope
 				});
 				if (typingReaction && message.ts) await reactSlackMessage(message.channel, message.ts, typingReaction, {
 					token: ctx.botToken,
-					client: ctx.app.client
-				}).catch(() => {});
+					client: slackClient
+				}).catch((err) => {
+					logVerbose(`slack send: typing reaction failed: ${formatSlackError(err)}`);
+				});
 			},
 			stop: async () => {
 				if (!didSetStatus) return;
@@ -938,12 +1052,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 				await ctx.setSlackThreadStatus({
 					channelId: message.channel,
 					threadTs: statusThreadTs,
-					status: ""
+					status: "",
+					eventScope: prepared.eventScope
 				});
 				if (typingReaction && message.ts) await removeSlackReaction(message.channel, message.ts, typingReaction, {
 					token: ctx.botToken,
-					client: ctx.app.client
-				}).catch(() => {});
+					client: slackClient
+				}).catch((err) => {
+					logVerbose(`slack send: typing reaction removal failed: ${formatSlackError(err)}`);
+				});
 			},
 			onStartError: (err) => {
 				logTypingFailure({
@@ -1067,7 +1184,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			delivery.outcome = "success";
 		}
 	};
-	const deliveryTracker = createSlackEventDeliveryTracker();
+	let deliveryTracker = createSlackEventDeliveryTracker();
 	const markPreviewPayloadDelivered = (params) => {
 		deliveryTracker.markDelivered(params);
 		const nextThreadTs = replyPlan.peekThreadTs();
@@ -1113,12 +1230,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 				accountId: account.accountId,
 				runtime,
 				textLimit: ctx.textLimit,
+				mediaMaxBytes: ctx.mediaMaxBytes,
 				replyThreadTs: session.threadTs,
 				replyToMode: replyDeliveryMode,
 				...slackIdentity ? { identity: slackIdentity } : {},
 				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
 				...messageSentDeliveryHookContext,
-				deferMessageSentHooks: true
+				deferMessageSentHooks: true,
+				...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
 			});
 			markSlackStreamFallbackDelivered(session);
 			if (!session.stopped) try {
@@ -1160,11 +1279,13 @@ async function dispatchPreparedSlackMessage(prepared) {
 			accountId: account.accountId,
 			runtime,
 			textLimit: ctx.textLimit,
+			mediaMaxBytes: ctx.mediaMaxBytes,
 			replyThreadTs: deliveryReplyThreadTs,
 			replyToMode: replyDeliveryMode,
 			...slackIdentity ? { identity: slackIdentity } : {},
 			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-			...messageSentDeliveryHookContext
+			...messageSentDeliveryHookContext,
+			...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
 		});
 		observedReplyDelivery = true;
 		if (params.kind === "final") observedFinalReplyDelivery = true;
@@ -1201,7 +1322,9 @@ async function dispatchPreparedSlackMessage(prepared) {
 	const deliverWithStreaming = async (params) => {
 		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
-		if (streamFailed || reply.hasMedia || readSlackReplyBlocks(params.payload)?.length || !reply.hasText) {
+		const renderPlan = resolveSlackReplyRenderPlan(params.payload);
+		const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
+		if (streamFailed || reply.hasMedia || renderPlan.mode === "split" || Boolean(plannedBlocks?.length) || readSlackReplyBlocks(params.payload)?.length || !reply.hasText) {
 			await deliverNormally({
 				payload: params.payload,
 				kind: params.kind,
@@ -1250,16 +1373,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 					return;
 				}
 				streamSession = await startSlackStream({
-					client: ctx.app.client,
+					client: slackClient,
 					channel: message.channel,
 					threadTs: streamThreadTs,
 					text,
 					...slackIdentity ? { identity: slackIdentity } : {},
 					teamId: await resolveSlackStreamRecipientTeamId({
-						client: ctx.app.client,
+						client: slackClient,
 						token: ctx.botToken,
 						userId: message.user,
-						fallbackTeamId: ctx.teamId
+						fallbackTeamId: slackStreamFallbackTeamId
 					}),
 					userId: message.user
 				});
@@ -1288,12 +1411,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 				logVerbose("slack-stream: suppressed duplicate append payload");
 				return;
 			}
-			const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && previewToolProgressLines.length > 0 ? buildSlackProgressStreamCompletionChunks({
-				title: explicitProgressTitle,
-				lines: previewToolProgressLines,
-				maxLineChars: progressDraftMaxLineChars,
-				finalInProgressStatus: params.payload.isError ? "error" : "complete"
-			}) : void 0;
+			const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && (previewToolProgressLines.length > 0 || Boolean(latestPlan?.length) || Boolean(latestPlanExplanation) || [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error")) ? reconcileSlackNativeTaskChunks({
+				previousTasks: nativeTaskState,
+				chunks: buildSlackProgressStreamCompletionChunks({
+					title: resolveNativeProgressTitle(),
+					lines: resolveNativeProgressLines(),
+					plan: resolveNativeProgressPlan(),
+					maxLineChars: progressDraftMaxLineChars,
+					finalInProgressStatus: params.payload.isError ? "error" : "complete"
+				})
+			}).chunks : void 0;
 			if (useNativeProgressStreaming) {
 				if (completionChunks?.length) {
 					await appendSlackStream({
@@ -1379,11 +1506,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 			return;
 		}
 		const reply = resolveSendableOutboundReplyParts(payload);
-		const slackBlocks = readSlackReplyBlocks(payload);
 		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
-		const trimmedFinalText = (payload.text ?? ttsSupplement?.spokenText ?? "").trim();
+		const replySourceText = payload.text ?? ttsSupplement?.spokenText;
+		const replyRenderPlan = resolveSlackReplyRenderPlan(payload, replySourceText);
+		const slackBlocks = replyRenderPlan.mode === "single" ? replyRenderPlan.blocks : replyRenderPlan.blockPart?.blocks;
+		const requiresSeparateFallbackDelivery = replyRenderPlan.mode === "split";
+		const trimmedFinalText = replyRenderPlan.mode === "single" ? replyRenderPlan.text.trim() : replyRenderPlan.fallbackText.trim();
+		const previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim());
 		const shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !draftPreviewCommitted && !observedFinalReplyDelivery && previewStreamingEnabled && !payload.text?.trim();
-		if (info.kind === "final" && ttsSupplement && draftStream && !draftPreviewCommitted && !observedFinalReplyDelivery && previewStreamingEnabled && !payload.isError && trimmedFinalText.length > 0) {
+		if (info.kind === "final" && ttsSupplement && draftStream && !draftPreviewCommitted && !observedFinalReplyDelivery && previewStreamingEnabled && !payload.isError && !requiresSeparateFallbackDelivery && trimmedFinalText.length > 0) {
 			const channelId = draftStream.channelId();
 			const messageId = draftStream.messageId();
 			if (channelId && messageId) {
@@ -1392,12 +1523,12 @@ async function dispatchPreparedSlackMessage(prepared) {
 				await draftStream.seal();
 				try {
 					await finalizeSlackPreviewEdit({
-						client: ctx.app.client,
+						client: slackClient,
 						token: ctx.botToken,
 						accountId: account.accountId,
 						channelId,
 						messageId,
-						text: normalizeSlackOutboundText(trimmedFinalText),
+						text: previewFinalText,
 						...slackBlocks?.length ? { blocks: slackBlocks } : {},
 						threadTs: finalThreadTs
 					});
@@ -1409,7 +1540,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 						await deliverNormally({
 							payload: payload.text?.trim() ? payload : {
 								...payload,
-								text: trimmedFinalText
+								text: ttsSupplement.spokenText
 							},
 							kind: info.kind,
 							forcedThreadTs: finalThreadTs
@@ -1456,9 +1587,9 @@ async function dispatchPreparedSlackMessage(prepared) {
 					}
 				} : void 0,
 				buildFinalEdit: () => {
-					if (!previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
+					if (!previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
 					return {
-						text: normalizeSlackOutboundText(trimmedFinalText),
+						text: previewFinalText,
 						blocks: slackBlocks,
 						threadTs: usedReplyThreadTs ?? statusThreadTs
 					};
@@ -1470,7 +1601,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 						threadTs: edit.threadTs
 					})) return;
 					await finalizeSlackPreviewEdit({
-						client: ctx.app.client,
+						client: slackClient,
 						token: ctx.botToken,
 						accountId: account.accountId,
 						channelId: preview.channelId,
@@ -1540,6 +1671,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		cfg,
 		token: ctx.botToken,
 		accountId: account.accountId,
+		...prepared.eventScope ? { eventScope: prepared.eventScope } : {},
 		identity: slackIdentity,
 		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
 		maxChars: Math.min(ctx.textLimit, SLACK_TEXT_LIMIT),
@@ -1554,7 +1686,11 @@ async function dispatchPreparedSlackMessage(prepared) {
 	let hasStreamedMessage = false;
 	const streamMode = slackStreaming.draftMode;
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
-	const previewToolProgressEnabled = (Boolean(draftStream) || useNativeProgressStreaming) && resolveChannelStreamingPreviewToolProgress(account.config);
+	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
+	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config);
+	const commentaryProgressEnabled = progressDraftActive && resolveChannelStreamingProgressCommentary(account.config);
+	const commentaryDraftEnabled = progressDraftActive && (slackStreaming.mode === "progress" ? resolveChannelStreamingProgressCommentary(account.config, previewToolProgressEnabled) : previewToolProgressEnabled);
+	let shouldYieldDraftProgress = () => false;
 	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
 		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
 		previewToolProgressEnabled,
@@ -1563,6 +1699,9 @@ async function dispatchPreparedSlackMessage(prepared) {
 	let previewToolProgressSuppressed = false;
 	let previewToolProgressLines = [];
 	let lastNonEmptyPreviewToolProgressLines = [];
+	let latestPlan;
+	let latestPlanExplanation;
+	let nativeTaskState = /* @__PURE__ */ new Map();
 	let appendRenderedText = "";
 	let appendSourceText = "";
 	let reasoningProgressRawText = "";
@@ -1580,12 +1719,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 			entry: account.config,
 			lines: progressLines,
 			seed: progressSeed,
-			formatLine: escapeSlackMrkdwn
+			formatLine: escapeSlackMrkdwn,
+			narration: latestPlanExplanation,
+			plan: latestPlan
 		});
 		if (!previewText) return;
 		const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
 			title: explicitProgressTitle,
 			lines: progressLines,
+			plan: latestPlan,
+			narration: latestPlanExplanation,
 			maxLineChars: resolveChannelProgressDraftMaxLineChars(account.config)
 		}) : void 0;
 		draftStream.update(useRichProgressDraft && richProgressBlocks ? {
@@ -1604,13 +1747,26 @@ async function dispatchPreparedSlackMessage(prepared) {
 		}
 		return !streamFailed;
 	};
+	const resolveNativeProgressPlan = () => latestPlan?.length ? latestPlan : void 0;
+	const resolveNativeProgressLines = () => {
+		if (latestPlan?.length || !latestPlanExplanation) return previewToolProgressLines;
+		const explanationLine = buildChannelProgressDraftLine({
+			event: "plan",
+			phase: "update",
+			explanation: latestPlanExplanation
+		});
+		return explanationLine ? [...previewToolProgressLines, explanationLine] : previewToolProgressLines;
+	};
+	const resolveNativeProgressTitle = () => explicitProgressTitle && latestPlanExplanation ? `${explicitProgressTitle} — ${latestPlanExplanation}` : explicitProgressTitle ?? latestPlanExplanation;
 	const buildNativeProgressChunks = () => streamSession ? buildSlackProgressStreamUpdateChunks({
-		title: explicitProgressTitle,
-		lines: previewToolProgressLines,
+		title: resolveNativeProgressTitle(),
+		lines: resolveNativeProgressLines(),
+		plan: resolveNativeProgressPlan(),
 		maxLineChars: progressDraftMaxLineChars
 	}) : buildSlackProgressStreamStartChunks({
-		title: explicitProgressTitle,
-		lines: previewToolProgressLines,
+		title: resolveNativeProgressTitle(),
+		lines: resolveNativeProgressLines(),
+		plan: resolveNativeProgressPlan(),
 		maxLineChars: progressDraftMaxLineChars
 	});
 	const markNativeProgressDelivered = (session, threadTs) => {
@@ -1630,17 +1786,17 @@ async function dispatchPreparedSlackMessage(prepared) {
 		nativeProgressStreamThreadTs = streamThreadTs;
 		const startPromise = (async () => {
 			const session = await startSlackStream({
-				client: ctx.app.client,
+				client: slackClient,
 				channel: message.channel,
 				threadTs: streamThreadTs,
 				chunks,
 				taskDisplayMode: "plan",
 				...slackIdentity ? { identity: slackIdentity } : {},
 				teamId: await resolveSlackStreamRecipientTeamId({
-					client: ctx.app.client,
+					client: slackClient,
 					token: ctx.botToken,
 					userId: message.user,
-					fallbackTeamId: ctx.teamId
+					fallbackTeamId: slackStreamFallbackTeamId
 				}),
 				userId: message.user
 			});
@@ -1668,30 +1824,60 @@ async function dispatchPreparedSlackMessage(prepared) {
 		nativeProgressChunkKey = chunkKey;
 	};
 	const updateNativeProgressStream = async () => {
-		if (!useNativeProgressStreaming || streamFailed || previewToolProgressLines.length === 0) return;
+		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (!useNativeProgressStreaming || streamFailed || previewToolProgressLines.length === 0 && !latestPlan?.length && !latestPlanExplanation && !hasRetirableNativeTasks) return;
 		if (!await waitForNativeProgressStreamStart()) return;
-		const chunks = buildNativeProgressChunks();
+		const reconciled = reconcileSlackNativeTaskChunks({
+			previousTasks: nativeTaskState,
+			chunks: buildNativeProgressChunks()
+		});
+		const chunks = reconciled.chunks;
 		if (!chunks?.length) return;
 		const chunkKey = JSON.stringify(chunks);
 		if (chunkKey === nativeProgressChunkKey) return;
 		try {
-			if (!streamSession) {
-				await startNativeProgressStream(chunks, chunkKey);
-				return;
-			}
-			await appendNativeProgressStream(chunks, chunkKey);
+			if (!streamSession) await startNativeProgressStream(chunks, chunkKey);
+			else await appendNativeProgressStream(chunks, chunkKey);
+			nativeTaskState = reconciled.tasks;
 		} catch (err) {
 			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
 			streamFailed = true;
 		}
 	};
 	const progressDraftGate = createChannelProgressDraftGate({ onStart: useNativeProgressStreaming ? updateNativeProgressStream : renderProgressDraft });
+	const pushPlanProgress = async (steps, explanation) => {
+		if (previewToolProgressSuppressed) return;
+		latestPlan = steps ? steps.map((entry) => ({ ...entry })) : void 0;
+		latestPlanExplanation = explanation?.replace(/\s+/g, " ").trim() || void 0;
+		if (!draftStream && !useNativeProgressStreaming) return;
+		if (streamMode !== "status_final" && !useNativeProgressStreaming) {
+			const text = formatChannelProgressDraftText({
+				entry: account.config,
+				lines: previewToolProgressLines,
+				seed: progressSeed,
+				formatLine: escapeSlackMrkdwn,
+				narration: latestPlanExplanation,
+				plan: latestPlan
+			});
+			if (text) {
+				draftStream?.update(text);
+				hasStreamedMessage = true;
+			}
+			return;
+		}
+		const alreadyStarted = progressDraftGate.hasStarted;
+		await progressDraftGate.startNow();
+		if (alreadyStarted && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+	};
 	const refreshStartedProgressDraft = async () => {
 		if (useNativeProgressStreaming) await updateNativeProgressStream();
 		else renderProgressDraft();
 	};
-	const pushPreviewToolProgress = async (line, options) => {
+	const pushPreviewProgress = async (line, options) => {
+		const lane = options?.lane ?? "tool";
+		const progressEnabled = lane === "commentary" ? commentaryDraftEnabled : previewToolProgressEnabled;
 		if (!draftStream && !useNativeProgressStreaming) return;
+		if (lane === "commentary" && commentaryProgressEnabled && shouldYieldDraftProgress()) return;
 		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
 		const normalized = line?.text.replace(/\s+/g, " ").trim();
 		if (!line || !normalized) {
@@ -1702,7 +1888,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			return;
 		}
 		if (streamMode !== "status_final") {
-			if (!previewToolProgressEnabled || previewToolProgressSuppressed) return;
+			if (!progressEnabled || previewToolProgressSuppressed) return;
 			const nextLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
 			if (nextLines === previewToolProgressLines) return;
 			previewToolProgressLines = nextLines;
@@ -1715,7 +1901,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			hasStreamedMessage = true;
 			return;
 		}
-		if (previewToolProgressEnabled && !previewToolProgressSuppressed) {
+		if (progressEnabled && !previewToolProgressSuppressed) {
 			previewToolProgressLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
 			if (previewToolProgressLines.length > 0) lastNonEmptyPreviewToolProgressLines = previewToolProgressLines;
 		}
@@ -1766,24 +1952,42 @@ async function dispatchPreparedSlackMessage(prepared) {
 		reasoningProgressRawText = mergeSlackReasoningProgressText(reasoningProgressRawText, payload.text, { snapshot: payload.isReasoningSnapshot === true });
 		const normalized = normalizeSlackReasoningProgressLine(reasoningProgressRawText);
 		if (!normalized) return;
-		await pushPreviewToolProgress({
+		await pushPreviewProgress({
 			id: "reasoning",
 			kind: "item",
 			text: normalized,
 			label: "Reasoning"
 		});
 	};
+	const resetDraftDeliveryState = () => {
+		hasStreamedMessage = false;
+		appendRenderedText = "";
+		appendSourceText = "";
+		statusUpdateCount = 0;
+	};
+	const resetDraftProgressState = () => {
+		reasoningProgressRawText = "";
+		previewToolProgressSuppressed = false;
+		previewToolProgressLines = [];
+	};
 	const onDraftBoundary = !shouldUseDraftStream ? void 0 : async () => {
 		if (hasStreamedMessage && streamMode !== "status_final") {
 			draftStream?.forceNewMessage();
-			hasStreamedMessage = false;
-			appendRenderedText = "";
-			appendSourceText = "";
-			statusUpdateCount = 0;
+			resetDraftDeliveryState();
 		}
-		reasoningProgressRawText = "";
-		previewToolProgressSuppressed = false;
-		previewToolProgressLines = [];
+		resetDraftProgressState();
+	};
+	const onQueuedFollowupAdmitted = !shouldUseDraftStream ? void 0 : async () => {
+		await draftStream?.flush();
+		draftStream?.forceNewMessage();
+		draftPreviewCommitted = false;
+		observedFinalReplyDelivery = false;
+		deliveryTracker = createSlackEventDeliveryTracker();
+		resetDraftDeliveryState();
+		resetDraftProgressState();
+		latestPlan = void 0;
+		latestPlanExplanation = void 0;
+		nativeTaskState = /* @__PURE__ */ new Map();
 	};
 	let dispatchError;
 	let queuedFinal = false;
@@ -1813,10 +2017,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 			replyOptions: {
 				skillFilter: prepared.channelConfig?.skills,
 				sourceReplyDeliveryMode,
+				suppressTyping: suppressRoomEventTyping ? true : void 0,
 				hasRepliedRef,
 				disableBlockStreaming,
 				onModelSelected,
 				suppressDefaultToolProgressMessages: suppressDefaultToolProgressMessages ? true : void 0,
+				commentaryProgressEnabled: commentaryProgressEnabled ? true : void 0,
+				onVerboseProgressVisibility: commentaryProgressEnabled ? (isActive) => {
+					shouldYieldDraftProgress = isActive;
+				} : void 0,
 				allowProgressCallbacksWhenSourceDeliverySuppressed: sourceReplyDeliveryMode === "message_tool_only" && statusReactionsEnabled ? true : void 0,
 				allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : void 0,
 				onPartialReply: useStreaming ? void 0 : !previewStreamingEnabled ? void 0 : async (payload) => {
@@ -1824,6 +2033,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onAssistantMessageStart: onDraftBoundary,
 				onReasoningEnd: onDraftBoundary,
+				onQueuedFollowupAdmitted,
 				onReasoningStream: statusReactionsEnabled || previewToolProgressEnabled ? async (payload) => {
 					await pushReasoningProgress(payload);
 					if (!statusReactionsEnabled) return;
@@ -1831,7 +2041,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				} : void 0,
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
-					await pushPreviewToolProgress(buildChannelProgressDraftLineForEntry(account.config, {
+					await pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
 						event: "tool",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -1841,7 +2051,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
 				},
 				onItemEvent: async (payload) => {
-					await pushPreviewToolProgress(buildChannelProgressDraftLineForEntry(account.config, {
+					await pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
 						event: "item",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -1853,21 +2063,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 						summary: payload.summary,
 						progressText: payload.progressText,
 						meta: payload.meta
-					}));
+					}), payload.kind === "preamble" ? { lane: "commentary" } : void 0);
 				},
 				onPlanUpdate: async (payload) => {
 					if (payload.phase !== "update") return;
-					await pushPreviewToolProgress(buildChannelProgressDraftLine({
-						event: "plan",
-						phase: payload.phase,
-						title: payload.title,
-						explanation: payload.explanation,
-						steps: payload.steps
-					}));
+					await pushPlanProgress(payload.planSteps, payload.explanation);
 				},
 				onApprovalEvent: async (payload) => {
 					if (payload.phase !== "requested") return;
-					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+					await pushPreviewProgress(buildChannelProgressDraftLine({
 						event: "approval",
 						phase: payload.phase,
 						title: payload.title,
@@ -1878,7 +2082,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onCommandOutput: async (payload) => {
 					if (payload.phase !== "end") return;
-					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+					await pushPreviewProgress(buildChannelProgressDraftLine({
 						event: "command-output",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -1891,7 +2095,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onPatchSummary: async (payload) => {
 					if (payload.phase !== "end") return;
-					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+					await pushPreviewProgress(buildChannelProgressDraftLine({
 						event: "patch",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -1920,12 +2124,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 	let streamFallbackDelivered = false;
 	const finalStream = streamSession;
 	if (finalStream && !finalStream.stopped) try {
-		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && previewToolProgressLines.length > 0 ? buildSlackProgressStreamCompletionChunks({
-			title: explicitProgressTitle,
-			lines: previewToolProgressLines,
-			maxLineChars: progressDraftMaxLineChars,
-			finalInProgressStatus: dispatchError ? "error" : "complete"
-		}) : void 0;
+		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && (previewToolProgressLines.length > 0 || Boolean(latestPlan?.length) || Boolean(latestPlanExplanation) || [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error")) ? reconcileSlackNativeTaskChunks({
+			previousTasks: nativeTaskState,
+			chunks: buildSlackProgressStreamCompletionChunks({
+				title: resolveNativeProgressTitle(),
+				lines: resolveNativeProgressLines(),
+				plan: resolveNativeProgressPlan(),
+				maxLineChars: progressDraftMaxLineChars,
+				finalInProgressStatus: dispatchError ? "error" : "complete"
+			})
+		}).chunks : void 0;
 		if (completionChunks?.length) nativeProgressCompletionSent = true;
 		const stopResult = await stopSlackStream({
 			session: finalStream,
@@ -1981,7 +2189,10 @@ async function dispatchPreparedSlackMessage(prepared) {
 		else statusReactions.restoreInitial();
 	} else await statusReactions.restoreInitial();
 	const participationThreadTs = usedReplyThreadTs ?? statusThreadTs;
-	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, { agentId: route.agentId });
+	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, {
+		agentId: route.agentId,
+		...prepared.eventScope ? { teamId: prepared.eventScope.teamId } : {}
+	});
 	if (dispatchError) throw toLintErrorObject(dispatchError, "Slack dispatch failed");
 	if (!anyReplyDelivered && !draftPreviewCommitted) {
 		await draftStream?.clear();
@@ -1997,7 +2208,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		ackReactionValue: prepared.ackReactionValue,
 		remove: () => removeSlackReaction(message.channel, prepared.ackReactionMessageTs ?? "", prepared.ackReactionValue, {
 			token: ctx.botToken,
-			client: ctx.app.client
+			client: slackClient
 		}),
 		onError: (err) => {
 			logAckFailure({
@@ -2017,11 +2228,100 @@ function toLintErrorObject(value, fallbackMessage) {
 	return error;
 }
 //#endregion
+//#region extensions/slack/src/monitor/message-handler/preflight-audio.ts
+const SLACK_DEFAULT_ECHO_TRANSCRIPT_FORMAT = "📝 \"{transcript}\"";
+const loadSlackPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio.runtime-D5Bgags0.js"));
+function isSlackAudioFile(file) {
+	if (file.subtype === "slack_audio") return true;
+	if ((file.mimetype?.split(";")[0]?.trim().toLowerCase())?.startsWith("audio/")) return true;
+	return Boolean(mimeTypeFromFilePath(file.name)?.startsWith("audio/"));
+}
+function findCaptionlessSlackAudioFile(message) {
+	if (message.text?.trim()) return;
+	return message.files?.slice(0, 8).find(isSlackAudioFile);
+}
+function formatSlackAudioTranscriptForAgent(params) {
+	return [`[Audio transcript (machine-generated, untrusted)]: ${JSON.stringify(params.transcript)}`, params.rawBody].filter(Boolean).join("\n");
+}
+function suppressSlackPreflightAudioEcho(cfg) {
+	const audio = cfg.tools?.media?.audio;
+	if (!audio?.echoTranscript) return cfg;
+	return {
+		...cfg,
+		tools: {
+			...cfg.tools,
+			media: {
+				...cfg.tools?.media,
+				audio: {
+					...audio,
+					echoTranscript: false
+				}
+			}
+		}
+	};
+}
+async function resolveSlackPreflightAudioTranscript(params) {
+	const mediaIndex = params.media.findIndex((entry) => entry.contentType?.toLowerCase().startsWith("audio/"));
+	if (mediaIndex < 0) return null;
+	try {
+		const { transcribeFirstAudio } = await loadSlackPreflightAudioRuntime();
+		const transcript = await transcribeFirstAudio({
+			ctx: {
+				MediaPaths: params.media.map((entry) => entry.path),
+				MediaTypes: params.media.map((entry) => entry.contentType ?? ""),
+				Provider: "slack",
+				Surface: "slack",
+				OriginatingChannel: "slack",
+				OriginatingTo: params.originatingTo,
+				AccountId: params.accountId,
+				MessageThreadId: params.messageThreadId,
+				ChatType: "channel",
+				SessionKey: params.sessionKey
+			},
+			cfg: suppressSlackPreflightAudioEcho(params.cfg)
+		});
+		return transcript ? {
+			transcript,
+			mediaIndex
+		} : null;
+	} catch (err) {
+		logVerbose(`slack: audio preflight transcription failed: ${String(err)}`);
+		return null;
+	}
+}
+function formatSlackAudioTranscriptEcho(transcript, format) {
+	return format.replace("{transcript}", () => transcript);
+}
+async function sendSlackPreflightAudioTranscriptEcho(params) {
+	const audio = params.cfg.tools?.media?.audio;
+	if (!audio?.echoTranscript) return;
+	const text = formatSlackAudioTranscriptEcho(params.transcript, audio.echoFormat ?? SLACK_DEFAULT_ECHO_TRANSCRIPT_FORMAT);
+	try {
+		const { sendDurableMessageBatch } = await loadSlackPreflightAudioRuntime();
+		const send = await sendDurableMessageBatch({
+			cfg: params.cfg,
+			channel: "slack",
+			to: params.originatingTo,
+			accountId: params.accountId,
+			threadId: params.messageThreadId,
+			payloads: [{ text }],
+			bestEffort: true,
+			durability: "best_effort"
+		});
+		if (send.status === "failed") throw send.error;
+	} catch (err) {
+		logVerbose(`slack: audio transcript echo failed: ${String(err)}`);
+	}
+}
+async function discardSlackPreflightMedia(media) {
+	await Promise.allSettled((media ?? []).map((entry) => fs.rm(entry.path, { force: true })));
+}
+//#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-content.ts
 const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
 const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-DMpDmKEA.js").then((n) => n.g));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-BZiuSTIq.js").then((n) => n.g));
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -2066,7 +2366,8 @@ async function resolveSlackMessageContent(params) {
 		maxBytes: params.mediaMaxBytes,
 		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
 		totalTimeoutMs: params.mediaTotalTimeoutMs,
-		abortSignal: params.abortSignal
+		abortSignal: params.abortSignal,
+		preloadedMedia: params.preloadedMedia
 	})) : Promise.resolve(null);
 	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		attachments: params.message.attachments,
@@ -2150,7 +2451,7 @@ async function resolveSlackDmHistoryContext(params) {
 		inboundHistory: void 0
 	};
 	try {
-		const messages = ((await params.ctx.app.client.conversations.history({
+		const messages = ((await (params.eventScope?.client ?? params.ctx.app.client).conversations.history({
 			token: params.ctx.botToken,
 			channel: params.channelId,
 			...params.currentMessageTs ? {
@@ -2170,7 +2471,7 @@ async function resolveSlackDmHistoryContext(params) {
 		const resolveUserLabel = async (userId) => {
 			const cached = userNames.get(userId);
 			if (cached) return cached;
-			const label = normalizeOptionalString((await params.ctx.resolveUserName(userId)).name) ?? userId;
+			const label = normalizeOptionalString((await params.ctx.resolveUserName(userId, params.eventScope)).name) ?? userId;
 			userNames.set(userId, label);
 			return label;
 		};
@@ -2267,28 +2568,46 @@ function normalizeSlackRouteBindingConfig(cfg) {
 	return normalizedCfg;
 }
 function resolveSlackBaseConversationId(params) {
-	return params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel;
+	const raw = params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel;
+	return params.eventScope ? `team:${encodeURIComponent(params.eventScope.teamId)}:${raw}` : raw;
+}
+function qualifySlackPeerId(params) {
+	if (!params.eventScope) return params.id;
+	return `team:${encodeURIComponent(params.eventScope.teamId)}:${params.kind}:${encodeURIComponent(params.id)}`;
 }
 function resolveSlackInitialAgentRoute(params) {
-	return resolveAgentRoute({
+	const route = resolveAgentRoute({
 		cfg: normalizeSlackRouteBindingConfig(params.ctx.cfg),
 		channel: "slack",
 		accountId: params.account.accountId,
-		teamId: params.ctx.teamId || void 0,
+		teamId: params.eventScope?.teamId || params.ctx.teamId || void 0,
 		peer: {
 			kind: params.isDirectMessage ? "direct" : params.isRoom ? "channel" : "group",
-			id: params.isDirectMessage ? params.message.user ?? "unknown" : params.message.channel
+			id: qualifySlackPeerId({
+				id: params.isDirectMessage ? params.message.user ?? "unknown" : params.message.channel,
+				kind: params.isDirectMessage ? "user" : "channel",
+				eventScope: params.eventScope
+			})
 		}
 	});
+	if (!params.eventScope || !params.isDirectMessage || route.dmScope !== "main") return route;
+	const partition = `account:${encodeURIComponent(params.account.accountId).toLowerCase()}:team:${encodeURIComponent(params.eventScope.teamId).toLowerCase()}`;
+	const sessionKey = `${route.sessionKey}:${partition}`;
+	return {
+		...route,
+		sessionKey,
+		mainSessionKey: sessionKey
+	};
 }
 function resolveSlackRoutingContext(params) {
-	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs } = params;
+	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, eventScope } = params;
 	let route = resolveSlackInitialAgentRoute({
 		ctx,
 		account,
 		message,
 		isDirectMessage,
-		isRoom
+		isRoom,
+		eventScope
 	});
 	const chatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
 	const replyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, chatType);
@@ -2304,10 +2623,11 @@ function resolveSlackRoutingContext(params) {
 	const routedThreadId = (isDirectMessage ? assistantThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
 	const baseConversationId = resolveSlackBaseConversationId({
 		message,
-		isDirectMessage
+		isDirectMessage,
+		eventScope
 	});
 	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
-	const boundThreadRoute = runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
+	const boundThreadRoute = !eventScope && runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
 		route,
 		conversation: {
 			channel: "slack",
@@ -2316,7 +2636,11 @@ function resolveSlackRoutingContext(params) {
 			parentConversationId: baseConversationId
 		}
 	}) : null;
-	const runtimeRoute = boundThreadRoute?.boundSessionKey || boundThreadRoute?.bindingRecord ? boundThreadRoute : resolveRuntimeConversationBindingRoute({
+	const runtimeRoute = eventScope ? {
+		route,
+		bindingRecord: null,
+		boundSessionKey: void 0
+	} : boundThreadRoute?.boundSessionKey || boundThreadRoute?.bindingRecord ? boundThreadRoute : resolveRuntimeConversationBindingRoute({
 		route,
 		conversation: {
 			channel: "slack",
@@ -2327,7 +2651,7 @@ function resolveSlackRoutingContext(params) {
 	let configuredBinding = null;
 	let configuredBindingSessionKey = "";
 	if (runtimeRoute.boundSessionKey || runtimeRoute.bindingRecord) route = runtimeRoute.route;
-	else {
+	else if (!eventScope) {
 		const configuredRoute = resolveConfiguredBindingRoute({
 			cfg: ctx.cfg,
 			route,
@@ -2350,7 +2674,7 @@ function resolveSlackRoutingContext(params) {
 		parentSessionKey: routedThreadId && ctx.threadInheritParent ? route.sessionKey : void 0
 	});
 	const sessionKey = threadKeys.sessionKey;
-	const historyKey = isThreadReply && ctx.threadHistoryScope === "thread" ? sessionKey : message.channel;
+	const historyKey = isThreadReply && ctx.threadHistoryScope === "thread" ? sessionKey : eventScope ? `${account.accountId}:${eventScope.teamId}:${message.channel}` : message.channel;
 	return {
 		route,
 		runtimeBinding: runtimeRoute.bindingRecord,
@@ -2419,7 +2743,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DMpDmKEA.js").then((n) => n.g));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BZiuSTIq.js").then((n) => n.g));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -2455,7 +2779,7 @@ async function resolveSlackThreadUserMap(params) {
 	if (uniqueUserIds.length === 0) return userMap;
 	const { results } = await runTasksWithConcurrency({
 		tasks: uniqueUserIds.map((id) => async () => {
-			const user = await params.ctx.resolveUserName(id);
+			const user = await params.ctx.resolveUserName(id, params.eventScope);
 			return user ? {
 				id,
 				user
@@ -2498,7 +2822,7 @@ async function resolveSlackThreadContextData(params) {
 		threadStarterMedia
 	};
 	const starter = params.threadStarter;
-	const starterSenderName = params.allowNameMatching && params.allowFromLower.length > 0 && starter?.userId ? (await params.ctx.resolveUserName(starter.userId))?.name : void 0;
+	const starterSenderName = params.allowNameMatching && params.allowFromLower.length > 0 && starter?.userId ? (await params.ctx.resolveUserName(starter.userId, params.eventScope))?.name : void 0;
 	const starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor({
 		userId: starter.userId,
 		botId: starter.botId
@@ -2523,7 +2847,7 @@ async function resolveSlackThreadContextData(params) {
 			const { resolveSlackMedia } = await loadSlackMediaModule();
 			threadStarterMedia = await resolveSlackMedia({
 				files: starter.files,
-				client: params.ctx.app.client,
+				client: params.eventScope?.client ?? params.ctx.app.client,
 				token: params.ctx.botToken,
 				maxBytes: params.ctx.mediaMaxBytes
 			});
@@ -2551,7 +2875,7 @@ async function resolveSlackThreadContextData(params) {
 			history: await resolveSlackThreadHistory({
 				channelId: params.message.channel,
 				threadTs: params.threadTs,
-				client: params.ctx.app.client,
+				client: params.eventScope?.client ?? params.ctx.app.client,
 				currentMessageTs: params.message.ts,
 				limit: threadInitialHistoryLimit
 			}),
@@ -2572,7 +2896,8 @@ async function resolveSlackThreadContextData(params) {
 			});
 			const userMapForFilter = params.contextVisibilityMode !== "all" && params.allowNameMatching && params.allowFromLower.length > 0 ? await resolveSlackThreadUserMap({
 				ctx: params.ctx,
-				messages: threadHistoryWithoutCurrentBot
+				messages: threadHistoryWithoutCurrentBot,
+				eventScope: params.eventScope
 			}) : /* @__PURE__ */ new Map();
 			const { items: filteredThreadHistory, omitted: omittedHistoryCount } = params.contextVisibilityMode === "all" ? {
 				items: threadHistoryWithoutCurrentBot,
@@ -2639,7 +2964,7 @@ async function resolveSlackThreadContextData(params) {
 //#region extensions/slack/src/monitor/message-handler/subteam-mentions.ts
 const SUBTEAM_MENTION_RE = /<!subteam\^([A-Z0-9]+)(?:\|[^>]*)?>/gi;
 const SUBTEAM_MEMBER_CACHE_TTL_MS = 300 * 1e3;
-let subteamMemberCache = /* @__PURE__ */ new WeakMap();
+const subteamMemberCache = /* @__PURE__ */ new WeakMap();
 function normalizeSlackId(value) {
 	return typeof value === "string" && value.trim() ? value.trim().toUpperCase() : void 0;
 }
@@ -2756,7 +3081,7 @@ async function restoreSlackAssistantThreadContextFromMetadata(params) {
 	const parentUserId = params.message.parent_user_id?.trim();
 	if (!params.message.channel || !threadTs || !parentUserId || parentUserId !== params.ctx.botUserId && parentUserId !== params.ctx.botId) return;
 	try {
-		const response = await params.ctx.app.client.conversations.replies({
+		const response = await (params.eventScope?.client ?? params.ctx.app.client).conversations.replies({
 			channel: params.message.channel,
 			ts: threadTs,
 			oldest: threadTs,
@@ -2841,7 +3166,7 @@ async function resolveSlackHistoryMediaForPendingRecord(params) {
 		isThreadReply: params.isThreadReply,
 		threadStarter: params.threadStarter,
 		isBotMessage: params.isBotMessage,
-		client: params.ctx.app.client,
+		client: params.eventScope?.client ?? params.ctx.app.client,
 		botToken: params.ctx.botToken,
 		mediaMaxBytes: Math.min(params.ctx.mediaMaxBytes, SLACK_HISTORY_MEDIA_MAX_BYTES),
 		mediaReadIdleTimeoutMs: SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS,
@@ -2872,10 +3197,10 @@ async function resolveSlackExplicitMentionState(params) {
 	const normalizedBotUserId = normalizeSlackId(params.ctx.botUserId);
 	const explicitlyMentionedBotUser = Boolean(normalizedBotUserId && params.mentionedUserIds.includes(normalizedBotUserId));
 	const explicitlyMentionedBotSubteam = Boolean(params.ctx.botUserId && params.hasSubteamMention) && await isSlackSubteamMentionForBot({
-		client: params.ctx.app.client,
+		client: params.eventScope?.client ?? params.ctx.app.client,
 		text: params.messageText,
 		botUserId: params.ctx.botUserId,
-		teamId: params.ctx.teamId,
+		teamId: params.eventScope?.teamId ?? params.ctx.teamId,
 		log: logVerbose
 	});
 	return {
@@ -2909,8 +3234,8 @@ async function resolveSlackConversationContext(params) {
 	let channelInfo = {};
 	let resolvedChannelType = normalizeSlackChannelType(message.channel_type, message.channel);
 	if (resolvedChannelType !== "im" && (!message.channel_type || message.channel_type !== "im")) {
-		channelInfo = await ctx.resolveChannelName(message.channel);
-		resolvedChannelType = normalizeSlackChannelType(message.channel_type ?? channelInfo.type, message.channel);
+		channelInfo = await ctx.resolveChannelName(message.channel, params.eventScope);
+		resolvedChannelType = normalizeSlackChannelType(message.channel_type ?? channelInfo.type ?? ctx.recallSlackChannelType(message.channel, params.eventScope), message.channel);
 	}
 	const channelName = channelInfo?.name;
 	const isDirectMessage = resolvedChannelType === "im";
@@ -2978,12 +3303,12 @@ async function authorizeSlackInboundMessage(params) {
 			accountId: account.accountId,
 			senderId: directUserId,
 			allowFromLower,
-			resolveSenderName: ctx.resolveUserName,
+			resolveSenderName: (userId) => ctx.resolveUserName(userId, params.eventScope),
 			sendPairingReply: async (text) => {
 				await sendMessageSlack(message.channel, text, {
 					cfg: ctx.cfg,
 					token: ctx.botToken,
-					client: ctx.app.client,
+					client: params.eventScope?.client ?? ctx.app.client,
 					accountId: account.accountId
 				});
 			},
@@ -3003,18 +3328,25 @@ async function authorizeSlackInboundMessage(params) {
 }
 async function prepareSlackMessage(params) {
 	const { ctx, account, message, opts } = params;
+	const slackClient = opts.eventScope?.client ?? ctx.app.client;
+	const threadStarterWorkspaceScope = opts.eventScope ? {
+		accountId: account.accountId,
+		teamId: opts.eventScope.teamId
+	} : void 0;
 	const cfg = ctx.cfg;
 	const conversation = await resolveSlackConversationContext({
 		ctx,
 		account,
-		message
+		message,
+		eventScope: opts.eventScope
 	});
 	const { channelInfo, channelName, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, allowBotsMode, isBotMessage } = conversation;
 	const authorization = await authorizeSlackInboundMessage({
 		ctx,
 		account,
 		message,
-		conversation
+		conversation,
+		eventScope: opts.eventScope
 	});
 	if (!authorization) return null;
 	const { senderId, allowFromLower } = authorization;
@@ -3023,7 +3355,7 @@ async function prepareSlackMessage(params) {
 	const resolveSenderName = async () => {
 		if (resolvedSenderName) return resolvedSenderName;
 		if (message.user) {
-			const normalized = normalizeOptionalString((await ctx.resolveUserName(message.user))?.name);
+			const normalized = normalizeOptionalString((await ctx.resolveUserName(message.user, opts.eventScope))?.name);
 			if (normalized) {
 				resolvedSenderName = normalized;
 				return resolvedSenderName;
@@ -3037,24 +3369,26 @@ async function prepareSlackMessage(params) {
 	const messageAssistantThreadContext = resolveSlackMessageAssistantThreadContext(message);
 	const assistantContextLookupChannelId = messageAssistantThreadContext?.assistantChannelId ?? message.channel;
 	const assistantContextLookupThreadTs = messageAssistantThreadContext?.threadTs ?? message.thread_ts ?? message.ts;
-	const cachedAssistantThreadContext = isDirectMessage ? ctx.getSlackAssistantThreadContext(assistantContextLookupChannelId, assistantContextLookupThreadTs) : void 0;
+	const cachedAssistantThreadContext = isDirectMessage ? ctx.getSlackAssistantThreadContext(assistantContextLookupChannelId, assistantContextLookupThreadTs, opts.eventScope) : void 0;
 	const restoredAssistantThreadContextPromise = isDirectMessage && !cachedAssistantThreadContext && !hasSlackAssistantThreadMetadata(messageAssistantThreadContext) ? restoreSlackAssistantThreadContextFromMetadata({
 		ctx,
-		message
+		message,
+		eventScope: opts.eventScope
 	}) : Promise.resolve(void 0);
 	const { explicitlyMentionedBotUser, explicitlyMentionedBotSubteam, explicitlyMentioned } = await resolveSlackExplicitMentionState({
 		ctx,
 		messageText,
 		mentionedUserIds,
 		hasSubteamMention: mentionMetadata.hasSubteamMention,
-		source: opts.source
+		source: opts.source,
+		eventScope: opts.eventScope
 	});
 	const channelRequireMention = channelConfig?.requireMention ?? ctx.defaultRequireMention ?? true;
 	const channelChatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
 	const restoredAssistantThreadContext = await restoredAssistantThreadContextPromise;
 	const assistantThreadContext = mergeSlackAssistantThreadContext(messageAssistantThreadContext, cachedAssistantThreadContext ?? restoredAssistantThreadContext);
 	const assistantThreadContextToCache = messageAssistantThreadContext || restoredAssistantThreadContext ? assistantThreadContext : void 0;
-	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache);
+	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache, opts.eventScope);
 	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, channelChatType);
 	const willImplicitlyThreadReply = isRoom && !channelRequireMention && channelReplyToMode !== "off";
 	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
@@ -3068,8 +3402,10 @@ async function prepareSlackMessage(params) {
 		isRoomish,
 		channelConfig,
 		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource,
-		assistantThreadTs: assistantThreadContext?.threadTs
+		assistantThreadTs: assistantThreadContext?.threadTs,
+		eventScope: opts.eventScope
 	});
+	let mentionCheckTranscript;
 	const resolveWasMentioned = (mentionRegexes) => opts.wasMentioned ?? (!isDirectMessage && matchesMentionWithExplicit({
 		text: messageText,
 		mentionRegexes,
@@ -3077,7 +3413,8 @@ async function prepareSlackMessage(params) {
 			hasAnyMention,
 			isExplicitlyMentioned: explicitlyMentioned,
 			canResolveExplicit: Boolean(ctx.botUserId)
-		}
+		},
+		transcript: mentionCheckTranscript
 	}));
 	const buildPolicyMentionRegexes = (agentId) => resolveCachedMentionRegexes(ctx, agentId, {
 		provider: "slack",
@@ -3087,23 +3424,8 @@ async function prepareSlackMessage(params) {
 	let mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
 	let wasMentioned = resolveWasMentioned(mentionRegexes);
 	const hasBoundSession = Boolean(routing.runtimeBoundSessionKey || routing.configuredBindingSessionKey);
-	if (!seedTopLevelRoomThreadBySource && wasMentioned && isRoom && !routing.isThreadReply && !hasBoundSession) {
-		routing = resolveSlackRoutingContext({
-			ctx,
-			account,
-			message,
-			isDirectMessage,
-			isGroupDm,
-			isRoom,
-			isRoomish,
-			channelConfig,
-			seedTopLevelRoomThread: true,
-			assistantThreadTs: assistantThreadContext?.threadTs
-		});
-		mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
-		wasMentioned = resolveWasMentioned(mentionRegexes);
-	}
-	const { route, runtimeBinding, configuredBinding, configuredBindingSessionKey, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey, historyKey } = routing;
+	let { route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey, historyKey } = routing;
+	const { configuredBinding, configuredBindingSessionKey } = routing;
 	const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);
 	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (isThreadReply || isAssistantThreadMessage || replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
 	if (runtimeBinding && shouldLogVerbose()) logVerbose(`slack: routed via bound conversation ${runtimeBinding.conversation.conversationId} -> ${runtimeBinding.targetSessionKey}`);
@@ -3135,14 +3457,14 @@ async function prepareSlackMessage(params) {
 		ok: true,
 		name: void 0
 	});
-	const directThreadRoutedToDmSession = !assistantThreadContext && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
 	let implicitMentionKinds = [];
 	if (!isDirectMessage && ctx.botUserId && message.thread_ts && !ctx.threadRequireExplicitMention && !wasMentioned) {
 		const replyToBotKinds = implicitMentionKindWhen("reply_to_bot", message.parent_user_id === ctx.botUserId);
 		implicitMentionKinds = replyToBotKinds.length > 0 ? replyToBotKinds : implicitMentionKindWhen("bot_thread_participant", await hasSlackThreadParticipationWithPersistence({
 			accountId: account.accountId,
 			channelId: message.channel,
-			threadTs: message.thread_ts
+			threadTs: message.thread_ts,
+			...opts.eventScope ? { teamId: opts.eventScope.teamId } : {}
 		}));
 	}
 	const recordDroppedHistory = async (reason) => {
@@ -3153,7 +3475,8 @@ async function prepareSlackMessage(params) {
 		const skippedThreadStarter = historyMediaCandidate && isThreadReply && threadTs ? await resolveSlackThreadStarter({
 			channelId: message.channel,
 			threadTs,
-			client: ctx.app.client
+			client: slackClient,
+			workspaceScope: threadStarterWorkspaceScope
 		}) : null;
 		const senderName = pendingBody ? await resolveSenderName() : void 0;
 		await recordDroppedChannelInboundHistory({
@@ -3190,11 +3513,39 @@ async function prepareSlackMessage(params) {
 					message,
 					isThreadReply,
 					threadStarter: skippedThreadStarter,
-					isBotMessage
+					isBotMessage,
+					eventScope: opts.eventScope
 				})
 			}
 		});
 	};
+	let threadStarterPromise;
+	const getThreadStarter = () => {
+		threadStarterPromise ??= isThreadReply && threadTs ? resolveSlackThreadStarter({
+			channelId: message.channel,
+			threadTs,
+			client: slackClient,
+			workspaceScope: threadStarterWorkspaceScope
+		}) : Promise.resolve(null);
+		return threadStarterPromise;
+	};
+	const resolveMessageContent = (contentMessage, preloadedMedia) => getThreadStarter().then((threadStarter) => resolveSlackMessageContent({
+		message: contentMessage,
+		isThreadReply,
+		threadStarter,
+		isBotMessage,
+		botToken: ctx.botToken,
+		client: slackClient,
+		mediaMaxBytes: ctx.mediaMaxBytes,
+		resolveUserName: (userId) => ctx.resolveUserName(userId, opts.eventScope),
+		preloadedMedia
+	}));
+	let preloadedDirectMedia;
+	let messageContentPromise;
+	const getMessageContent = () => {
+		messageContentPromise ??= resolveMessageContent(message, preloadedDirectMedia);
+		return messageContentPromise;
+	};
 	const senderNameForAuthResult = await senderNameForAuthPromise;
 	if (!senderNameForAuthResult.ok) throw senderNameForAuthResult.error;
 	const senderNameForAuth = senderNameForAuthResult.name;
@@ -3211,7 +3562,7 @@ async function prepareSlackMessage(params) {
 		}, "skipping ambiguous slack thread reply");
 		return null;
 	}
-	const canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
+	let canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
 	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
 	const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
 	const hasAbortRequest = isAbortRequestText(textForCommandDetection);
@@ -3238,19 +3589,9 @@ async function prepareSlackMessage(params) {
 			...ctx.threadRequireExplicitMention ? { allowedImplicitMentionKinds: [] } : {}
 		}
 	});
-	const effectiveWasMentioned = messageIngress.activationAccess.effectiveWasMentioned ?? false;
-	const shouldBypassMention = messageIngress.activationAccess.shouldBypassMention ?? false;
-	const matchedImplicitMentionKinds = implicitMentionKinds;
-	const mentionSource = resolveSlackMentionSource({
-		explicitBotMention: explicitlyMentionedBotUser || opts.source === "app_mention",
-		explicitSubteamMention: explicitlyMentionedBotSubteam,
-		matchedImplicitMentionKinds,
-		shouldBypassMention,
-		wasMentioned
-	});
 	const senderGate = messageIngress.senderAccess.gate;
-	if (isRoom && senderGate?.allowed === false) {
-		logVerbose(`Blocked unauthorized slack sender ${senderId} (not in channel users)`);
+	if (isRoomish && senderGate?.allowed === false) {
+		logVerbose(`Blocked unauthorized slack sender ${senderId} (not in sender allowlist)`);
 		return null;
 	}
 	if (isRoom && isBotMessage && allowBotsMode !== "off" && !await authorizeSlackBotRoomMessage({
@@ -3259,14 +3600,9 @@ async function prepareSlackMessage(params) {
 		senderId,
 		senderName: senderNameForAuth,
 		channelUsers: channelConfig?.users,
-		allowFromLower
+		allowFromLower,
+		eventScope: opts.eventScope
 	})) return null;
-	if (isBotMessage && allowBotsMode === "mentions") {
-		if (!(isDirectMessage || effectiveWasMentioned || shouldBypassMention)) {
-			logVerbose("slack: drop bot message (allowBots=mentions, missing mention)");
-			return null;
-		}
-	}
 	const threadContextAllowFromLower = isRoom ? channelUsersAllowlistConfigured ? normalizeAllowListLower(channelConfig?.users) : [] : isDirectMessage ? allowFromLower : [];
 	const contextVisibilityMode = resolveChannelContextVisibilityMode({
 		cfg: ctx.cfg,
@@ -3283,6 +3619,104 @@ async function prepareSlackMessage(params) {
 		});
 		return null;
 	}
+	const canSeedMentionedRoomThread = !seedTopLevelRoomThreadBySource && isRoom && !routing.isThreadReply && !hasBoundSession;
+	let seededMentionRouting;
+	const getSeededMentionRouting = () => {
+		seededMentionRouting ??= resolveSlackRoutingContext({
+			ctx,
+			account,
+			message,
+			isDirectMessage,
+			isGroupDm,
+			isRoom,
+			isRoomish,
+			channelConfig,
+			seedTopLevelRoomThread: true,
+			assistantThreadTs: assistantThreadContext?.threadTs,
+			eventScope: opts.eventScope
+		});
+		return seededMentionRouting;
+	};
+	let preflightAudioTranscript;
+	let preflightAudioMedia;
+	const preflightAudioFile = findCaptionlessSlackAudioFile(message);
+	if (isRoom && !isBotMessage && shouldRequireMention && cfg.tools?.media?.audio?.enabled !== false && messageIngress.activationAccess.shouldSkip && mentionRegexes.length > 0 && Boolean(preflightAudioFile) && preflightAudioFile) {
+		const preflightRouting = canSeedMentionedRoomThread ? getSeededMentionRouting() : routing;
+		const preflightMedia = (await resolveMessageContent({
+			...message,
+			files: [preflightAudioFile],
+			attachments: void 0,
+			blocks: void 0
+		}))?.effectiveDirectMedia;
+		const downloadedAudioMedia = preflightMedia?.[0];
+		if (downloadedAudioMedia) preloadedDirectMedia = /* @__PURE__ */ new Map([[preflightAudioFile, downloadedAudioMedia]]);
+		const preflightResult = preflightMedia ? await resolveSlackPreflightAudioTranscript({
+			media: preflightMedia,
+			cfg,
+			accountId: account.accountId,
+			originatingTo: `channel:${message.channel}`,
+			sessionKey: preflightRouting.sessionKey,
+			messageThreadId: preflightRouting.threadContext.messageThreadId
+		}) : null;
+		if (preflightResult) {
+			mentionCheckTranscript = preflightResult.transcript;
+			wasMentioned = resolveWasMentioned(mentionRegexes);
+			if (wasMentioned) {
+				preflightAudioTranscript = preflightResult.transcript;
+				preflightAudioMedia = preflightMedia?.[preflightResult.mediaIndex];
+			}
+		}
+		if (!preflightAudioTranscript) {
+			await discardSlackPreflightMedia(preflightMedia);
+			preloadedDirectMedia = void 0;
+		}
+	}
+	if (canSeedMentionedRoomThread && wasMentioned) {
+		routing = getSeededMentionRouting();
+		mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
+		wasMentioned = resolveWasMentioned(mentionRegexes);
+		({route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey, historyKey} = routing);
+		canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
+	}
+	if (preflightAudioTranscript && !wasMentioned) {
+		await discardSlackPreflightMedia(preloadedDirectMedia ? [...preloadedDirectMedia.values()] : void 0);
+		preloadedDirectMedia = void 0;
+		preflightAudioTranscript = void 0;
+		preflightAudioMedia = void 0;
+	}
+	const directThreadRoutedToDmSession = !assistantThreadContext && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
+	const mentionDecision = resolveInboundMentionDecision({
+		facts: {
+			canDetectMention,
+			wasMentioned,
+			hasAnyMention,
+			implicitMentionKinds
+		},
+		policy: {
+			isGroup: isRoom,
+			requireMention: shouldRequireMention,
+			allowTextCommands,
+			hasControlCommand: hasControlCommandInMessage,
+			commandAuthorized,
+			...ctx.threadRequireExplicitMention ? { allowedImplicitMentionKinds: [] } : {}
+		}
+	});
+	const effectiveWasMentioned = mentionDecision.effectiveWasMentioned;
+	const shouldBypassMention = mentionDecision.shouldBypassMention;
+	const matchedImplicitMentionKinds = mentionDecision.matchedImplicitMentionKinds;
+	const mentionSource = resolveSlackMentionSource({
+		explicitBotMention: explicitlyMentionedBotUser || opts.source === "app_mention",
+		explicitSubteamMention: explicitlyMentionedBotSubteam,
+		matchedImplicitMentionKinds,
+		shouldBypassMention,
+		wasMentioned
+	});
+	if (isBotMessage && allowBotsMode === "mentions") {
+		if (!(isDirectMessage || effectiveWasMentioned || shouldBypassMention)) {
+			logVerbose("slack: drop bot message (allowBots=mentions, missing mention)");
+			return null;
+		}
+	}
 	if (isRoom && shouldRequireMention && !canDetectMention && !effectiveWasMentioned) {
 		ctx.logger.info({
 			channel: message.channel,
@@ -3302,7 +3736,7 @@ async function prepareSlackMessage(params) {
 		await recordDroppedHistory("slack-other-mention");
 		return null;
 	}
-	if (isRoom && shouldRequireMention && messageIngress.activationAccess.shouldSkip) {
+	if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) {
 		ctx.logger.info({
 			channel: message.channel,
 			reason: "no-mention"
@@ -3310,11 +3744,6 @@ async function prepareSlackMessage(params) {
 		await recordDroppedHistory("slack-no-mention");
 		return null;
 	}
-	const threadStarterPromise = isThreadReply && threadTs ? resolveSlackThreadStarter({
-		channelId: message.channel,
-		threadTs,
-		client: ctx.app.client
-	}) : Promise.resolve(null);
 	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
 	const inboundEventKind = classifyChannelInboundEvent({
 		conversation: { kind: chatType },
@@ -3326,19 +3755,14 @@ async function prepareSlackMessage(params) {
 		hasControlCommand: hasControlCommandInMessage,
 		hasAbortRequest
 	});
-	const threadStarter = await threadStarterPromise;
-	const resolvedMessageContent = await resolveSlackMessageContent({
-		message,
-		isThreadReply,
-		threadStarter,
-		isBotMessage,
-		botToken: ctx.botToken,
-		client: ctx.app.client,
-		mediaMaxBytes: ctx.mediaMaxBytes,
-		resolveUserName: ctx.resolveUserName
-	});
+	const threadStarter = await getThreadStarter();
+	const resolvedMessageContent = await getMessageContent();
 	if (!resolvedMessageContent) return null;
 	const { rawBody, effectiveDirectMedia } = resolvedMessageContent;
+	const bodyForAgent = preflightAudioTranscript ? formatSlackAudioTranscriptForAgent({
+		transcript: preflightAudioTranscript,
+		rawBody
+	}) : rawBody;
 	const ackReaction = resolveAckReaction(cfg, route.agentId, {
 		channel: "slack",
 		accountId: account.accountId
@@ -3370,14 +3794,14 @@ async function prepareSlackMessage(params) {
 	const statusReactionsWillHandle = Boolean(ackReactionMessageTs) && !isRoomEvent && statusReactionsExplicitlyEnabled && shouldSendAckReaction;
 	const ackReactionPromise = !statusReactionsWillHandle && shouldSendAckReaction && ackReactionMessageTs && ackReactionValue ? reactSlackMessage(message.channel, ackReactionMessageTs, ackReactionValue, {
 		token: ctx.botToken,
-		client: ctx.app.client
+		client: slackClient
 	}).then(() => true, (err) => {
 		logVerbose(`slack react failed for channel ${message.channel}: ${formatSlackError(err)}`);
 		return false;
 	}) : statusReactionsWillHandle ? Promise.resolve(true) : null;
 	const roomLabel = channelName ? `#${channelName}` : `#${message.channel}`;
 	const senderName = await resolveSenderName();
-	const preview = rawBody.replace(/\s+/g, " ").slice(0, 160);
+	const preview = truncateUtf16Safe(bodyForAgent.replace(/\s+/g, " "), 160);
 	const inboundLabel = isDirectMessage ? `Slack DM from ${senderName}` : `Slack message in ${roomLabel} from ${senderName}`;
 	const slackFrom = isDirectMessage ? `slack:${message.user}` : isRoom ? `slack:channel:${message.channel}` : `slack:group:${message.channel}`;
 	enqueueSystemEvent(inboundLabel, {
@@ -3391,7 +3815,7 @@ async function prepareSlackMessage(params) {
 		From: slackFrom
 	}) ?? (isDirectMessage ? senderName : roomLabel);
 	const threadInfo = isThreadReply && threadTs ? ` thread_ts: ${threadTs}${message.parent_user_id ? ` parent_user_id: ${message.parent_user_id}` : ""}` : "";
-	const textWithId = `${rawBody}\n[slack message id: ${message.ts} channel: ${message.channel}${threadInfo}]`;
+	const textWithId = `${bodyForAgent}\n[slack message id: ${message.ts} channel: ${message.channel}${threadInfo}]`;
 	const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId });
 	const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
 	const previousTimestamp = readSessionUpdatedAt({
@@ -3426,7 +3850,8 @@ async function prepareSlackMessage(params) {
 		channelId: message.channel,
 		currentMessageTs: message.ts,
 		limit: dmHistoryLimit,
-		envelopeOptions
+		envelopeOptions,
+		eventScope: opts.eventScope
 	}) : {
 		body: void 0,
 		inboundHistory: void 0
@@ -3467,9 +3892,11 @@ async function prepareSlackMessage(params) {
 		allowNameMatching: ctx.allowNameMatching,
 		contextVisibilityMode,
 		envelopeOptions,
-		effectiveDirectMedia
+		effectiveDirectMedia,
+		eventScope: opts.eventScope
 	});
 	const effectiveMedia = effectiveDirectMedia ?? threadStarterMedia;
+	const inboundMedia = toInboundMediaFacts(effectiveMedia, { transcribed: (entry) => effectiveMedia === effectiveDirectMedia && entry === preflightAudioMedia });
 	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? channelHistory.buildInboundHistory({
 		historyKey,
 		limit: ctx.historyLimit
@@ -3480,7 +3907,7 @@ async function prepareSlackMessage(params) {
 	const ctxPayload = buildChannelInboundEventContext({
 		channel: "slack",
 		accountId: route.accountId,
-		messageId: message.ts,
+		messageId: threadContext.messageTs,
 		timestamp: resolveSlackTimestampMs(message.ts),
 		from: slackFrom,
 		sender: {
@@ -3493,7 +3920,7 @@ async function prepareSlackMessage(params) {
 			kind: chatType,
 			id: message.channel,
 			label: envelopeFrom,
-			spaceId: ctx.teamId || void 0,
+			spaceId: opts.eventScope?.teamId || ctx.teamId || void 0,
 			threadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
 			nativeChannelId: message.channel
 		},
@@ -3512,7 +3939,7 @@ async function prepareSlackMessage(params) {
 		message: {
 			inboundEventKind,
 			body: combinedBody,
-			bodyForAgent: rawBody,
+			bodyForAgent,
 			rawBody,
 			commandBody,
 			inboundHistory
@@ -3528,7 +3955,7 @@ async function prepareSlackMessage(params) {
 			},
 			commands: { authorized: commandAuthorized }
 		},
-		media: toInboundMediaFacts(effectiveMedia),
+		media: inboundMedia,
 		supplemental: {
 			thread: {
 				starterBody: !directThreadRoutedToDmSession && shouldSeedInitialThreadContext ? threadStarterBody : void 0,
@@ -3545,6 +3972,7 @@ async function prepareSlackMessage(params) {
 			SlackAssistantThreadContextChannelId: assistantThreadContext?.channelId,
 			SlackAssistantThreadContextTeamId: assistantThreadContext?.teamId,
 			SlackAssistantThreadContextEnterpriseId: assistantThreadContext?.enterpriseId ?? void 0,
+			Transcript: preflightAudioTranscript,
 			IsFirstThreadTurn: isThreadReply && threadTs && !directThreadRoutedToDmSession && shouldSeedInitialThreadContext ? true : void 0,
 			...buildSlackMentionContextPayload({
 				isRoomish,
@@ -3575,6 +4003,13 @@ async function prepareSlackMessage(params) {
 	}) : null;
 	const replyTarget = isDirectMessage ? `channel:${message.channel}` : ctxPayload.To ?? void 0;
 	if (!replyTarget) return null;
+	if (preflightAudioTranscript) await sendSlackPreflightAudioTranscriptEcho({
+		transcript: preflightAudioTranscript,
+		cfg,
+		accountId: account.accountId,
+		originatingTo: `channel:${message.channel}`,
+		messageThreadId: threadContext.messageThreadId
+	});
 	if (shouldLogVerbose()) logVerbose(`slack inbound: account=${route.accountId} agent=${route.agentId} channel=${message.channel} message_ts=${message.ts ?? "unknown"} thread_ts=${effectiveMessageThreadId ?? "none"} from=${slackFrom} chat=${chatType} chars=${rawBody.length}`);
 	const updateLastRouteSessionKey = resolveInboundLastRouteSessionKey({
 		route,
@@ -3585,6 +4020,7 @@ async function prepareSlackMessage(params) {
 		account,
 		message,
 		...opts.relayIdentity ? { relayIdentity: opts.relayIdentity } : {},
+		...opts.eventScope ? { eventScope: opts.eventScope } : {},
 		route,
 		channelConfig,
 		replyTarget,