@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/.setup/pipeline.runtime-qFsXbTJf.mjs

@@ -0,0 +1,3646 @@
+import { t as resolveSlackReplyToMode } from "./account-reply-mode-Bvoq75cS.mjs";
+import { r as parseSlackTarget } from "./target-parsing-C36VFWHQ.mjs";
+import "./targets-DnpzC22e.mjs";
+import { a as SLACK_TEXT_LIMIT, b as truncateSlackText, c as formatSlackError, d as normalizeAllowListLower, f as normalizeSlackAllowOwnerEntry, m as resolveSlackAllowListMatch } from "./reply-blocks-Cwu6LYJI.mjs";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-BLw4HEPS.mjs";
+import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-DjlgH-Be.mjs";
+import { c as recordSlackThreadParticipation, r as sendMessageSlack, s as hasSlackThreadParticipationWithPersistence } from "./send-DEOvcVM4.mjs";
+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-2VEX4Wdz.mjs";
+import { n as normalizeSlackOutboundText } from "./format-xuAop9a-.mjs";
+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-Bjv1R5E2.mjs";
+import { n as resolveSlackChannelConfig } from "./policy-C6VVHqUf.mjs";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-BO37R07g.mjs";
+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 { 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 { 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 { 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 { 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";
+import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
+import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
+import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
+//#region extensions/slack/src/draft-stream.ts
+const DEFAULT_THROTTLE_MS = 1e3;
+function createSlackDraftStream(params) {
+	const maxChars = Math.min(params.maxChars ?? 8e3, SLACK_TEXT_LIMIT);
+	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+	const send = params.send ?? sendMessageSlack;
+	const edit = params.edit ?? editSlackMessage;
+	const remove = params.remove ?? deleteSlackMessage;
+	let streamMessageId;
+	let streamChannelId;
+	let lastSentKey = "";
+	let pendingUpdate;
+	let stopped = false;
+	const normalizeUpdate = (update) => typeof update === "string" ? { text: update } : update;
+	const sendOrEditStreamMessage = async (text) => {
+		if (stopped) return;
+		const trimmed = text.trimEnd();
+		if (!trimmed) return;
+		if (trimmed.length > maxChars) {
+			stopped = true;
+			params.warn?.(`slack stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+			return;
+		}
+		const update = normalizeUpdate(pendingUpdate ?? text);
+		const blocks = update.text === text ? update.blocks : void 0;
+		const sentKey = `${trimmed}\n${blocks ? JSON.stringify(blocks) : ""}`;
+		if (sentKey === lastSentKey) return;
+		lastSentKey = sentKey;
+		try {
+			if (streamChannelId && streamMessageId) {
+				await edit(streamChannelId, streamMessageId, trimmed, {
+					cfg: params.cfg,
+					token: params.token,
+					accountId: params.accountId,
+					...blocks ? { blocks } : {}
+				});
+				return;
+			}
+			const sent = await send(params.target, trimmed, {
+				cfg: params.cfg,
+				token: params.token,
+				accountId: params.accountId,
+				threadTs: params.resolveThreadTs?.(),
+				identity: params.identity,
+				...params.metadata ? { metadata: params.metadata } : {},
+				...blocks ? { blocks } : {}
+			});
+			streamChannelId = sent.channelId || streamChannelId;
+			streamMessageId = sent.messageId || streamMessageId;
+			if (!streamChannelId || !streamMessageId) {
+				stopped = true;
+				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
+				return;
+			}
+			params.onMessageSent?.();
+		} catch (err) {
+			stopped = true;
+			params.warn?.(`slack stream preview failed: ${formatSlackError(err)}`);
+		}
+	};
+	const loop = createDraftStreamLoop({
+		throttleMs,
+		isStopped: () => stopped,
+		sendOrEditStreamMessage
+	});
+	const stop = () => {
+		stopped = true;
+		loop.stop();
+	};
+	const discardPending = async () => {
+		stop();
+		await loop.waitForInFlight();
+	};
+	const clear = async () => {
+		await discardPending();
+		const channelId = streamChannelId;
+		const messageId = streamMessageId;
+		streamChannelId = void 0;
+		streamMessageId = void 0;
+		lastSentKey = "";
+		pendingUpdate = void 0;
+		if (!channelId || !messageId) return;
+		try {
+			await remove(channelId, messageId, {
+				token: params.token,
+				accountId: params.accountId
+			});
+		} catch (err) {
+			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
+		}
+	};
+	const forceNewMessage = () => {
+		streamMessageId = void 0;
+		streamChannelId = void 0;
+		lastSentKey = "";
+		pendingUpdate = void 0;
+		loop.resetPending();
+	};
+	params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+	return {
+		update: (update) => {
+			const normalized = normalizeUpdate(update);
+			pendingUpdate = update;
+			loop.update(normalized.text);
+		},
+		flush: loop.flush,
+		clear,
+		discardPending,
+		seal: discardPending,
+		stop,
+		forceNewMessage,
+		messageId: () => streamMessageId,
+		channelId: () => streamChannelId
+	};
+}
+//#endregion
+//#region extensions/slack/src/progress-blocks.ts
+const SLACK_PROGRESS_FIELD_MAX = 1800;
+const DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS = 120;
+const DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS = 48;
+const SLACK_PROGRESS_CHUNK_TEXT_MAX = 256;
+const SLACK_PROGRESS_TASK_TITLE_MAX = 120;
+const SLACK_PROGRESS_PLAN_FALLBACK_TITLE = "Thinking";
+function field(text) {
+	return {
+		type: "mrkdwn",
+		text: truncateSlackText(text, SLACK_PROGRESS_FIELD_MAX)
+	};
+}
+function resolveMaxLineChars(value, fallback) {
+	return value && value > 0 ? Math.floor(value) : fallback;
+}
+function compactDetail(value, maxChars) {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	const chars = Array.from(normalized);
+	if (chars.length <= maxChars) return normalized;
+	if (maxChars <= 1) return "…";
+	const keepStart = Math.max(1, Math.ceil((maxChars - 1) * .45));
+	const keepEnd = Math.max(1, maxChars - keepStart - 1);
+	return `${chars.slice(0, keepStart).join("").trimEnd()}…${chars.slice(-keepEnd).join("").trimStart()}`;
+}
+function compactTitle(value) {
+	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_TASK_TITLE_MAX);
+}
+function compactChunkText(value) {
+	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
+}
+function lineDetailParts(line) {
+	return [line.detail, line.status && line.status !== "completed" && !line.detail?.includes(line.status) ? line.status : void 0].map((part) => part?.trim()).filter((part) => Boolean(part));
+}
+function legacyLineTitle(line) {
+	return `${line.icon ?? "•"} *${escapeSlackMrkdwn(line.label)}*`;
+}
+function legacyLineDetail(line, maxChars) {
+	const detail = lineDetailParts(line).join(" · ");
+	return detail ? escapeSlackMrkdwn(compactDetail(detail, maxChars)) : "—";
+}
+function lineTaskTitle(line, maxLineChars) {
+	const label = line.label.replace(/\s+/g, " ").trim() || line.toolName || line.kind || "Update";
+	const detail = lineDetailParts(line).join(" · ") || line.status?.trim();
+	const fallback = line.text.replace(/\s+/g, " ").trim();
+	if (detail) return compactTitle(`${label} — ${compactDetail(detail, maxLineChars)}`);
+	if (fallback && fallback !== label) return compactTitle(fallback);
+	return compactTitle(label);
+}
+function lineTaskStatus(line) {
+	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
+	if (!normalized) return "in_progress";
+	if (normalized === "complete" || normalized === "completed" || normalized === "done" || normalized === "ok" || normalized === "success" || normalized === "succeeded" || normalized === "successful" || normalized === "exit 0") return "complete";
+	if (normalized === "error" || normalized === "failed" || normalized === "failure" || normalized.startsWith("exit ")) return normalized === "exit 0" ? "complete" : "error";
+	return "in_progress";
+}
+function slugTaskIdPart(value) {
+	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
+}
+function stableTaskIdPart(value) {
+	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
+	return `${slugTaskIdPart(value)}_${suffix}`;
+}
+function buildPlanTasks(params) {
+	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}`,
+		title: lineTaskTitle(line, maxLineChars),
+		status: lineTaskStatus(line)
+	}));
+}
+function resolvePlanTitle(params) {
+	return compactChunkText(params.title?.trim() || params.label?.trim() || params.tasks.at(-1)?.title || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
+}
+function buildSlackProgressStreamChunks(params) {
+	const tasks = buildPlanTasks({
+		lines: params.lines,
+		maxLineChars: params.maxLineChars
+	});
+	if (tasks.length === 0) return;
+	return [{
+		type: "plan_update",
+		title: resolvePlanTitle({
+			label: params.label,
+			title: params.title,
+			tasks
+		})
+	}, ...tasks.map((task) => ({
+		type: "task_update",
+		id: task.id,
+		title: task.title,
+		status: task.status === "in_progress" ? params.finalInProgressStatus ?? (params.completeInProgress ? "complete" : task.status) : task.status
+	}))];
+}
+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) => ({
+		type: "section",
+		fields: [field(legacyLineTitle(line)), field(legacyLineDetail(line, maxLineChars))]
+	}))].slice(-50);
+	return renderedBlocks.length ? renderedBlocks : void 0;
+}
+function buildSlackProgressStreamStartChunks(params) {
+	return buildSlackProgressStreamChunks(params);
+}
+function buildSlackProgressStreamUpdateChunks(params) {
+	return buildSlackProgressStreamChunks(params);
+}
+function buildSlackProgressStreamCompletionChunks(params) {
+	return buildSlackProgressStreamChunks({
+		...params,
+		completeInProgress: true
+	});
+}
+//#endregion
+//#region extensions/slack/src/stream-mode.ts
+function resolveSlackStreamingConfig(params) {
+	const mode = resolveSlackStreamingMode(params);
+	return {
+		mode,
+		nativeStreaming: resolveSlackNativeStreaming(params),
+		draftMode: mapStreamingModeToSlackLegacyDraftStreamMode(mode)
+	};
+}
+function applyAppendOnlyStreamUpdate(params) {
+	const incoming = params.incoming.trimEnd();
+	if (!incoming) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (!params.rendered) return {
+		rendered: incoming,
+		source: incoming,
+		changed: true
+	};
+	if (incoming === params.source) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (incoming.startsWith(params.source) || incoming.startsWith(params.rendered)) return {
+		rendered: incoming,
+		source: incoming,
+		changed: incoming !== params.rendered
+	};
+	if (params.source.startsWith(incoming)) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	const separator = params.rendered.endsWith("\n") ? "" : "\n";
+	return {
+		rendered: `${params.rendered}${separator}${incoming}`,
+		source: incoming,
+		changed: true
+	};
+}
+//#endregion
+//#region extensions/slack/src/streaming.ts
+/**
+* Thrown when Slack definitively rejects a stream flush/finalize while text
+* remains buffered locally by the Slack SDK. Carries the pending text so the
+* caller can deliver it via the normal Slack reply path.
+*/
+var SlackStreamNotDeliveredError = class extends Error {
+	constructor(pendingText, slackCode) {
+		super(`slack-stream: finalize failed with ${slackCode} before buffered text reached Slack (${pendingText.length} chars pending)`);
+		this.name = "SlackStreamNotDeliveredError";
+		this.pendingText = pendingText;
+		this.slackCode = slackCode;
+	}
+};
+/**
+* Start a new Slack text stream.
+*
+* Returns a {@link SlackStreamSession} that should be passed to
+* {@link appendSlackStream} and {@link stopSlackStream}.
+*
+* The first chunk of text can optionally be included via `text`.
+*/
+async function startSlackStream(params) {
+	const { client, channel, threadTs, text, chunks, taskDisplayMode, teamId, userId, identity } = params;
+	const identityPayload = identity?.iconUrl ? {
+		...identity.username ? { username: identity.username } : {},
+		icon_url: identity.iconUrl
+	} : identity?.iconEmoji ? {
+		...identity.username ? { username: identity.username } : {},
+		icon_emoji: identity.iconEmoji
+	} : identity?.username ? { username: identity.username } : {};
+	logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}${teamId ? ` team=${teamId}` : ""}${userId ? ` user=${userId}` : ""}`);
+	const streamer = client.chatStream({
+		channel,
+		thread_ts: threadTs,
+		...taskDisplayMode ? { task_display_mode: taskDisplayMode } : {},
+		...teamId ? { recipient_team_id: teamId } : {},
+		...userId ? { recipient_user_id: userId } : {},
+		...identityPayload
+	});
+	const session = {
+		streamer,
+		channel,
+		threadTs,
+		stopped: false,
+		delivered: false,
+		pendingText: ""
+	};
+	if (text || chunks?.length) {
+		if (text) session.pendingText += text;
+		try {
+			const result = await streamer.append({
+				...text ? { markdown_text: text } : {},
+				...chunks?.length ? { chunks } : {}
+			});
+			if (result) {
+				session.delivered = true;
+				session.pendingText = "";
+			}
+			logVerbose(`slack-stream: appended initial payload (${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks, ${result ? "flushed" : "buffered"})`);
+		} catch (err) {
+			if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
+			throw err;
+		}
+	}
+	return session;
+}
+/**
+* Append markdown text to an active Slack stream.
+*/
+async function appendSlackStream(params) {
+	const { session, text, chunks } = params;
+	if (session.stopped) {
+		logVerbose("slack-stream: attempted to append to a stopped stream, ignoring");
+		return;
+	}
+	if (!text && !chunks?.length) return;
+	if (text) session.pendingText += text;
+	try {
+		const result = await session.streamer.append({
+			...text ? { markdown_text: text } : {},
+			...chunks?.length ? { chunks } : {}
+		});
+		if (result) {
+			session.delivered = true;
+			session.pendingText = "";
+		}
+		logVerbose(`slack-stream: appended ${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks (${result ? "flushed" : "buffered"})`);
+	} catch (err) {
+		if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
+		throw err;
+	}
+}
+/**
+* Stop (finalize) a Slack stream.
+*
+* After calling this the stream message becomes a normal Slack message.
+* Optionally include final text to append before stopping.
+*
+* If Slack's `chat.stopStream` responds with a definitive recipient/channel
+* rejection while text is still buffered locally, this function throws a
+* {@link SlackStreamNotDeliveredError} carrying that pending text so the caller
+* can deliver it through the normal Slack reply path. Ambiguous failures
+* propagate unchanged because Slack may have committed the request.
+*
+* If Slack responds with a known benign finalize error (see
+* {@link BENIGN_SLACK_FINALIZE_ERROR_CODES}) after prior `append` calls already
+* landed, the error is swallowed and the session is marked stopped - the
+* already-delivered text stays visible.
+*
+* Errors without buffered text propagate unchanged.
+*
+* On success, returns the finalized message's Slack `ts` (when reported) so the
+* caller can emit the `message_sent` hook with a populated `messageId`.
+*/
+async function stopSlackStream(params) {
+	const { session, text, chunks, metadata } = params;
+	if (session.stopped) {
+		logVerbose("slack-stream: stream already stopped, ignoring duplicate stop");
+		return {};
+	}
+	session.stopped = true;
+	if (text) session.pendingText += text;
+	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}${text ? ` (final text: ${text.length} chars)` : ""}`);
+	try {
+		const stopResponse = await session.streamer.stop(text || chunks?.length || metadata ? {
+			...text ? { markdown_text: text } : {},
+			...chunks?.length ? { chunks } : {},
+			...metadata ? { metadata } : {}
+		} : void 0);
+		session.delivered = true;
+		session.pendingText = "";
+		logVerbose("slack-stream: stream stopped");
+		const messageId = stopResponse?.ts ?? stopResponse?.message?.ts;
+		return messageId ? { messageId } : {};
+	} catch (err) {
+		const code = extractSlackErrorCode(err) ?? "unknown";
+		const benignFinalizeError = isBenignSlackFinalizeError(err);
+		if (session.pendingText && (benignFinalizeError || code === "missing_scope")) throw new SlackStreamNotDeliveredError(session.pendingText, code);
+		if (benignFinalizeError) {
+			if (session.delivered) {
+				logVerbose(`slack-stream: finalize rejected by Slack (${code}); prior appends delivered, treating stream as stopped`);
+				return {};
+			}
+		}
+		throw err;
+	}
+}
+/**
+* Slack API error codes that indicate `chat.stopStream` (or the
+* `chat.startStream` call the SDK issues inside `stop()` when the buffer
+* never flushed) cannot finalize the stream for the current recipient or
+* team. Either the caller falls back to a normal message (see
+* {@link SlackStreamNotDeliveredError}) or, if prior appends already
+* delivered text, the error is logged verbosely and swallowed.
+*/
+const BENIGN_SLACK_FINALIZE_ERROR_CODES = /* @__PURE__ */ new Set([
+	"user_not_found",
+	"team_not_found",
+	"missing_recipient_user_id",
+	"method_not_supported_for_channel_type"
+]);
+function isBenignSlackFinalizeError(err) {
+	const code = extractSlackErrorCode(err);
+	return code !== void 0 && BENIGN_SLACK_FINALIZE_ERROR_CODES.has(code);
+}
+function extractSlackErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const record = err;
+	if (record.data && typeof record.data === "object") {
+		const inner = record.data.error;
+		if (typeof inner === "string") return inner;
+	}
+	return (typeof record.message === "string" ? record.message : "").match(/An API error occurred:\s*([a-z_][a-z0-9_]*)/i)?.[1];
+}
+function markSlackStreamFallbackDelivered(session) {
+	const nativeStreamWasStarted = session.delivered;
+	session.pendingText = "";
+	session.streamer.buffer = "";
+	session.stopped = !nativeStreamWasStarted;
+}
+//#endregion
+//#region extensions/slack/src/threading.ts
+function resolveSlackThreadContext(params) {
+	const incomingThreadTs = params.message.thread_ts;
+	const eventTs = params.message.event_ts;
+	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 isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
+	return {
+		incomingThreadTs,
+		messageTs,
+		isThreadReply,
+		replyToId,
+		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
+	};
+}
+/**
+* Resolves Slack thread targeting for replies and status indicators.
+*
+* @returns replyThreadTs - Thread timestamp for reply messages
+* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
+* @returns isThreadReply - true if this is a genuine user reply in a thread,
+*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
+*/
+function resolveSlackThreadTargets(params) {
+	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
+	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
+	return {
+		replyThreadTs,
+		statusThreadTs: replyThreadTs,
+		isThreadReply
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
+function buildExpectedSlackEditText(params) {
+	return buildSlackEditTextPayload(params.text, params.blocks);
+}
+function blocksMatch(expected, actual) {
+	if (!expected?.length) return !actual?.length;
+	if (!actual?.length) return false;
+	return JSON.stringify(expected) === JSON.stringify(actual);
+}
+async function readSlackMessageAfterEditError(params) {
+	if (params.threadTs) return ((await params.client.conversations.replies({
+		token: params.token,
+		channel: params.channelId,
+		ts: params.threadTs,
+		latest: params.messageId,
+		inclusive: true,
+		limit: 100
+	})).messages ?? []).find((message) => message?.ts === params.messageId) ?? null;
+	const message = (await params.client.conversations.history({
+		token: params.token,
+		channel: params.channelId,
+		latest: params.messageId,
+		oldest: params.messageId,
+		inclusive: true,
+		limit: 1
+	})).messages?.[0];
+	if (!message?.ts || message.ts !== params.messageId) return null;
+	return message;
+}
+async function didSlackPreviewEditApplyAfterError(params) {
+	const readback = await readSlackMessageAfterEditError(params);
+	if (!readback) return false;
+	const expectedText = buildExpectedSlackEditText({
+		text: params.text,
+		blocks: params.blocks
+	});
+	const actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
+	if (params.blocks?.length) return actualText === expectedText && blocksMatch(params.blocks, readback.blocks);
+	return actualText === expectedText;
+}
+async function finalizeSlackPreviewEdit(params) {
+	try {
+		await editSlackMessage(params.channelId, params.messageId, params.text, {
+			token: params.token,
+			accountId: params.accountId,
+			client: params.client,
+			...params.blocks?.length ? { blocks: params.blocks } : {}
+		});
+	} catch (err) {
+		try {
+			if (await didSlackPreviewEditApplyAfterError({
+				client: params.client,
+				token: params.token,
+				channelId: params.channelId,
+				messageId: params.messageId,
+				text: params.text,
+				blocks: params.blocks,
+				threadTs: params.threadTs
+			})) {
+				logVerbose(`slack: preview final edit response failed but readback matched message ${params.channelId}/${params.messageId}; suppressing duplicate fallback send`);
+				return;
+			}
+		} catch (readbackErr) {
+			logVerbose(`slack: preview final edit readback failed (${String(readbackErr)})`);
+		}
+		throw err;
+	}
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/timestamp.ts
+const SLACK_TIMESTAMP_RE = /^\d+(?:\.\d+)?$/;
+const MAX_SAFE_SLACK_TIMESTAMP_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
+function resolveSlackTimestampMs(ts) {
+	const trimmed = ts?.trim();
+	if (!trimmed || !SLACK_TIMESTAMP_RE.test(trimmed)) return;
+	const seconds = asFiniteNumberInRange(parseStrictFiniteNumber(trimmed), {
+		min: 0,
+		max: MAX_SAFE_SLACK_TIMESTAMP_SECONDS
+	});
+	return seconds === void 0 ? void 0 : Math.round(seconds * 1e3);
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch.ts
+const SLACK_REASONING_TAG_RE = /<\s*(\/?)\s*(?:(?:antml:|mm:)?(?:think(?:ing)?|thought)|antthinking)\b[^<>]*>/gi;
+const SLACK_REASONING_LABEL_PREFIX_RE = /^\s*(?:>\s*)?Reasoning:\s*/iu;
+const SLACK_THINKING_LABEL_PREFIX_RE = /^\s*(?:>\s*)?Thinking\.{0,3}(?=\s*(?:\n|_))/iu;
+const SLACK_THREAD_LOADING_MESSAGES = [
+	"Reading the thread...",
+	"Checking context...",
+	"Working through the request...",
+	"Putting it all together..."
+];
+function resolveSlackMessageTimestampMs(message) {
+	return resolveSlackTimestampMs(message.event_ts ?? message.ts);
+}
+function resolveSlackBotLoopProtection(prepared) {
+	const senderBotId = prepared.message.bot_id;
+	if (!senderBotId) return;
+	const receiverBotId = prepared.ctx.botId || prepared.ctx.botUserId;
+	if (!receiverBotId || senderBotId === prepared.ctx.botId || prepared.message.user === prepared.ctx.botUserId) return;
+	return {
+		scopeId: prepared.route.accountId,
+		conversationId: prepared.message.channel,
+		senderId: senderBotId,
+		receiverId: receiverBotId,
+		config: mergePairLoopGuardConfig(prepared.account.config.botLoopProtection, prepared.channelConfig?.botLoopProtection),
+		defaultsConfig: prepared.ctx.cfg.channels?.defaults?.botLoopProtection,
+		defaultEnabled: true,
+		nowMs: resolveSlackMessageTimestampMs(prepared.message)
+	};
+}
+function isSlackStreamingEnabled(params) {
+	if (params.mode === "partial") return params.nativeStreaming;
+	if (params.mode === "progress") return params.nativeStreaming && params.nativeProgressTaskCards === true;
+	return false;
+}
+function shouldEnableSlackPreviewStreaming(params) {
+	return params.mode !== "off";
+}
+function shouldInitializeSlackDraftStream(params) {
+	return params.previewStreamingEnabled && !params.useStreaming;
+}
+function resolveSlackDisableBlockStreaming(params) {
+	if (params.useStreaming || params.shouldUseDraftStream) return true;
+	return typeof params.blockStreamingEnabled === "boolean" ? !params.blockStreamingEnabled : void 0;
+}
+function resolveExplicitSlackProgressTitle(entry) {
+	const label = resolveChannelProgressDraftConfig(entry).label;
+	if (typeof label !== "string") return;
+	const trimmed = label.trim();
+	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
+}
+function resolveSlackNativeProgressTaskCards(entry) {
+	const streaming = entry?.streaming;
+	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return false;
+	const progressConfig = streaming.progress;
+	return Boolean(progressConfig) && typeof progressConfig === "object" && !Array.isArray(progressConfig) && progressConfig.nativeTaskCards === true;
+}
+function resolveSlackStreamingThreadHint(params) {
+	return resolveSlackThreadTs({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: false,
+		isThreadReply: params.isThreadReply
+	});
+}
+const SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
+const slackStreamRecipientTeamCache = /* @__PURE__ */ new Map();
+function buildSlackEventDeliveryKey(params) {
+	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
+	const slackBlocks = readSlackReplyBlocks(params.payload);
+	if (!reply.hasContent && !slackBlocks?.length) return null;
+	return JSON.stringify({
+		kind: params.kind,
+		threadTs: params.threadTs ?? "",
+		replyToId: params.payload.replyToId ?? null,
+		text: reply.trimmedText,
+		mediaUrls: reply.mediaUrls,
+		blocks: slackBlocks ?? null
+	});
+}
+function readSlackStreamRecipientTeamCache(params) {
+	if (!params.fallbackTeamId || !params.userId) return;
+	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
+	const cached = slackStreamRecipientTeamCache.get(cacheKey);
+	if (!cached) return;
+	slackStreamRecipientTeamCache.delete(cacheKey);
+	slackStreamRecipientTeamCache.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);
+	}
+}
+function normalizeSlackReasoningProgressLine(text) {
+	return (extractSlackReasoningTagText(text) || stripReasoningTagsFromText(text, {
+		mode: "strict",
+		trim: "both"
+	})).replace(SLACK_REASONING_LABEL_PREFIX_RE, "").replace(SLACK_THINKING_LABEL_PREFIX_RE, "").split(/\r?\n/u).map((line) => stripSimpleItalicMarkers(line)).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+}
+function extractSlackReasoningTagText(text) {
+	if (!text) return "";
+	let result = "";
+	let lastIndex = 0;
+	let inReasoning = false;
+	SLACK_REASONING_TAG_RE.lastIndex = 0;
+	for (const match of text.matchAll(SLACK_REASONING_TAG_RE)) {
+		const index = match.index ?? 0;
+		if (inReasoning) result += text.slice(lastIndex, index);
+		inReasoning = match[1] !== "/";
+		lastIndex = index + match[0].length;
+	}
+	if (inReasoning) result += text.slice(lastIndex);
+	return result.trim();
+}
+function stripSimpleItalicMarkers(line) {
+	const trimmed = line.trim();
+	if (trimmed.length >= 2 && trimmed.startsWith("_") && trimmed.endsWith("_")) return trimmed.slice(1, -1).trim();
+	return trimmed;
+}
+function mergeSlackReasoningProgressText(current, incoming, options) {
+	if (!current) return incoming;
+	const normalizedCurrent = normalizeSlackReasoningProgressLine(current);
+	const normalizedIncoming = normalizeSlackReasoningProgressLine(incoming);
+	if (!normalizedIncoming || normalizedIncoming === normalizedCurrent) return current;
+	if (options?.snapshot === true || isSlackReasoningSnapshotText(incoming) || normalizedIncoming.startsWith(normalizedCurrent)) return incoming;
+	return `${current}${incoming}`;
+}
+function isSlackReasoningSnapshotText(text) {
+	return SLACK_REASONING_LABEL_PREFIX_RE.test(text) || SLACK_THINKING_LABEL_PREFIX_RE.test(text);
+}
+function createSlackEventDeliveryTracker() {
+	const deliveredKeys = /* @__PURE__ */ new Set();
+	return {
+		hasDelivered(params) {
+			const key = buildSlackEventDeliveryKey(params);
+			return key ? deliveredKeys.has(key) : false;
+		},
+		markDelivered(params) {
+			const key = buildSlackEventDeliveryKey(params);
+			if (key) deliveredKeys.add(key);
+		}
+	};
+}
+function shouldUseStreaming(params) {
+	if (!params.streamingEnabled) return false;
+	if (!params.threadTs) {
+		logVerbose("slack-stream: streaming disabled — no reply thread target available");
+		return false;
+	}
+	return true;
+}
+async function resolveSlackStreamRecipientTeamId(params) {
+	const cachedTeamId = readSlackStreamRecipientTeamCache(params);
+	if (cachedTeamId) return cachedTeamId;
+	if (params.userId) try {
+		const info = await params.client.users.info({
+			token: params.token,
+			user: params.userId
+		});
+		const teamId = info.user?.team_id ?? info.user?.profile?.team;
+		if (teamId) {
+			rememberSlackStreamRecipientTeam({
+				...params,
+				teamId
+			});
+			return teamId;
+		}
+	} catch (err) {
+		logVerbose(`slack-stream: users.info team lookup failed (${formatErrorMessage(err)})`);
+	}
+	return params.fallbackTeamId;
+}
+async function dispatchPreparedSlackMessage(prepared) {
+	const { ctx, account, message, route } = prepared;
+	const cfg = ctx.cfg;
+	const runtime = ctx.runtime;
+	const outboundIdentity = resolveAgentOutboundIdentity(cfg, route.agentId);
+	const slackIdentity = outboundIdentity ? {
+		username: outboundIdentity.name,
+		iconUrl: outboundIdentity.avatarUrl,
+		iconEmoji: outboundIdentity.emoji
+	} : prepared.relayIdentity;
+	if (prepared.isDirectMessage) {
+		const sessionCfg = cfg.session;
+		const storePath = resolveStorePath(sessionCfg?.store, { agentId: route.agentId });
+		const pinnedMainDmOwner = resolvePinnedMainDmOwnerFromAllowlist({
+			dmScope: cfg.session?.dmScope,
+			allowFrom: ctx.allowFrom,
+			normalizeEntry: normalizeSlackAllowOwnerEntry
+		});
+		const senderRecipient = normalizeOptionalLowercaseString(message.user);
+		const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
+			route,
+			sessionKey: prepared.ctxPayload.SessionKey ?? route.sessionKey
+		});
+		if (inboundLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner && senderRecipient && normalizeOptionalLowercaseString(pinnedMainDmOwner) !== senderRecipient) logVerbose(`slack: skip main-session last route for ${senderRecipient} (pinned owner ${pinnedMainDmOwner})`);
+		else await updateLastRoute({
+			storePath,
+			sessionKey: inboundLastRouteSessionKey,
+			deliveryContext: {
+				channel: "slack",
+				to: `user:${message.user}`,
+				accountId: route.accountId,
+				threadId: prepared.ctxPayload.MessageThreadId ?? prepared.ctxPayload.TransportThreadId
+			},
+			ctx: prepared.ctxPayload
+		});
+	}
+	const threadTargets = resolveSlackThreadTargets({
+		message,
+		replyToMode: prepared.replyToMode
+	});
+	const forcedReplyThreadTs = prepared.forcedReplyThreadTs;
+	const slackMessageMetadata = prepared.slackMessageMetadata;
+	const statusThreadTs = forcedReplyThreadTs ?? threadTargets.statusThreadTs;
+	const isThreadReply = threadTargets.isThreadReply;
+	const replyDeliveryMode = forcedReplyThreadTs ? "off" : prepared.replyToMode;
+	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
+		cfg,
+		ctx: prepared.ctxPayload
+	});
+	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	const messageSentHookTarget = prepared.ctxPayload.OriginatingTo ?? prepared.ctxPayload.To ?? prepared.replyTarget;
+	const messageSentHookContext = {
+		sessionKeyForInternalHooks: prepared.ctxPayload.SessionKey ?? route.sessionKey,
+		isGroup: prepared.isRoomish,
+		groupId: prepared.isRoomish ? message.channel : void 0
+	};
+	const messageSentDeliveryHookContext = {
+		...messageSentHookContext,
+		messageSentHookTarget
+	};
+	const reactionMessageTs = prepared.ackReactionMessageTs;
+	const messageTs = message.ts ?? message.event_ts;
+	const incomingThreadTs = message.thread_ts;
+	let didSetStatus = false;
+	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
+	const slackStatusAdapter = {
+		setReaction: async (emoji) => {
+			await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
+				token: ctx.botToken,
+				client: ctx.app.client
+			}).catch((err) => {
+				if (formatErrorMessage(err).includes("already_reacted")) return;
+				throw err;
+			});
+		},
+		removeReaction: async (emoji) => {
+			await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
+				token: ctx.botToken,
+				client: ctx.app.client
+			}).catch((err) => {
+				if (formatErrorMessage(err).includes("no_reaction")) return;
+				throw err;
+			});
+		}
+	};
+	const statusReactionTiming = {
+		...DEFAULT_TIMING,
+		...cfg.messages?.statusReactions?.timing
+	};
+	const statusReactions = createStatusReactionController({
+		enabled: statusReactionsEnabled,
+		adapter: slackStatusAdapter,
+		initialEmoji: prepared.ackReactionValue || "eyes",
+		emojis: cfg.messages?.statusReactions?.emojis,
+		timing: cfg.messages?.statusReactions?.timing,
+		onError: (err) => {
+			logAckFailure({
+				log: logVerbose,
+				channel: "slack",
+				target: `${message.channel}/${message.ts}`,
+				error: err
+			});
+		}
+	});
+	if (statusReactionsEnabled) statusReactions.setQueued();
+	const hasRepliedRef = { value: false };
+	const replyPlan = createSlackReplyDeliveryPlan({
+		replyToMode: replyDeliveryMode,
+		incomingThreadTs: forcedReplyThreadTs ?? incomingThreadTs,
+		messageTs,
+		hasRepliedRef,
+		isThreadReply: Boolean(forcedReplyThreadTs) || isThreadReply
+	});
+	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
+	const typingReaction = ctx.typingReaction;
+	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
+		cfg,
+		agentId: route.agentId,
+		channel: "slack",
+		accountId: route.accountId,
+		transformReplyPayload: (payload) => {
+			if (payload.isReasoning === true) return null;
+			return isSlackInteractiveRepliesEnabled({
+				cfg,
+				accountId: route.accountId
+			}) ? compileSlackInteractiveReplies(payload) : payload;
+		},
+		typing: {
+			start: async () => {
+				didSetStatus = true;
+				await ctx.setSlackThreadStatus({
+					channelId: message.channel,
+					threadTs: statusThreadTs,
+					status: "is typing...",
+					loadingMessages: SLACK_THREAD_LOADING_MESSAGES
+				});
+				if (typingReaction && message.ts) await reactSlackMessage(message.channel, message.ts, typingReaction, {
+					token: ctx.botToken,
+					client: ctx.app.client
+				}).catch(() => {});
+			},
+			stop: async () => {
+				if (!didSetStatus) return;
+				didSetStatus = false;
+				await ctx.setSlackThreadStatus({
+					channelId: message.channel,
+					threadTs: statusThreadTs,
+					status: ""
+				});
+				if (typingReaction && message.ts) await removeSlackReaction(message.channel, message.ts, typingReaction, {
+					token: ctx.botToken,
+					client: ctx.app.client
+				}).catch(() => {});
+			},
+			onStartError: (err) => {
+				logTypingFailure({
+					log: (messageValue) => runtime.error?.(danger(messageValue)),
+					channel: "slack",
+					action: "start",
+					target: typingTarget,
+					error: err
+				});
+			},
+			onStopError: (err) => {
+				logTypingFailure({
+					log: (messageLocal) => runtime.error?.(danger(messageLocal)),
+					channel: "slack",
+					action: "stop",
+					target: typingTarget,
+					error: err
+				});
+			}
+		}
+	});
+	const slackStreaming = resolveSlackStreamingConfig({
+		streaming: account.config.streaming,
+		nativeStreaming: resolveChannelStreamingNativeTransport(account.config)
+	});
+	const streamThreadHint = forcedReplyThreadTs ?? resolveSlackStreamingThreadHint({
+		replyToMode: replyDeliveryMode,
+		incomingThreadTs,
+		messageTs,
+		isThreadReply
+	});
+	const previewStreamingEnabled = !sourceRepliesAreToolOnly && shouldEnableSlackPreviewStreaming({ mode: slackStreaming.mode });
+	const hasSlackCustomIdentity = Boolean(slackIdentity?.username || slackIdentity?.iconUrl || slackIdentity?.iconEmoji);
+	const useStreaming = shouldUseStreaming({
+		streamingEnabled: !sourceRepliesAreToolOnly && isSlackStreamingEnabled({
+			mode: slackStreaming.mode,
+			nativeStreaming: slackStreaming.nativeStreaming,
+			nativeProgressTaskCards: resolveSlackNativeProgressTaskCards(account.config)
+		}),
+		threadTs: streamThreadHint
+	});
+	const shouldUseDraftStream = !hasSlackCustomIdentity && shouldInitializeSlackDraftStream({
+		previewStreamingEnabled,
+		useStreaming
+	});
+	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
+	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
+		useStreaming,
+		shouldUseDraftStream,
+		blockStreamingEnabled
+	});
+	let streamSession = null;
+	let nativeProgressStreamStartPromise = null;
+	let nativeProgressStreamThreadTs;
+	let streamFailed = false;
+	let usedReplyThreadTs;
+	let usedBlockReplyThreadTs;
+	let observedReplyDelivery = false;
+	let observedFinalReplyDelivery = false;
+	const streamedDeliveries = [];
+	const streamedFailuresOwnedByDispatcher = {
+		tool: 0,
+		block: 0,
+		final: 0
+	};
+	const refreshStreamedAcknowledgements = (session) => {
+		if (session.pendingText.length === 0) for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+	};
+	const recordStreamedDelivery = (kind, content) => {
+		const delivery = {
+			kind,
+			content,
+			acknowledged: false
+		};
+		streamedDeliveries.push(delivery);
+		return delivery;
+	};
+	const rememberStreamedDelivery = (kind, content, session) => {
+		recordStreamedDelivery(kind, content);
+		refreshStreamedAcknowledgements(session);
+	};
+	const emitAcknowledgedStreamedDeliveries = (messageId) => {
+		for (const delivery of streamedDeliveries) {
+			if (!delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: true,
+				...messageId ? { messageId } : {}
+			});
+			delivery.outcome = "success";
+		}
+	};
+	const emitFailedPendingStreamedDeliveries = (error) => {
+		for (const delivery of streamedDeliveries) {
+			if (delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: false,
+				error
+			});
+			delivery.outcome = "failure";
+		}
+	};
+	const emitSuccessfulPendingStreamedDeliveries = (messageId) => {
+		for (const delivery of streamedDeliveries) {
+			if (delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: true,
+				...messageId ? { messageId } : {}
+			});
+			delivery.outcome = "success";
+		}
+	};
+	const deliveryTracker = createSlackEventDeliveryTracker();
+	const markPreviewPayloadDelivered = (params) => {
+		deliveryTracker.markDelivered(params);
+		const nextThreadTs = replyPlan.peekThreadTs();
+		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered({
+			...params,
+			threadTs: nextThreadTs
+		});
+	};
+	const resolveDeliveryThreadTs = (params) => {
+		const plannedThreadTs = params.forcedThreadTs ? void 0 : replyPlan.nextThreadTs();
+		return params.forcedThreadTs ?? plannedThreadTs ?? (params.kind === "block" ? usedBlockReplyThreadTs : void 0);
+	};
+	const rememberDeliveredThreadTs = (kind, deliveredThreadTs) => {
+		if (!deliveredThreadTs) return;
+		usedReplyThreadTs ??= deliveredThreadTs;
+		if (kind === "block") usedBlockReplyThreadTs = deliveredThreadTs;
+	};
+	const deliverPendingStreamFallback = async (session, err) => {
+		let fallbackError = err;
+		if (!session.stopped) try {
+			const stopResult = await stopSlackStream({
+				session,
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			});
+			for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+			emitAcknowledgedStreamedDeliveries(stopResult.messageId);
+			observedReplyDelivery = true;
+			usedReplyThreadTs ??= session.threadTs;
+			return true;
+		} catch (stopErr) {
+			if (stopErr instanceof SlackStreamNotDeliveredError) fallbackError = stopErr;
+			else runtime.error?.(danger(`slack-stream: failed to finalize buffered text before fallback: ${formatSlackError(stopErr)}`));
+		}
+		emitAcknowledgedStreamedDeliveries();
+		const fallbackText = fallbackError.pendingText.trim();
+		if (!fallbackText) return false;
+		try {
+			await deliverReplies({
+				cfg: ctx.cfg,
+				replies: [{ text: fallbackText }],
+				target: prepared.replyTarget,
+				token: ctx.botToken,
+				accountId: account.accountId,
+				runtime,
+				textLimit: ctx.textLimit,
+				replyThreadTs: session.threadTs,
+				replyToMode: replyDeliveryMode,
+				...slackIdentity ? { identity: slackIdentity } : {},
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+				...messageSentDeliveryHookContext,
+				deferMessageSentHooks: true
+			});
+			markSlackStreamFallbackDelivered(session);
+			if (!session.stopped) try {
+				await stopSlackStream({
+					session,
+					...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+				});
+			} catch (finalizeErr) {
+				runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
+			}
+			emitSuccessfulPendingStreamedDeliveries();
+			observedReplyDelivery = true;
+			usedReplyThreadTs ??= session.threadTs;
+			logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
+			return true;
+		} catch (postErr) {
+			emitFailedPendingStreamedDeliveries(formatErrorMessage(postErr));
+			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${fallbackError.slackCode}: ${formatErrorMessage(postErr)}`));
+			return false;
+		}
+	};
+	const deliverNormally = async (params) => {
+		if (params.payload.isReasoning === true) return;
+		const replyThreadTs = resolveDeliveryThreadTs(params);
+		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
+		if (deliveryTracker.hasDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: deliveryReplyThreadTs
+		})) {
+			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
+			return deliveryReplyThreadTs;
+		}
+		await deliverReplies({
+			cfg: ctx.cfg,
+			replies: [params.payload],
+			target: prepared.replyTarget,
+			token: ctx.botToken,
+			accountId: account.accountId,
+			runtime,
+			textLimit: ctx.textLimit,
+			replyThreadTs: deliveryReplyThreadTs,
+			replyToMode: replyDeliveryMode,
+			...slackIdentity ? { identity: slackIdentity } : {},
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+			...messageSentDeliveryHookContext
+		});
+		observedReplyDelivery = true;
+		if (params.kind === "final") observedFinalReplyDelivery = true;
+		const deliveredThreadTs = resolveDeliveredSlackReplyThreadTs({
+			replyToMode: replyDeliveryMode,
+			payloadReplyToId: params.payload.replyToId,
+			replyThreadTs: deliveryReplyThreadTs
+		});
+		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
+		replyPlan.markSent();
+		deliveryTracker.markDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: deliveryReplyThreadTs
+		});
+		return deliveryReplyThreadTs;
+	};
+	const deliverBufferedStreamFallback = async (params) => {
+		if (!await deliverPendingStreamFallback(params.session, params.err)) {
+			streamedFailuresOwnedByDispatcher[params.kind] += 1;
+			return false;
+		}
+		replyPlan.markSent();
+		if (params.kind === "final") observedFinalReplyDelivery = true;
+		deliveryTracker.markDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: params.session.threadTs,
+			textOverride: params.textOverride
+		});
+		rememberDeliveredThreadTs(params.kind, params.session.threadTs);
+		return true;
+	};
+	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) {
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
+			});
+			return;
+		}
+		const text = reply.trimmedText;
+		let plannedThreadTs;
+		try {
+			if (!streamSession && nativeProgressStreamStartPromise) await nativeProgressStreamStartPromise;
+			if (streamFailed) {
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind,
+					forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
+				});
+				return;
+			}
+			if (useNativeProgressStreaming && !streamSession) {
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind
+				});
+				return;
+			}
+			if (!streamSession) {
+				const streamThreadTs = replyPlan.nextThreadTs();
+				plannedThreadTs = streamThreadTs;
+				if (!streamThreadTs) {
+					logVerbose("slack-stream: no reply thread target for stream start, falling back to normal delivery");
+					streamFailed = true;
+					await deliverNormally({
+						payload: params.payload,
+						kind: params.kind
+					});
+					return;
+				}
+				if (deliveryTracker.hasDelivered({
+					kind: params.kind,
+					payload: params.payload,
+					threadTs: streamThreadTs,
+					textOverride: text
+				})) {
+					logVerbose("slack-stream: suppressed duplicate stream start payload");
+					return;
+				}
+				streamSession = await startSlackStream({
+					client: ctx.app.client,
+					channel: message.channel,
+					threadTs: streamThreadTs,
+					text,
+					...slackIdentity ? { identity: slackIdentity } : {},
+					teamId: await resolveSlackStreamRecipientTeamId({
+						client: ctx.app.client,
+						token: ctx.botToken,
+						userId: message.user,
+						fallbackTeamId: ctx.teamId
+					}),
+					userId: message.user
+				});
+				refreshStreamedAcknowledgements(streamSession);
+				if (streamSession.delivered) {
+					observedReplyDelivery = true;
+					if (params.kind === "final") observedFinalReplyDelivery = true;
+				}
+				if (text) rememberStreamedDelivery(params.kind, text, streamSession);
+				rememberDeliveredThreadTs(params.kind, streamThreadTs);
+				replyPlan.markSent();
+				deliveryTracker.markDelivered({
+					kind: params.kind,
+					payload: params.payload,
+					threadTs: streamThreadTs,
+					textOverride: text
+				});
+				return;
+			}
+			if (deliveryTracker.hasDelivered({
+				kind: params.kind,
+				payload: params.payload,
+				threadTs: streamSession.threadTs,
+				textOverride: text
+			})) {
+				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;
+			if (useNativeProgressStreaming) {
+				if (completionChunks?.length) {
+					await appendSlackStream({
+						session: streamSession,
+						chunks: completionChunks
+					});
+					nativeProgressCompletionSent = true;
+					if (streamSession.delivered) observedReplyDelivery = true;
+				}
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind,
+					forcedThreadTs: streamSession.threadTs
+				});
+				return;
+			}
+			if (text) recordStreamedDelivery(params.kind, text);
+			await appendSlackStream({
+				session: streamSession,
+				text: "\n" + text,
+				chunks: completionChunks
+			});
+			refreshStreamedAcknowledgements(streamSession);
+			if (completionChunks?.length) nativeProgressCompletionSent = true;
+			if (streamSession.delivered) {
+				observedReplyDelivery = true;
+				if (params.kind === "final") observedFinalReplyDelivery = true;
+			}
+			deliveryTracker.markDelivered({
+				kind: params.kind,
+				payload: params.payload,
+				threadTs: streamSession.threadTs,
+				textOverride: text
+			});
+		} catch (err) {
+			if (err instanceof SlackStreamNotDeliveredError) {
+				streamFailed = true;
+				if (streamSession) {
+					if (await deliverBufferedStreamFallback({
+						session: streamSession,
+						err,
+						payload: params.payload,
+						kind: params.kind,
+						textOverride: text
+					})) return;
+					throw err;
+				}
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind,
+					forcedThreadTs: plannedThreadTs
+				});
+				return;
+			}
+			runtime.error?.(danger(`slack-stream: streaming API call failed: ${formatSlackError(err)}, falling back`));
+			streamFailed = true;
+			if (streamSession && streamSession.pendingText) {
+				const bufferedFallbackErr = new SlackStreamNotDeliveredError(streamSession.pendingText, "unknown");
+				if (await deliverBufferedStreamFallback({
+					session: streamSession,
+					err: bufferedFallbackErr,
+					payload: params.payload,
+					kind: params.kind,
+					textOverride: text
+				})) return;
+				throw err;
+			}
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: streamSession?.threadTs ?? plannedThreadTs
+			});
+		}
+	};
+	let draftPreviewCommitted = false;
+	const deliverSlackPayload = async (payload, info) => {
+		if (payload.isReasoning === true) return { visibleReplySent: false };
+		if (useStreaming) {
+			await deliverWithStreaming({
+				payload,
+				kind: info.kind
+			});
+			return;
+		}
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const slackBlocks = readSlackReplyBlocks(payload);
+		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
+		const trimmedFinalText = (payload.text ?? ttsSupplement?.spokenText ?? "").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) {
+			const channelId = draftStream.channelId();
+			const messageId = draftStream.messageId();
+			if (channelId && messageId) {
+				const finalThreadTs = usedReplyThreadTs ?? statusThreadTs;
+				await draftStream.flush();
+				await draftStream.seal();
+				try {
+					await finalizeSlackPreviewEdit({
+						client: ctx.app.client,
+						token: ctx.botToken,
+						accountId: account.accountId,
+						channelId,
+						messageId,
+						text: normalizeSlackOutboundText(trimmedFinalText),
+						...slackBlocks?.length ? { blocks: slackBlocks } : {},
+						threadTs: finalThreadTs
+					});
+				} catch (err) {
+					logVerbose(`slack: preview final edit failed; falling back to standard send (${formatSlackError(err)})`);
+					await draftStream.discardPending();
+					let delivered = false;
+					try {
+						await deliverNormally({
+							payload: payload.text?.trim() ? payload : {
+								...payload,
+								text: trimmedFinalText
+							},
+							kind: info.kind,
+							forcedThreadTs: finalThreadTs
+						});
+						delivered = true;
+					} finally {
+						if (delivered) await draftStream.clear();
+					}
+					return;
+				}
+				draftPreviewCommitted = true;
+				observedFinalReplyDelivery = true;
+				observedReplyDelivery = true;
+				replyPlan.markSent();
+				await deliverNormally({
+					payload: buildTtsSupplementMediaPayload(payload),
+					kind: info.kind,
+					forcedThreadTs: finalThreadTs
+				});
+				markPreviewPayloadDelivered({
+					kind: info.kind,
+					payload,
+					threadTs: finalThreadTs
+				});
+				return;
+			}
+		}
+		await deliverWithFinalizableLivePreviewAdapter({
+			kind: info.kind,
+			payload,
+			adapter: defineFinalizableLivePreviewAdapter({
+				draft: draftStream && !draftPreviewCommitted && !observedFinalReplyDelivery ? {
+					flush: draftStream.flush,
+					clear: draftStream.clear,
+					discardPending: draftStream.discardPending,
+					seal: draftStream.seal,
+					id: () => {
+						const channelId = draftStream.channelId();
+						const messageId = draftStream.messageId();
+						return channelId && messageId ? {
+							channelId,
+							messageId
+						} : void 0;
+					}
+				} : void 0,
+				buildFinalEdit: () => {
+					if (!previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
+					return {
+						text: normalizeSlackOutboundText(trimmedFinalText),
+						blocks: slackBlocks,
+						threadTs: usedReplyThreadTs ?? statusThreadTs
+					};
+				},
+				editFinal: async (preview, edit) => {
+					if (deliveryTracker.hasDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: edit.threadTs
+					})) return;
+					await finalizeSlackPreviewEdit({
+						client: ctx.app.client,
+						token: ctx.botToken,
+						accountId: account.accountId,
+						channelId: preview.channelId,
+						messageId: preview.messageId,
+						text: edit.text,
+						...edit.blocks?.length ? { blocks: edit.blocks } : {},
+						threadTs: edit.threadTs
+					});
+					if (!ttsSupplement) emitSlackMessageSentHooks({
+						...messageSentHookContext,
+						to: messageSentHookTarget,
+						accountId: account.accountId,
+						content: trimmedFinalText,
+						success: true,
+						messageId: preview.messageId
+					});
+					draftPreviewCommitted = true;
+					observedFinalReplyDelivery = true;
+				},
+				onPreviewFinalized: (_preview) => {
+					draftPreviewCommitted = true;
+					observedFinalReplyDelivery = true;
+					const finalThreadTs = usedReplyThreadTs ?? statusThreadTs;
+					observedReplyDelivery = true;
+					replyPlan.markSent();
+					if (!ttsSupplement) markPreviewPayloadDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: finalThreadTs
+					});
+				},
+				buildSupplementalPayload: () => ttsSupplement ? buildTtsSupplementMediaPayload(payload) : void 0,
+				deliverSupplemental: async (supplementalPayload) => {
+					const previewThreadTs = usedReplyThreadTs ?? statusThreadTs;
+					const supplementalThreadTs = await deliverNormally({
+						payload: supplementalPayload,
+						kind: info.kind,
+						forcedThreadTs: previewThreadTs
+					});
+					markPreviewPayloadDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: supplementalThreadTs
+					});
+				},
+				logPreviewEditFailure: (err) => {
+					logVerbose(`slack: preview final edit failed; falling back to standard send (${formatSlackError(err)})`);
+				}
+			}),
+			deliverNormally: async () => {
+				await deliverNormally({
+					payload: shouldRestoreTtsSupplementTextForPreviewFallback ? {
+						...payload,
+						text: ttsSupplement?.spokenText
+					} : payload,
+					kind: info.kind
+				});
+			}
+		});
+	};
+	const onSlackDeliveryError = (err, info) => {
+		runtime.error?.(danger(`slack ${info.kind} reply failed: ${formatSlackError(err)}`));
+		replyPipeline.typingCallbacks?.onIdle?.();
+	};
+	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
+		target: prepared.replyTarget,
+		cfg,
+		token: ctx.botToken,
+		accountId: account.accountId,
+		identity: slackIdentity,
+		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+		maxChars: Math.min(ctx.textLimit, SLACK_TEXT_LIMIT),
+		resolveThreadTs: () => {
+			const ts = replyPlan.peekThreadTs();
+			if (ts) usedReplyThreadTs ??= ts;
+			return ts;
+		},
+		log: logVerbose,
+		warn: logVerbose
+	}) : void 0;
+	let hasStreamedMessage = false;
+	const streamMode = slackStreaming.draftMode;
+	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
+	const previewToolProgressEnabled = (Boolean(draftStream) || useNativeProgressStreaming) && resolveChannelStreamingPreviewToolProgress(account.config);
+	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
+		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
+		previewToolProgressEnabled,
+		previewStreamingEnabled
+	});
+	let previewToolProgressSuppressed = false;
+	let previewToolProgressLines = [];
+	let lastNonEmptyPreviewToolProgressLines = [];
+	let appendRenderedText = "";
+	let appendSourceText = "";
+	let reasoningProgressRawText = "";
+	let statusUpdateCount = 0;
+	let nativeProgressCompletionSent = false;
+	let nativeProgressChunkKey;
+	const progressSeed = `${account.accountId}:${message.channel}`;
+	const useRichProgressDraft = streamMode === "status_final" && resolveChannelProgressDraftRender(account.config) === "rich";
+	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
+	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
+	const renderProgressDraft = () => {
+		if (!draftStream || streamMode !== "status_final") return;
+		const progressLines = previewToolProgressLines.length === 0 ? lastNonEmptyPreviewToolProgressLines : previewToolProgressLines;
+		const previewText = formatChannelProgressDraftText({
+			entry: account.config,
+			lines: progressLines,
+			seed: progressSeed,
+			formatLine: escapeSlackMrkdwn
+		});
+		if (!previewText) return;
+		const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
+			title: explicitProgressTitle,
+			lines: progressLines,
+			maxLineChars: resolveChannelProgressDraftMaxLineChars(account.config)
+		}) : void 0;
+		draftStream.update(useRichProgressDraft && richProgressBlocks ? {
+			text: previewText,
+			blocks: richProgressBlocks
+		} : previewText);
+		hasStreamedMessage = true;
+	};
+	const waitForNativeProgressStreamStart = async () => {
+		if (streamSession || !nativeProgressStreamStartPromise) return true;
+		try {
+			await nativeProgressStreamStartPromise;
+		} catch {
+			streamFailed = true;
+			return false;
+		}
+		return !streamFailed;
+	};
+	const buildNativeProgressChunks = () => streamSession ? buildSlackProgressStreamUpdateChunks({
+		title: explicitProgressTitle,
+		lines: previewToolProgressLines,
+		maxLineChars: progressDraftMaxLineChars
+	}) : buildSlackProgressStreamStartChunks({
+		title: explicitProgressTitle,
+		lines: previewToolProgressLines,
+		maxLineChars: progressDraftMaxLineChars
+	});
+	const markNativeProgressDelivered = (session, threadTs) => {
+		if (session.delivered) observedReplyDelivery = true;
+		if (threadTs) {
+			usedReplyThreadTs ??= threadTs;
+			rememberDeliveredThreadTs("block", threadTs);
+		}
+	};
+	const startNativeProgressStream = async (chunks, chunkKey) => {
+		const streamThreadTs = replyPlan.nextThreadTs();
+		if (!streamThreadTs) {
+			logVerbose("slack-stream: no reply thread target for native progress stream start, falling back");
+			streamFailed = true;
+			return;
+		}
+		nativeProgressStreamThreadTs = streamThreadTs;
+		const startPromise = (async () => {
+			const session = await startSlackStream({
+				client: ctx.app.client,
+				channel: message.channel,
+				threadTs: streamThreadTs,
+				chunks,
+				taskDisplayMode: "plan",
+				...slackIdentity ? { identity: slackIdentity } : {},
+				teamId: await resolveSlackStreamRecipientTeamId({
+					client: ctx.app.client,
+					token: ctx.botToken,
+					userId: message.user,
+					fallbackTeamId: ctx.teamId
+				}),
+				userId: message.user
+			});
+			streamSession = session;
+			return session;
+		})();
+		nativeProgressStreamStartPromise = startPromise;
+		let startedSession;
+		try {
+			startedSession = await startPromise;
+		} finally {
+			if (nativeProgressStreamStartPromise === startPromise) nativeProgressStreamStartPromise = null;
+		}
+		if (startedSession) markNativeProgressDelivered(startedSession, streamThreadTs);
+		nativeProgressChunkKey = chunkKey;
+		replyPlan.markSent();
+	};
+	const appendNativeProgressStream = async (chunks, chunkKey) => {
+		if (!streamSession) return;
+		await appendSlackStream({
+			session: streamSession,
+			chunks
+		});
+		markNativeProgressDelivered(streamSession);
+		nativeProgressChunkKey = chunkKey;
+	};
+	const updateNativeProgressStream = async () => {
+		if (!useNativeProgressStreaming || streamFailed || previewToolProgressLines.length === 0) return;
+		if (!await waitForNativeProgressStreamStart()) return;
+		const chunks = buildNativeProgressChunks();
+		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);
+		} 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 refreshStartedProgressDraft = async () => {
+		if (useNativeProgressStreaming) await updateNativeProgressStream();
+		else renderProgressDraft();
+	};
+	const pushPreviewToolProgress = async (line, options) => {
+		if (!draftStream && !useNativeProgressStreaming) return;
+		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
+		const normalized = line?.text.replace(/\s+/g, " ").trim();
+		if (!line || !normalized) {
+			if (streamMode !== "status_final") return;
+			const alreadyStarted = progressDraftGate.hasStarted;
+			const progressActive = await progressDraftGate.noteWork();
+			if ((alreadyStarted || progressActive) && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+			return;
+		}
+		if (streamMode !== "status_final") {
+			if (!previewToolProgressEnabled || previewToolProgressSuppressed) return;
+			const nextLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
+			if (nextLines === previewToolProgressLines) return;
+			previewToolProgressLines = nextLines;
+			draftStream?.update(formatChannelProgressDraftText({
+				entry: account.config,
+				lines: previewToolProgressLines,
+				seed: progressSeed,
+				formatLine: escapeSlackMrkdwn
+			}));
+			hasStreamedMessage = true;
+			return;
+		}
+		if (previewToolProgressEnabled && !previewToolProgressSuppressed) {
+			previewToolProgressLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
+			if (previewToolProgressLines.length > 0) lastNonEmptyPreviewToolProgressLines = previewToolProgressLines;
+		}
+		if (useNativeProgressStreaming) {
+			if (progressDraftGate.hasStarted) await updateNativeProgressStream();
+			else {
+				await progressDraftGate.startNow();
+				if (progressDraftGate.hasStarted) await updateNativeProgressStream();
+			}
+			return;
+		}
+		const alreadyStarted = progressDraftGate.hasStarted;
+		const progressActive = await progressDraftGate.noteWork();
+		if ((alreadyStarted || progressActive) && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+	};
+	const updateDraftFromPartial = (text) => {
+		const trimmed = text?.trimEnd();
+		if (!trimmed) return;
+		if (streamMode === "append") {
+			previewToolProgressSuppressed = true;
+			previewToolProgressLines = [];
+			const next = applyAppendOnlyStreamUpdate({
+				incoming: trimmed,
+				rendered: appendRenderedText,
+				source: appendSourceText
+			});
+			appendRenderedText = next.rendered;
+			appendSourceText = next.source;
+			if (!next.changed) return;
+			draftStream?.update(next.rendered);
+			hasStreamedMessage = true;
+			return;
+		}
+		if (streamMode === "status_final") {
+			if (!progressDraftGate.hasStarted) return;
+			statusUpdateCount += 1;
+			if (statusUpdateCount > 1 && statusUpdateCount % 4 !== 0) return;
+			renderProgressDraft();
+			return;
+		}
+		previewToolProgressSuppressed = true;
+		previewToolProgressLines = [];
+		draftStream?.update(trimmed);
+		hasStreamedMessage = true;
+	};
+	const pushReasoningProgress = async (payload) => {
+		if (!payload?.text) return;
+		reasoningProgressRawText = mergeSlackReasoningProgressText(reasoningProgressRawText, payload.text, { snapshot: payload.isReasoningSnapshot === true });
+		const normalized = normalizeSlackReasoningProgressLine(reasoningProgressRawText);
+		if (!normalized) return;
+		await pushPreviewToolProgress({
+			id: "reasoning",
+			kind: "item",
+			text: normalized,
+			label: "Reasoning"
+		});
+	};
+	const onDraftBoundary = !shouldUseDraftStream ? void 0 : async () => {
+		if (hasStreamedMessage && streamMode !== "status_final") {
+			draftStream?.forceNewMessage();
+			hasStreamedMessage = false;
+			appendRenderedText = "";
+			appendSourceText = "";
+			statusUpdateCount = 0;
+		}
+		reasoningProgressRawText = "";
+		previewToolProgressSuppressed = false;
+		previewToolProgressLines = [];
+	};
+	let dispatchError;
+	let queuedFinal = false;
+	let counts = {};
+	try {
+		const turnResult = await dispatchChannelInboundReply({
+			cfg,
+			channel: "slack",
+			accountId: route.accountId,
+			agentId: route.agentId,
+			routeSessionKey: route.sessionKey,
+			storePath: prepared.turn.storePath,
+			ctxPayload: prepared.ctxPayload,
+			recordInboundSession,
+			dispatchReplyWithBufferedBlockDispatcher,
+			dispatcherOptions: {
+				...replyPipeline,
+				humanDelay: resolveHumanDelayConfig(cfg, route.agentId)
+			},
+			delivery: {
+				deliver: deliverSlackPayload,
+				onError: onSlackDeliveryError
+			},
+			record: prepared.turn.record,
+			history: prepared.turn.history,
+			botLoopProtection: resolveSlackBotLoopProtection(prepared),
+			replyOptions: {
+				skillFilter: prepared.channelConfig?.skills,
+				sourceReplyDeliveryMode,
+				hasRepliedRef,
+				disableBlockStreaming,
+				onModelSelected,
+				suppressDefaultToolProgressMessages: suppressDefaultToolProgressMessages ? true : 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) => {
+					updateDraftFromPartial(payload.text);
+				},
+				onAssistantMessageStart: onDraftBoundary,
+				onReasoningEnd: onDraftBoundary,
+				onReasoningStream: statusReactionsEnabled || previewToolProgressEnabled ? async (payload) => {
+					await pushReasoningProgress(payload);
+					if (!statusReactionsEnabled) return;
+					await statusReactions.setThinking();
+				} : void 0,
+				onToolStart: async (payload) => {
+					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
+					await pushPreviewToolProgress(buildChannelProgressDraftLineForEntry(account.config, {
+						event: "tool",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						name: payload.name,
+						phase: payload.phase,
+						args: payload.args
+					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
+				},
+				onItemEvent: async (payload) => {
+					await pushPreviewToolProgress(buildChannelProgressDraftLineForEntry(account.config, {
+						event: "item",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						itemKind: payload.kind,
+						title: payload.title,
+						name: payload.name,
+						phase: payload.phase,
+						status: payload.status,
+						summary: payload.summary,
+						progressText: payload.progressText,
+						meta: payload.meta
+					}));
+				},
+				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
+					}));
+				},
+				onApprovalEvent: async (payload) => {
+					if (payload.phase !== "requested") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "approval",
+						phase: payload.phase,
+						title: payload.title,
+						command: payload.command,
+						reason: payload.reason,
+						message: payload.message
+					}));
+				},
+				onCommandOutput: async (payload) => {
+					if (payload.phase !== "end") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "command-output",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						phase: payload.phase,
+						title: payload.title,
+						name: payload.name,
+						status: payload.status,
+						exitCode: payload.exitCode
+					}));
+				},
+				onPatchSummary: async (payload) => {
+					if (payload.phase !== "end") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "patch",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						phase: payload.phase,
+						title: payload.title,
+						name: payload.name,
+						added: payload.added,
+						modified: payload.modified,
+						deleted: payload.deleted,
+						summary: payload.summary
+					}));
+				}
+			}
+		});
+		if (turnResult.dispatched) {
+			const result = turnResult.dispatchResult;
+			queuedFinal = result.queuedFinal;
+			counts = result.counts;
+		}
+	} catch (err) {
+		dispatchError = err;
+	} finally {
+		progressDraftGate.cancel();
+		await draftStream?.discardPending();
+	}
+	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;
+		if (completionChunks?.length) nativeProgressCompletionSent = true;
+		const stopResult = await stopSlackStream({
+			session: finalStream,
+			...completionChunks?.length ? { chunks: completionChunks } : {},
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+		});
+		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+		emitAcknowledgedStreamedDeliveries(stopResult?.messageId);
+	} catch (err) {
+		if (err instanceof SlackStreamNotDeliveredError) {
+			streamFallbackDelivered = await deliverPendingStreamFallback(finalStream, err);
+			if (!streamFallbackDelivered) dispatchError ??= err;
+		} else {
+			const error = formatSlackError(err);
+			emitAcknowledgedStreamedDeliveries();
+			emitFailedPendingStreamedDeliveries(error);
+			runtime.error?.(danger(`slack-stream: failed to stop stream: ${error}`));
+			if (!finalStream.delivered) dispatchError ??= err;
+		}
+	}
+	for (const kind of [
+		"tool",
+		"block",
+		"final"
+	]) {
+		const failedStreamedCount = streamedDeliveries.filter((delivery) => delivery.kind === kind && delivery.outcome === "failure").length;
+		const additionalFailedStreamed = Math.max(0, failedStreamedCount - streamedFailuresOwnedByDispatcher[kind]);
+		if (additionalFailedStreamed > 0) counts = {
+			...counts,
+			[kind]: Math.max(0, (counts[kind] ?? 0) - additionalFailedStreamed)
+		};
+	}
+	queuedFinal = queuedFinal && (counts.final ?? 0) > 0;
+	const anyReplyDelivered = hasVisibleInboundReplyDispatch({
+		queuedFinal,
+		counts
+	}, {
+		observedReplyDelivery,
+		fallbackDelivered: streamFallbackDelivered
+	});
+	if (statusReactionsEnabled) {
+		if (dispatchError) {
+			await statusReactions.setError();
+			if (ctx.removeAckAfterReply) (async () => {
+				await sleep(statusReactionTiming.errorHoldMs);
+				if (anyReplyDelivered) await statusReactions.clear();
+			})();
+		} else if (anyReplyDelivered) {
+			await statusReactions.setDone();
+			if (ctx.removeAckAfterReply) (async () => {
+				await sleep(statusReactionTiming.doneHoldMs);
+				await statusReactions.clear();
+			})();
+			else statusReactions.restoreInitial();
+		} else await statusReactions.restoreInitial();
+	}
+	const participationThreadTs = usedReplyThreadTs ?? statusThreadTs;
+	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, { agentId: route.agentId });
+	if (dispatchError) throw toLintErrorObject(dispatchError, "Slack dispatch failed");
+	if (!anyReplyDelivered && !draftPreviewCommitted) {
+		await draftStream?.clear();
+		return;
+	}
+	if (shouldLogVerbose()) {
+		const finalCount = counts.final;
+		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
+	}
+	if (!statusReactionsEnabled) removeAckReactionAfterReply({
+		removeAfterReply: ctx.removeAckAfterReply && anyReplyDelivered,
+		ackReactionPromise: prepared.ackReactionPromise,
+		ackReactionValue: prepared.ackReactionValue,
+		remove: () => removeSlackReaction(message.channel, prepared.ackReactionMessageTs ?? "", prepared.ackReactionValue, {
+			token: ctx.botToken,
+			client: ctx.app.client
+		}),
+		onError: (err) => {
+			logAckFailure({
+				log: logVerbose,
+				channel: "slack",
+				target: `${message.channel}/${message.ts}`,
+				error: err
+			});
+		}
+	});
+}
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
+//#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-2VEX4Wdz.mjs").then((n) => n.g));
+function collectUniqueSlackMentionIds$1(texts) {
+	const seen = /* @__PURE__ */ new Set();
+	const mentionIds = [];
+	for (const text of texts) {
+		if (!text) continue;
+		SLACK_USER_MENTION_RE$1.lastIndex = 0;
+		for (const match of text.matchAll(SLACK_USER_MENTION_RE$1)) {
+			const userId = match[1];
+			if (!userId || seen.has(userId)) continue;
+			seen.add(userId);
+			mentionIds.push(userId);
+		}
+	}
+	return mentionIds;
+}
+function renderSlackUserMentions(text, renderedMentions) {
+	if (!text || renderedMentions.size === 0) return text;
+	SLACK_USER_MENTION_RE$1.lastIndex = 0;
+	return text.replace(SLACK_USER_MENTION_RE$1, (full, userId) => {
+		return renderedMentions.get(userId) ?? full;
+	});
+}
+function filterInheritedParentFiles(params) {
+	const { files, isThreadReply, threadStarter } = params;
+	if (!isThreadReply || !files?.length) return files;
+	if (!threadStarter?.files?.length) return files;
+	const starterFileIds = new Set(threadStarter.files.map((file) => file.id));
+	const filtered = files.filter((file) => !file.id || !starterFileIds.has(file.id));
+	if (filtered.length < files.length) logVerbose(`slack: filtered ${files.length - filtered.length} inherited parent file(s) from thread reply`);
+	return filtered.length > 0 ? filtered : void 0;
+}
+async function resolveSlackMessageContent(params) {
+	const ownFiles = filterInheritedParentFiles({
+		files: params.message.files,
+		isThreadReply: params.isThreadReply,
+		threadStarter: params.threadStarter
+	});
+	const mediaPromise = ownFiles && ownFiles.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackMedia }) => resolveSlackMedia({
+		files: ownFiles,
+		client: params.client,
+		token: params.botToken,
+		maxBytes: params.mediaMaxBytes,
+		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
+		totalTimeoutMs: params.mediaTotalTimeoutMs,
+		abortSignal: params.abortSignal
+	})) : Promise.resolve(null);
+	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
+		attachments: params.message.attachments,
+		client: params.client,
+		token: params.botToken,
+		maxBytes: params.mediaMaxBytes,
+		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
+		totalTimeoutMs: params.mediaTotalTimeoutMs,
+		abortSignal: params.abortSignal
+	})) : Promise.resolve(null);
+	const [media, attachmentContent] = await Promise.all([mediaPromise, attachmentContentPromise]);
+	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
+	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
+	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((item) => item.placeholder).join(" ") : void 0;
+	const fallbackFiles = ownFiles ?? [];
+	const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0 ? fallbackFiles.slice(0, 8).map((file) => formatSlackFileReference(file)).join(", ") : void 0;
+	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
+	let botAttachmentText;
+	if (params.isBotMessage && !attachmentContent?.text) {
+		const botAttachmentTextParts = [];
+		for (const attachment of params.message.attachments ?? []) {
+			const text = normalizeOptionalString(attachment.text) ?? normalizeOptionalString(attachment.fallback);
+			if (text) botAttachmentTextParts.push(text);
+		}
+		botAttachmentText = botAttachmentTextParts.length > 0 ? botAttachmentTextParts.join("\n") : void 0;
+	}
+	const blocksText = resolveSlackBlocksText(params.message.blocks);
+	const textParts = [
+		chooseSlackPrimaryText({
+			messageText: normalizeOptionalString(params.message.text),
+			blocksText
+		}),
+		attachmentContent?.text,
+		botAttachmentText
+	];
+	const renderedMentions = /* @__PURE__ */ new Map();
+	const resolveUserName = params.resolveUserName;
+	if (resolveUserName) {
+		const mentionIds = collectUniqueSlackMentionIds$1(textParts);
+		const lookupIds = mentionIds.slice(0, SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE);
+		const skippedLookups = mentionIds.length - lookupIds.length;
+		if (skippedLookups > 0) logVerbose(`slack: skipping ${skippedLookups} mention lookup(s) beyond per-message cap (${SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE})`);
+		const { results } = await runTasksWithConcurrency({
+			tasks: lookupIds.map((userId) => async () => {
+				const user = await resolveUserName(userId);
+				const renderedName = normalizeOptionalString(user?.name);
+				return {
+					userId,
+					rendered: renderedName ? `<@${userId}> (${renderedName})` : null
+				};
+			}),
+			limit: SLACK_MENTION_RESOLUTION_CONCURRENCY
+		});
+		for (const result of results) {
+			if (!result) continue;
+			renderedMentions.set(result.userId, result.rendered);
+		}
+	}
+	const rawBody = [
+		renderSlackUserMentions(textParts[0], renderedMentions),
+		renderSlackUserMentions(textParts[1], renderedMentions),
+		renderSlackUserMentions(textParts[2], renderedMentions),
+		mediaPlaceholder,
+		fileOnlyPlaceholder
+	].filter(Boolean).join("\n") || "";
+	if (!rawBody) return null;
+	return {
+		rawBody,
+		effectiveDirectMedia
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-dm-history.ts
+function resolveSlackDmHistoryLimit(params) {
+	const override = params.userId && params.account.config.dms?.[params.userId]?.historyLimit !== void 0 ? params.account.config.dms[params.userId]?.historyLimit : void 0;
+	return Math.max(0, override ?? params.defaultLimit);
+}
+async function resolveSlackDmHistoryContext(params) {
+	const maxMessages = Math.max(0, Math.floor(params.limit));
+	if (maxMessages <= 0) return {
+		body: void 0,
+		inboundHistory: void 0
+	};
+	try {
+		const messages = ((await params.ctx.app.client.conversations.history({
+			token: params.ctx.botToken,
+			channel: params.channelId,
+			...params.currentMessageTs ? {
+				latest: params.currentMessageTs,
+				inclusive: true
+			} : {},
+			limit: maxMessages + 1
+		})).messages ?? []).filter((message) => {
+			if (params.currentMessageTs && message.ts === params.currentMessageTs) return false;
+			return Boolean(normalizeOptionalString(message.text));
+		}).slice(0, maxMessages).toReversed();
+		if (messages.length === 0) return {
+			body: void 0,
+			inboundHistory: void 0
+		};
+		const userNames = /* @__PURE__ */ new Map();
+		const resolveUserLabel = async (userId) => {
+			const cached = userNames.get(userId);
+			if (cached) return cached;
+			const label = normalizeOptionalString((await params.ctx.resolveUserName(userId)).name) ?? userId;
+			userNames.set(userId, label);
+			return label;
+		};
+		const entries = [];
+		const formatted = [];
+		for (const message of messages) {
+			const body = normalizeOptionalString(message.text);
+			if (!body) continue;
+			const isCurrentBot = params.ctx.botUserId && message.user === params.ctx.botUserId || params.ctx.botId && message.bot_id === params.ctx.botId;
+			const role = isCurrentBot || message.bot_id ? "assistant" : "user";
+			const sender = `${isCurrentBot ? "Assistant" : message.user ? await resolveUserLabel(message.user) : normalizeOptionalString(message.username) ?? (message.bot_id ? "Bot" : "Unknown")} (${role})`;
+			const timestamp = resolveSlackTimestampMs(message.ts);
+			entries.push({
+				sender,
+				body,
+				timestamp
+			});
+			formatted.push(formatInboundEnvelope({
+				channel: "Slack",
+				from: sender,
+				timestamp,
+				body: `${body}\n[slack message id: ${message.ts ?? "unknown"} channel: ${params.channelId}]`,
+				chatType: "direct",
+				envelope: params.envelopeOptions
+			}));
+		}
+		return {
+			body: formatted.length > 0 ? formatted.join("\n\n") : void 0,
+			inboundHistory: entries.length > 0 ? entries : void 0
+		};
+	} catch (err) {
+		logVerbose(`slack: failed to fetch DM history for channel ${params.channelId}: ${formatErrorMessage(err)}`);
+		return {
+			body: void 0,
+			inboundHistory: void 0
+		};
+	}
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-routing.ts
+const slackRouteBindingConfigCache = /* @__PURE__ */ new WeakMap();
+function slackTargetDefaultKindForPeer(kind) {
+	return kind === "direct" ? "user" : "channel";
+}
+function slackTargetKindMatchesPeer(peerKind, targetKind) {
+	if (targetKind === "user") return peerKind === "direct";
+	return peerKind === "channel" || peerKind === "group";
+}
+function normalizeSlackRouteBindingPeer(peer) {
+	const rawId = peer.id.trim();
+	if (!rawId || rawId === "*") return peer;
+	const target = (() => {
+		try {
+			return parseSlackTarget(rawId, { defaultKind: slackTargetDefaultKindForPeer(peer.kind) });
+		} catch {
+			return;
+		}
+	})();
+	if (!target || !slackTargetKindMatchesPeer(peer.kind, target.kind) || target.id === peer.id) return peer;
+	return {
+		...peer,
+		id: target.id
+	};
+}
+function normalizeSlackRouteBindingConfig(cfg) {
+	const bindings = cfg.bindings;
+	const cached = slackRouteBindingConfigCache.get(cfg);
+	if (cached && cached.bindingsRef === bindings) return cached.normalizedCfg;
+	if (!Array.isArray(bindings)) return cfg;
+	let changed = false;
+	const normalizedBindings = bindings.map((binding) => {
+		if (binding.type === "acp" || binding.match.channel.trim().toLowerCase() !== "slack") return binding;
+		const peer = binding.match.peer;
+		if (!peer) return binding;
+		const normalizedPeer = normalizeSlackRouteBindingPeer(peer);
+		if (normalizedPeer === peer) return binding;
+		changed = true;
+		return {
+			...binding,
+			match: {
+				...binding.match,
+				peer: normalizedPeer
+			}
+		};
+	});
+	const normalizedCfg = changed ? {
+		...cfg,
+		bindings: normalizedBindings
+	} : cfg;
+	slackRouteBindingConfigCache.set(cfg, {
+		bindingsRef: bindings,
+		normalizedCfg
+	});
+	return normalizedCfg;
+}
+function resolveSlackBaseConversationId(params) {
+	return params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel;
+}
+function resolveSlackInitialAgentRoute(params) {
+	return resolveAgentRoute({
+		cfg: normalizeSlackRouteBindingConfig(params.ctx.cfg),
+		channel: "slack",
+		accountId: params.account.accountId,
+		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
+		}
+	});
+}
+function resolveSlackRoutingContext(params) {
+	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs } = params;
+	let route = resolveSlackInitialAgentRoute({
+		ctx,
+		account,
+		message,
+		isDirectMessage,
+		isRoom
+	});
+	const chatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
+	const replyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, chatType);
+	const threadContext = resolveSlackThreadContext({
+		message,
+		replyToMode,
+		isDirectMessage
+	});
+	const threadTs = threadContext.incomingThreadTs;
+	const isThreadReply = threadContext.isThreadReply;
+	const autoThreadId = !isThreadReply && replyToMode === "all" && threadContext.messageTs ? threadContext.messageTs : void 0;
+	const seedCandidateThreadId = threadContext.incomingThreadTs ?? threadContext.messageTs;
+	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
+	});
+	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
+	const boundThreadRoute = runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
+		route,
+		conversation: {
+			channel: "slack",
+			accountId: account.accountId,
+			conversationId: runtimeBindingThreadId,
+			parentConversationId: baseConversationId
+		}
+	}) : null;
+	const runtimeRoute = boundThreadRoute?.boundSessionKey || boundThreadRoute?.bindingRecord ? boundThreadRoute : resolveRuntimeConversationBindingRoute({
+		route,
+		conversation: {
+			channel: "slack",
+			accountId: account.accountId,
+			conversationId: baseConversationId
+		}
+	});
+	let configuredBinding = null;
+	let configuredBindingSessionKey = "";
+	if (runtimeRoute.boundSessionKey || runtimeRoute.bindingRecord) route = runtimeRoute.route;
+	else {
+		const configuredRoute = resolveConfiguredBindingRoute({
+			cfg: ctx.cfg,
+			route,
+			conversation: {
+				channel: "slack",
+				accountId: account.accountId,
+				conversationId: baseConversationId
+			}
+		});
+		configuredBinding = configuredRoute.bindingResolution;
+		configuredBindingSessionKey = configuredRoute.boundSessionKey ?? "";
+		route = configuredRoute.route;
+	}
+	const threadKeys = runtimeRoute.boundSessionKey || configuredBindingSessionKey ? {
+		sessionKey: route.sessionKey,
+		parentSessionKey: void 0
+	} : resolveThreadSessionKeys({
+		baseSessionKey: route.sessionKey,
+		threadId: routedThreadId,
+		parentSessionKey: routedThreadId && ctx.threadInheritParent ? route.sessionKey : void 0
+	});
+	const sessionKey = threadKeys.sessionKey;
+	const historyKey = isThreadReply && ctx.threadHistoryScope === "thread" ? sessionKey : message.channel;
+	return {
+		route,
+		runtimeBinding: runtimeRoute.bindingRecord,
+		runtimeBoundSessionKey: runtimeRoute.boundSessionKey,
+		configuredBinding,
+		configuredBindingSessionKey,
+		chatType,
+		replyToMode,
+		threadContext,
+		threadTs,
+		isThreadReply,
+		threadKeys,
+		sessionKey,
+		historyKey
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-thread-context-root.ts
+function isSlackThreadAuthorCurrentBot(params) {
+	const { identity, author } = params;
+	if (identity.botUserId && author.userId && author.userId === identity.botUserId) return true;
+	if (identity.botId && author.botId && author.botId === identity.botId) return true;
+	return false;
+}
+function resolveSlackThreadHistoryFilterPolicy(params) {
+	if (!params.includeBotStarterAsRootContext || !params.starterTs) return {};
+	return { retainCurrentBotRootTs: params.starterTs };
+}
+function applySlackThreadHistoryFilterPolicy(params) {
+	const kept = [];
+	let omittedCurrentBot = 0;
+	for (const entry of params.history) {
+		if (!isSlackThreadAuthorCurrentBot({
+			identity: params.identity,
+			author: entry
+		})) {
+			kept.push(entry);
+			continue;
+		}
+		if (params.policy.retainCurrentBotRootTs && entry.ts === params.policy.retainCurrentBotRootTs) kept.push(entry);
+		else omittedCurrentBot += 1;
+	}
+	return {
+		kept,
+		omittedCurrentBot
+	};
+}
+function shouldIncludeBotThreadStarterContext(params) {
+	if (!params.hasStarterText) return false;
+	return params.starterIsCurrentBot && params.isNewThreadSession;
+}
+function ensureSlackThreadHistoryHasBotRoot(params) {
+	if (!params.includeBotStarterAsRootContext || !params.threadStarter?.text) return params.history;
+	if (params.history.some((entry) => entry.ts === params.threadStarter?.ts)) return params.history;
+	return [params.threadStarter, ...params.history];
+}
+function formatSlackBotStarterThreadLabel(params) {
+	const base = `Slack thread ${params.roomLabel}`;
+	if (!params.starterText) return base;
+	const snippet = formatSlackThreadLabelSnippet(params.starterText).trim();
+	if (!snippet) return base;
+	return `${base} (assistant root): ${snippet}`;
+}
+function formatSlackThreadLabelSnippet(text) {
+	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-2VEX4Wdz.mjs").then((n) => n.g));
+const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
+function resolveSlackThreadSessionFreshness(params) {
+	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
+		storePath: params.storePath,
+		sessionKey: params.sessionKey,
+		sessionCfg: params.ctx.cfg.session,
+		resetType: "thread",
+		resetOverride: resolveChannelResetConfig({
+			sessionCfg: params.ctx.cfg.session,
+			channel: "slack"
+		})
+	});
+}
+function isSlackThreadContextSenderAllowed(params) {
+	if (params.allowFromLower.length === 0 || params.botId) return true;
+	if (!params.userId) return false;
+	return resolveSlackAllowListMatch({
+		allowList: params.allowFromLower,
+		id: params.userId,
+		name: params.userName,
+		allowNameMatching: params.allowNameMatching
+	}).allowed;
+}
+async function resolveSlackThreadUserMap(params) {
+	const uniqueUserIds = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of params.messages) {
+		if (!item.userId || seen.has(item.userId)) continue;
+		seen.add(item.userId);
+		uniqueUserIds.push(item.userId);
+	}
+	const userMap = /* @__PURE__ */ new Map();
+	if (uniqueUserIds.length === 0) return userMap;
+	const { results } = await runTasksWithConcurrency({
+		tasks: uniqueUserIds.map((id) => async () => {
+			const user = await params.ctx.resolveUserName(id);
+			return user ? {
+				id,
+				user
+			} : null;
+		}),
+		limit: SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY
+	});
+	for (const result of results) if (result) userMap.set(result.id, result.user);
+	return userMap;
+}
+async function resolveSlackThreadContextData(params) {
+	const botIdentity = {
+		botUserId: params.ctx.botUserId,
+		botId: params.ctx.botId
+	};
+	const isCurrentBotAuthor = (author) => isSlackThreadAuthorCurrentBot({
+		identity: botIdentity,
+		author
+	});
+	let threadStarterBody;
+	let threadHistoryBody;
+	let threadLabel;
+	let threadStarterMedia = null;
+	const threadSessionFreshness = params.isThreadReply && params.threadTs ? resolveSlackThreadSessionFreshness({
+		ctx: params.ctx,
+		storePath: params.storePath,
+		sessionKey: params.sessionKey
+	}) : void 0;
+	const threadSessionPreviousTimestamp = params.isThreadReply && params.threadTs && !threadSessionFreshness ? readSessionUpdatedAt({
+		storePath: params.storePath,
+		sessionKey: params.sessionKey
+	}) : void 0;
+	const shouldSeedInitialThreadContext = Boolean(params.isThreadReply && params.threadTs && (threadSessionFreshness ? threadSessionFreshness.state !== "fresh" : threadSessionPreviousTimestamp === void 0));
+	const shouldLoadInitialThreadHistory = shouldSeedInitialThreadContext || params.forceInitialHistory === true;
+	if (!params.isThreadReply || !params.threadTs) return {
+		threadStarterBody,
+		threadHistoryBody,
+		shouldSeedInitialThreadContext,
+		threadLabel,
+		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 starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor({
+		userId: starter.userId,
+		botId: starter.botId
+	}));
+	const starterAllowed = !starter || !starterIsCurrentBot && isSlackThreadContextSenderAllowed({
+		allowFromLower: params.allowFromLower,
+		allowNameMatching: params.allowNameMatching,
+		userId: starter.userId,
+		userName: starterSenderName,
+		botId: starter.botId
+	});
+	const includeStarterContext = !starter || !starterIsCurrentBot && shouldIncludeSupplementalContext({
+		mode: params.contextVisibilityMode,
+		kind: "thread",
+		senderAllowed: starterAllowed
+	});
+	if (starter?.text && includeStarterContext) {
+		threadStarterBody = starter.text;
+		const snippet = formatSlackThreadLabelSnippet(starter.text);
+		threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
+		if (shouldSeedInitialThreadContext && !params.effectiveDirectMedia && starter.files && starter.files.length > 0) {
+			const { resolveSlackMedia } = await loadSlackMediaModule();
+			threadStarterMedia = await resolveSlackMedia({
+				files: starter.files,
+				client: params.ctx.app.client,
+				token: params.ctx.botToken,
+				maxBytes: params.ctx.mediaMaxBytes
+			});
+			if (threadStarterMedia) {
+				const starterPlaceholders = threadStarterMedia.map((item) => item.placeholder).join(", ");
+				logVerbose(`slack: hydrated thread starter file ${starterPlaceholders} from root message`);
+			}
+		}
+	} else threadLabel = `Slack thread ${params.roomLabel}`;
+	const includeBotStarterAsRootContext = shouldIncludeBotThreadStarterContext({
+		starterIsCurrentBot,
+		isNewThreadSession: shouldSeedInitialThreadContext,
+		hasStarterText: Boolean(starter?.text)
+	});
+	if (starter?.text && starterIsCurrentBot && !includeBotStarterAsRootContext) logVerbose("slack: omitted current-bot thread starter from context");
+	else if (starter?.text && !includeStarterContext && !starterIsCurrentBot) logVerbose(`slack: omitted thread starter from context (mode=${params.contextVisibilityMode}, sender_allowed=${starterAllowed ? "yes" : "no"})`);
+	else if (includeBotStarterAsRootContext) {
+		threadLabel = formatSlackBotStarterThreadLabel({
+			roomLabel: params.roomLabel,
+			starterText: starter?.text
+		});
+		logVerbose("slack: retained current-bot thread starter as assistant root context");
+	}
+	const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;
+	if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {
+		const currentBotRootTs = starter?.ts ?? params.threadTs;
+		const threadHistoryWithBotRoot = ensureSlackThreadHistoryHasBotRoot({
+			history: await resolveSlackThreadHistory({
+				channelId: params.message.channel,
+				threadTs: params.threadTs,
+				client: params.ctx.app.client,
+				currentMessageTs: params.message.ts,
+				limit: threadInitialHistoryLimit
+			}),
+			includeBotStarterAsRootContext,
+			threadStarter: starter ? {
+				...starter,
+				ts: currentBotRootTs
+			} : null
+		});
+		if (threadHistoryWithBotRoot.length > 0) {
+			const { kept: threadHistoryWithoutCurrentBot, omittedCurrentBot: omittedCurrentBotHistoryCount } = applySlackThreadHistoryFilterPolicy({
+				history: threadHistoryWithBotRoot,
+				policy: resolveSlackThreadHistoryFilterPolicy({
+					includeBotStarterAsRootContext,
+					starterTs: currentBotRootTs
+				}),
+				identity: botIdentity
+			});
+			const userMapForFilter = params.contextVisibilityMode !== "all" && params.allowNameMatching && params.allowFromLower.length > 0 ? await resolveSlackThreadUserMap({
+				ctx: params.ctx,
+				messages: threadHistoryWithoutCurrentBot
+			}) : /* @__PURE__ */ new Map();
+			const { items: filteredThreadHistory, omitted: omittedHistoryCount } = params.contextVisibilityMode === "all" ? {
+				items: threadHistoryWithoutCurrentBot,
+				omitted: 0
+			} : filterSupplementalContextItems({
+				items: threadHistoryWithoutCurrentBot,
+				mode: params.contextVisibilityMode,
+				kind: "thread",
+				isSenderAllowed: (historyMsg) => {
+					if (isCurrentBotAuthor({
+						userId: historyMsg.userId,
+						botId: historyMsg.botId
+					})) return true;
+					const msgUser = historyMsg.userId ? userMapForFilter.get(historyMsg.userId) : null;
+					return isSlackThreadContextSenderAllowed({
+						allowFromLower: params.allowFromLower,
+						allowNameMatching: params.allowNameMatching,
+						userId: historyMsg.userId,
+						userName: msgUser?.name,
+						botId: historyMsg.botId
+					});
+				}
+			});
+			const userMap = await resolveSlackThreadUserMap({
+				ctx: params.ctx,
+				messages: filteredThreadHistory
+			});
+			if (omittedHistoryCount > 0 || omittedCurrentBotHistoryCount > 0) logVerbose(`slack: omitted ${omittedHistoryCount + omittedCurrentBotHistoryCount} thread message(s) from context (mode=${params.contextVisibilityMode})`);
+			const historyParts = [];
+			for (const historyMsg of filteredThreadHistory) {
+				const msgUser = historyMsg.userId ? userMap.get(historyMsg.userId) : null;
+				const isOtherBot = Boolean(historyMsg.botId) && historyMsg.botId !== params.ctx.botId;
+				const isCurrentBot = isCurrentBotAuthor({
+					userId: historyMsg.userId,
+					botId: historyMsg.botId
+				});
+				const role = isCurrentBot || isOtherBot || Boolean(historyMsg.botId) ? "assistant" : "user";
+				const msgSenderName = isCurrentBot ? "Bot (this assistant)" : msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
+				const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
+				historyParts.push(formatInboundEnvelope({
+					channel: "Slack",
+					from: `${msgSenderName} (${role})`,
+					timestamp: resolveSlackTimestampMs(historyMsg.ts),
+					body: msgWithId,
+					chatType: "channel",
+					envelope: params.envelopeOptions
+				}));
+			}
+			if (historyParts.length > 0) {
+				threadHistoryBody = historyParts.join("\n\n");
+				logVerbose(`slack: populated thread history with ${filteredThreadHistory.length} messages for new session`);
+			}
+		}
+	}
+	return {
+		threadStarterBody,
+		threadHistoryBody,
+		shouldSeedInitialThreadContext,
+		threadLabel,
+		threadStarterMedia
+	};
+}
+//#endregion
+//#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 = 3e5;
+let subteamMemberCache = /* @__PURE__ */ new WeakMap();
+function normalizeSlackId(value) {
+	return typeof value === "string" && value.trim() ? value.trim().toUpperCase() : void 0;
+}
+function extractSlackSubteamMentionIds(text) {
+	if (!text) return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(SUBTEAM_MENTION_RE)) {
+		const id = normalizeSlackId(match[1]);
+		if (id) ids.add(id);
+	}
+	return [...ids];
+}
+async function readSlackSubteamUsers(params) {
+	let bySubteam = subteamMemberCache.get(params.client);
+	if (!bySubteam) {
+		bySubteam = /* @__PURE__ */ new Map();
+		subteamMemberCache.set(params.client, bySubteam);
+	}
+	const cacheKey = `${normalizeSlackId(params.teamId) ?? ""}:${params.subteamId}`;
+	const cached = bySubteam.get(cacheKey);
+	const now = asDateTimestampMs(params.now);
+	if (cached) {
+		if (now !== void 0 && asDateTimestampMs(cached.expiresAt) !== void 0 && cached.expiresAt > now) return cached.users;
+		bySubteam.delete(cacheKey);
+	}
+	try {
+		const response = await params.client.usergroups.users.list({
+			usergroup: params.subteamId,
+			...params.teamId ? { team_id: params.teamId } : {}
+		});
+		if (!response.ok) {
+			params.log?.(`slack: failed to resolve user-group mention ${params.subteamId}: ${response.error ?? "unknown_error"}`);
+			return /* @__PURE__ */ new Set();
+		}
+		const users = new Set((response.users ?? []).map((userId) => normalizeSlackId(userId)).filter(Boolean));
+		const expiresAt = resolveExpiresAtMsFromDurationMs(SUBTEAM_MEMBER_CACHE_TTL_MS, { nowMs: params.now });
+		if (expiresAt !== void 0) bySubteam.set(cacheKey, {
+			expiresAt,
+			users
+		});
+		return users;
+	} catch (err) {
+		params.log?.(`slack: failed to resolve user-group mention ${params.subteamId}: ${formatErrorMessage(err)}`);
+		return /* @__PURE__ */ new Set();
+	}
+}
+async function isSlackSubteamMentionForBot(params) {
+	const botUserId = normalizeSlackId(params.botUserId);
+	if (!botUserId) return false;
+	const subteamIds = extractSlackSubteamMentionIds(params.text);
+	if (subteamIds.length === 0) return false;
+	const now = params.now ?? Date.now();
+	for (const subteamId of subteamIds) if ((await readSlackSubteamUsers({
+		client: params.client,
+		subteamId,
+		teamId: normalizeOptionalString(params.teamId),
+		now,
+		log: params.log
+	})).has(botUserId)) return true;
+	return false;
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare.ts
+const mentionRegexCache = /* @__PURE__ */ new WeakMap();
+const SLACK_ANY_MENTION_RE = /<@[^>]+>|<!subteam\^[^>]+>/;
+const SLACK_USER_MENTION_RE = /<@([^>|]+)(?:\|[^>]+)?>/g;
+const SLACK_SUBTEAM_MENTION_RE = /<!subteam\^([^>|]+)(?:\|[^>]+)?>/g;
+const SLACK_SUBTEAM_MENTION_MARKER = "<!subteam^";
+const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
+const SLACK_HISTORY_MEDIA_MAX_BYTES = 10485760;
+const SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS = 1e3;
+const SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS = 3e3;
+function recordString(record, key) {
+	return normalizeOptionalString(record?.[key]);
+}
+function recordNullableString(record, key) {
+	if (!record || !(key in record)) return;
+	if (record[key] === null) return null;
+	return normalizeOptionalString(record[key]);
+}
+function mergeSlackAssistantThreadContext(primary, fallback) {
+	if (!primary) return fallback;
+	if (!fallback) return primary;
+	return {
+		assistantChannelId: primary.assistantChannelId || fallback.assistantChannelId,
+		threadTs: primary.threadTs || fallback.threadTs,
+		userId: primary.userId ?? fallback.userId,
+		channelId: primary.channelId ?? fallback.channelId,
+		teamId: primary.teamId ?? fallback.teamId,
+		enterpriseId: primary.enterpriseId !== void 0 ? primary.enterpriseId : fallback.enterpriseId
+	};
+}
+function hasSlackAssistantThreadMetadata(context) {
+	return Boolean(context?.channelId || context?.teamId || context?.enterpriseId !== void 0);
+}
+function resolveSlackMessageAssistantThreadContext(message) {
+	const thread = asOptionalRecord(message.assistant_thread);
+	if (!thread) return;
+	const context = asOptionalRecord(thread.context);
+	const assistantChannelId = recordString(thread, "channel_id") ?? message.channel;
+	const threadTs = recordString(thread, "thread_ts") ?? message.thread_ts ?? message.ts;
+	if (!assistantChannelId || !threadTs) return;
+	return {
+		assistantChannelId,
+		threadTs,
+		userId: recordString(thread, "user_id") ?? message.user,
+		channelId: recordString(context, "channel_id"),
+		teamId: recordString(context, "team_id"),
+		enterpriseId: recordNullableString(context, "enterprise_id")
+	};
+}
+async function restoreSlackAssistantThreadContextFromMetadata(params) {
+	const threadTs = params.message.thread_ts;
+	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({
+			channel: params.message.channel,
+			ts: threadTs,
+			oldest: threadTs,
+			include_all_metadata: true,
+			limit: 4
+		});
+		for (const message of response.messages ?? []) {
+			const context = parseSlackAssistantThreadMetadata(message.metadata);
+			if (!context) continue;
+			return {
+				assistantChannelId: params.message.channel,
+				threadTs,
+				userId: params.message.user,
+				channelId: context.channelId,
+				teamId: context.teamId,
+				enterpriseId: context.enterpriseId
+			};
+		}
+	} catch (err) {
+		logVerbose(`slack assistant context restore failed channel=${params.message.channel} ts=${threadTs}: ${formatErrorMessage(err)}`);
+	}
+}
+function resolveCachedMentionRegexes(ctx, agentId, options) {
+	const key = [
+		normalizeOptionalString(agentId) ?? "__default__",
+		normalizeOptionalString(options?.provider),
+		normalizeOptionalString(options?.conversationId ?? void 0),
+		options?.providerPolicy ? JSON.stringify(options.providerPolicy) : ""
+	].join("");
+	let byAgent = mentionRegexCache.get(ctx);
+	if (!byAgent) {
+		byAgent = /* @__PURE__ */ new Map();
+		mentionRegexCache.set(ctx, byAgent);
+	}
+	const cached = byAgent.get(key);
+	if (cached) return cached;
+	const built = buildMentionRegexes(ctx.cfg, agentId, options);
+	byAgent.set(key, built);
+	return built;
+}
+function isSlackImageFileCandidate(file) {
+	if ((file.mimetype?.split(";")[0]?.trim().toLowerCase())?.startsWith("image/")) return true;
+	return Boolean(mimeTypeFromFilePath(file.name)?.startsWith("image/"));
+}
+function sliceSlackImageFileCandidates(files, limit) {
+	if (limit <= 0 || !files?.length) return [];
+	return files.filter(isSlackImageFileCandidate).slice(0, limit);
+}
+function sliceSlackHistoryAttachmentCandidates(attachments, limit) {
+	if (limit <= 0 || !attachments?.length) return [];
+	const out = [];
+	let remaining = limit;
+	for (const attachment of attachments) {
+		if (attachment.is_share !== true) continue;
+		const hasImageUrl = Boolean(normalizeOptionalString(attachment.image_url));
+		const files = sliceSlackImageFileCandidates(attachment.files, remaining - (hasImageUrl ? 1 : 0));
+		if (!hasImageUrl && files.length === 0) continue;
+		out.push({
+			...attachment,
+			files
+		});
+		remaining -= (hasImageUrl ? 1 : 0) + files.length;
+		if (remaining <= 0) break;
+	}
+	return out;
+}
+function buildSlackHistoryMediaCandidateMessage(message) {
+	const files = sliceSlackImageFileCandidates(message.files, SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS);
+	const attachments = sliceSlackHistoryAttachmentCandidates(message.attachments, Math.max(0, SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS - files.length));
+	if (files.length === 0 && attachments.length === 0) return null;
+	return {
+		...message,
+		files,
+		attachments
+	};
+}
+async function resolveSlackHistoryMediaForPendingRecord(params) {
+	const mediaMessage = buildSlackHistoryMediaCandidateMessage(params.message);
+	if (!mediaMessage) return [];
+	const content = await resolveSlackMessageContent({
+		message: mediaMessage,
+		isThreadReply: params.isThreadReply,
+		threadStarter: params.threadStarter,
+		isBotMessage: params.isBotMessage,
+		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,
+		mediaTotalTimeoutMs: SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS
+	});
+	return toInboundMediaFacts(content?.effectiveDirectMedia, {
+		kind: "image",
+		messageId: params.message.ts
+	});
+}
+function collectUniqueSlackMentionIds(text, regex) {
+	const ids = [];
+	regex.lastIndex = 0;
+	for (const match of text.matchAll(regex)) {
+		const id = normalizeSlackId(match[1]);
+		if (id && !ids.includes(id)) ids.push(id);
+	}
+	return ids;
+}
+function collectSlackMentionMetadata(text) {
+	return {
+		mentionedUserIds: collectUniqueSlackMentionIds(text, SLACK_USER_MENTION_RE),
+		mentionedSubteamIds: collectUniqueSlackMentionIds(text, SLACK_SUBTEAM_MENTION_RE),
+		hasAnyMention: SLACK_ANY_MENTION_RE.test(text),
+		hasSubteamMention: text.includes(SLACK_SUBTEAM_MENTION_MARKER)
+	};
+}
+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,
+		text: params.messageText,
+		botUserId: params.ctx.botUserId,
+		teamId: params.ctx.teamId,
+		log: logVerbose
+	});
+	return {
+		explicitlyMentionedBotUser,
+		explicitlyMentionedBotSubteam,
+		explicitlyMentioned: explicitlyMentionedBotUser || explicitlyMentionedBotSubteam || params.source === "app_mention"
+	};
+}
+function resolveSlackMentionSource(params) {
+	if (params.explicitBotMention) return "explicit_bot";
+	if (params.explicitSubteamMention) return "subteam";
+	if (params.shouldBypassMention) return "command_bypass";
+	if (params.wasMentioned) return "mention_pattern";
+	if (params.matchedImplicitMentionKinds.length > 0) return "implicit_thread";
+	return "none";
+}
+function buildSlackMentionContextPayload(params) {
+	if (!params.isRoomish) return {};
+	return {
+		WasMentioned: params.effectiveWasMentioned,
+		ExplicitlyMentionedBot: params.explicitlyMentioned,
+		MentionedUserIds: params.mentionedUserIds.length > 0 ? [...params.mentionedUserIds] : void 0,
+		MentionedSubteamIds: params.mentionedSubteamIds.length > 0 ? [...params.mentionedSubteamIds] : void 0,
+		ImplicitMentionKinds: params.matchedImplicitMentionKinds.length > 0 ? [...params.matchedImplicitMentionKinds] : void 0,
+		MentionSource: params.mentionSource
+	};
+}
+async function resolveSlackConversationContext(params) {
+	const { ctx, account, message } = params;
+	const cfg = ctx.cfg;
+	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);
+	}
+	const channelName = channelInfo?.name;
+	const isDirectMessage = resolvedChannelType === "im";
+	const isGroupDm = resolvedChannelType === "mpim";
+	const isRoom = resolvedChannelType === "channel" || resolvedChannelType === "group";
+	const isRoomish = isRoom || isGroupDm;
+	const channelConfig = isRoom ? resolveSlackChannelConfig({
+		channelId: message.channel,
+		channelName,
+		channels: ctx.channelsConfig,
+		channelKeys: ctx.channelsConfigKeys,
+		defaultRequireMention: ctx.defaultRequireMention,
+		allowNameMatching: ctx.allowNameMatching
+	}) : null;
+	const allowBotsSetting = channelConfig?.allowBots ?? account.config?.allowBots ?? cfg.channels?.slack?.allowBots ?? false;
+	return {
+		channelInfo,
+		channelName,
+		resolvedChannelType,
+		isDirectMessage,
+		isGroupDm,
+		isRoom,
+		isRoomish,
+		channelConfig,
+		allowBotsMode: allowBotsSetting === "mentions" ? "mentions" : allowBotsSetting ? "all" : "off",
+		isBotMessage: Boolean(message.bot_id)
+	};
+}
+async function authorizeSlackInboundMessage(params) {
+	const { ctx, account, message, conversation } = params;
+	const { isDirectMessage, channelName, resolvedChannelType, isBotMessage, allowBotsMode } = conversation;
+	if (isBotMessage) {
+		if (message.user && ctx.botUserId && message.user === ctx.botUserId) return null;
+		if (allowBotsMode === "off") {
+			logVerbose(`slack: drop bot message ${message.bot_id ?? "unknown"} (allowBots=false)`);
+			return null;
+		}
+	}
+	if (isDirectMessage && !message.user) {
+		logVerbose("slack: drop dm message (missing user id)");
+		return null;
+	}
+	const senderId = message.user ?? (isBotMessage ? message.bot_id : void 0);
+	if (!senderId) {
+		logVerbose("slack: drop message (missing sender id)");
+		return null;
+	}
+	if (!ctx.isChannelAllowed({
+		channelId: message.channel,
+		channelName,
+		channelType: resolvedChannelType
+	})) {
+		logVerbose("slack: drop message (channel not allowed)");
+		return null;
+	}
+	const allowFromLower = await resolveSlackEffectiveAllowFrom(ctx, { includePairingStore: isDirectMessage });
+	if (isDirectMessage) {
+		const directUserId = message.user;
+		if (!directUserId) {
+			logVerbose("slack: drop dm message (missing user id)");
+			return null;
+		}
+		if (!await authorizeSlackDirectMessage({
+			ctx,
+			accountId: account.accountId,
+			senderId: directUserId,
+			allowFromLower,
+			resolveSenderName: ctx.resolveUserName,
+			sendPairingReply: async (text) => {
+				await sendMessageSlack(message.channel, text, {
+					cfg: ctx.cfg,
+					token: ctx.botToken,
+					client: ctx.app.client,
+					accountId: account.accountId
+				});
+			},
+			onDisabled: () => {
+				logVerbose("slack: drop dm (dms disabled)");
+			},
+			onUnauthorized: ({ allowMatchMeta }) => {
+				logVerbose(`Blocked unauthorized slack sender ${message.user} (dmPolicy=${ctx.dmPolicy}, ${allowMatchMeta})`);
+			},
+			log: logVerbose
+		})) return null;
+	}
+	return {
+		senderId,
+		allowFromLower
+	};
+}
+async function prepareSlackMessage(params) {
+	const { ctx, account, message, opts } = params;
+	const cfg = ctx.cfg;
+	const conversation = await resolveSlackConversationContext({
+		ctx,
+		account,
+		message
+	});
+	const { channelInfo, channelName, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, allowBotsMode, isBotMessage } = conversation;
+	const authorization = await authorizeSlackInboundMessage({
+		ctx,
+		account,
+		message,
+		conversation
+	});
+	if (!authorization) return null;
+	const { senderId, allowFromLower } = authorization;
+	const messageText = message.text ?? "";
+	let resolvedSenderName = normalizeOptionalString(message.username);
+	const resolveSenderName = async () => {
+		if (resolvedSenderName) return resolvedSenderName;
+		if (message.user) {
+			const sender = await ctx.resolveUserName(message.user);
+			const normalized = normalizeOptionalString(sender?.name);
+			if (normalized) {
+				resolvedSenderName = normalized;
+				return resolvedSenderName;
+			}
+		}
+		resolvedSenderName = message.user ?? message.bot_id ?? "unknown";
+		return resolvedSenderName;
+	};
+	const mentionMetadata = collectSlackMentionMetadata(messageText);
+	const { mentionedUserIds, mentionedSubteamIds, hasAnyMention } = mentionMetadata;
+	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 restoredAssistantThreadContextPromise = isDirectMessage && !cachedAssistantThreadContext && !hasSlackAssistantThreadMetadata(messageAssistantThreadContext) ? restoreSlackAssistantThreadContextFromMetadata({
+		ctx,
+		message
+	}) : Promise.resolve(void 0);
+	const { explicitlyMentionedBotUser, explicitlyMentionedBotSubteam, explicitlyMentioned } = await resolveSlackExplicitMentionState({
+		ctx,
+		messageText,
+		mentionedUserIds,
+		hasSubteamMention: mentionMetadata.hasSubteamMention,
+		source: opts.source
+	});
+	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);
+	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, channelChatType);
+	const willImplicitlyThreadReply = isRoom && !channelRequireMention && channelReplyToMode !== "off";
+	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
+	let routing = resolveSlackRoutingContext({
+		ctx,
+		account,
+		message,
+		isDirectMessage,
+		isGroupDm,
+		isRoom,
+		isRoomish,
+		channelConfig,
+		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource,
+		assistantThreadTs: assistantThreadContext?.threadTs
+	});
+	const resolveWasMentioned = (mentionRegexes) => opts.wasMentioned ?? (!isDirectMessage && matchesMentionWithExplicit({
+		text: messageText,
+		mentionRegexes,
+		explicit: {
+			hasAnyMention,
+			isExplicitlyMentioned: explicitlyMentioned,
+			canResolveExplicit: Boolean(ctx.botUserId)
+		}
+	}));
+	const buildPolicyMentionRegexes = (agentId) => resolveCachedMentionRegexes(ctx, agentId, {
+		provider: "slack",
+		conversationId: message.channel,
+		providerPolicy: account.config.mentionPatterns
+	});
+	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;
+	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}`);
+	if (configuredBinding) {
+		const ensured = await ensureConfiguredBindingRouteReady({
+			cfg,
+			bindingResolution: configuredBinding
+		});
+		if (ensured.ok) {
+			if (shouldLogVerbose()) logVerbose(`slack: using configured ACP binding for ${configuredBinding.record.conversation.conversationId} -> ${configuredBindingSessionKey}`);
+		} else {
+			if (shouldLogVerbose()) logVerbose(`slack: configured ACP binding unavailable for ${configuredBinding.record.conversation.conversationId}: ${ensured.error}`);
+			logInboundDrop({
+				log: logVerbose,
+				channel: "slack",
+				reason: "configured ACP binding unavailable",
+				target: configuredBinding.record.conversation.conversationId
+			});
+			return null;
+		}
+	}
+	const senderNameForAuthPromise = ctx.allowNameMatching ? resolveSenderName().then((name) => ({
+		ok: true,
+		name
+	}), (error) => ({
+		ok: false,
+		error
+	})) : Promise.resolve({
+		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
+		}));
+	}
+	const recordDroppedHistory = async (reason) => {
+		const pendingText = (message.text ?? "").trim();
+		const historyMediaCandidate = buildSlackHistoryMediaCandidateMessage(message);
+		const fallbackFile = message.files?.length ? `[Slack file: ${formatSlackFileReference(message.files[0])}]` : "";
+		const pendingBody = pendingText || fallbackFile || (!fallbackFile && historyMediaCandidate ? "[Slack media attachment]" : "");
+		const skippedThreadStarter = historyMediaCandidate && isThreadReply && threadTs ? await resolveSlackThreadStarter({
+			channelId: message.channel,
+			threadTs,
+			client: ctx.app.client
+		}) : null;
+		const senderName = pendingBody ? await resolveSenderName() : void 0;
+		await recordDroppedChannelInboundHistory({
+			input: {
+				id: message.ts ?? `${message.channel}:${Date.now()}`,
+				timestamp: resolveSlackTimestampMs(message.ts),
+				rawText: pendingBody,
+				textForAgent: pendingBody,
+				raw: message
+			},
+			admission: {
+				kind: "drop",
+				reason,
+				recordHistory: true
+			},
+			preflight: {
+				message: pendingBody ? {
+					rawBody: pendingBody,
+					body: pendingBody,
+					bodyForAgent: pendingBody,
+					senderLabel: senderName,
+					envelopeFrom: senderName
+				} : void 0,
+				history: {
+					key: historyKey,
+					historyMap: ctx.channelHistories,
+					limit: ctx.historyLimit,
+					recordOnDrop: true,
+					mediaLimit: SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS,
+					shouldRecord: opts.shouldRecordDroppedHistory
+				},
+				media: () => resolveSlackHistoryMediaForPendingRecord({
+					ctx,
+					message,
+					isThreadReply,
+					threadStarter: skippedThreadStarter,
+					isBotMessage
+				})
+			}
+		});
+	};
+	const senderNameForAuthResult = await senderNameForAuthPromise;
+	if (!senderNameForAuthResult.ok) throw senderNameForAuthResult.error;
+	const senderNameForAuth = senderNameForAuthResult.name;
+	const allowTextCommands = shouldHandleTextCommands({
+		cfg,
+		surface: "slack"
+	});
+	const shouldRequireMention = isRoom ? channelConfig?.requireMention ?? ctx.defaultRequireMention : false;
+	if (message["_ambiguousThreadReply"]) {
+		ctx.logger.info({
+			channel: message.channel,
+			ts: message.ts,
+			parentUserId: message.parent_user_id
+		}, "skipping ambiguous slack thread reply");
+		return null;
+	}
+	const canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
+	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
+	const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
+	const hasAbortRequest = isAbortRequestText(textForCommandDetection);
+	const channelUsersAllowlistConfigured = isRoom && Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
+	const messageIngress = await resolveSlackCommandIngress({
+		ctx,
+		senderId,
+		senderName: senderNameForAuth,
+		channelType: conversation.resolvedChannelType ?? "channel",
+		channelId: message.channel,
+		ownerAllowFromLower: allowFromLower,
+		channelUsers: isRoom ? channelConfig?.users : void 0,
+		allowTextCommands,
+		hasControlCommand: hasControlCommandInMessage,
+		mentionFacts: {
+			canDetectMention,
+			wasMentioned,
+			hasAnyMention,
+			implicitMentionKinds
+		},
+		activation: {
+			requireMention: shouldRequireMention,
+			allowTextCommands,
+			...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)`);
+		return null;
+	}
+	if (isRoom && isBotMessage && allowBotsMode !== "off" && !await authorizeSlackBotRoomMessage({
+		ctx,
+		channelId: message.channel,
+		senderId,
+		senderName: senderNameForAuth,
+		channelUsers: channelConfig?.users,
+		allowFromLower
+	})) 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,
+		channel: "slack",
+		accountId: account.accountId
+	});
+	const commandAuthorized = messageIngress.commandAccess.authorized;
+	if (isRoomish && messageIngress.commandAccess.shouldBlockControlCommand) {
+		logInboundDrop({
+			log: logVerbose,
+			channel: "slack",
+			reason: "control command (unauthorized)",
+			target: senderId
+		});
+		return null;
+	}
+	if (isRoom && shouldRequireMention && !canDetectMention && !effectiveWasMentioned) {
+		ctx.logger.info({
+			channel: message.channel,
+			reason: "mention-detection-unavailable"
+		}, "skipping channel message");
+		await recordDroppedHistory("slack-mention-detection-unavailable");
+		return null;
+	}
+	const ignoreOtherMentions = channelConfig?.ignoreOtherMentions ?? false;
+	if (isRoom && ignoreOtherMentions && Boolean(ctx.botUserId) && hasAnyMention && !wasMentioned) {
+		logInboundDrop({
+			log: logVerbose,
+			channel: "slack",
+			reason: "other-mention",
+			target: senderId
+		});
+		await recordDroppedHistory("slack-other-mention");
+		return null;
+	}
+	if (isRoom && shouldRequireMention && messageIngress.activationAccess.shouldSkip) {
+		ctx.logger.info({
+			channel: message.channel,
+			reason: "no-mention"
+		}, "skipping channel message");
+		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 },
+		unmentionedGroupPolicy: resolveUnmentionedGroupInboundPolicy({
+			cfg,
+			agentId: route.agentId
+		}),
+		wasMentioned: effectiveWasMentioned,
+		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
+	});
+	if (!resolvedMessageContent) return null;
+	const { rawBody, effectiveDirectMedia } = resolvedMessageContent;
+	const ackReaction = resolveAckReaction(cfg, route.agentId, {
+		channel: "slack",
+		accountId: account.accountId
+	});
+	const ackReactionValue = ackReaction ?? "";
+	const sourceRepliesAreToolOnly = resolveChannelMessageSourceReplyDeliveryMode({
+		cfg,
+		ctx: {
+			ChatType: chatType,
+			InboundEventKind: inboundEventKind
+		}
+	}) === "message_tool_only";
+	const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
+	const isRoomEvent = inboundEventKind === "room_event";
+	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
+		scope: ctx.ackReactionScope,
+		inboundEventKind,
+		isDirect: isDirectMessage,
+		isGroup: isRoomish,
+		isMentionableGroup: isRoom,
+		requireMention: shouldRequireMention,
+		canDetectMention,
+		effectiveWasMentioned,
+		shouldBypassMention
+	}));
+	const ackReactionMessageTs = message.ts;
+	const allowToolOnlyStatusReaction = statusReactionsExplicitlyEnabled && (effectiveWasMentioned || shouldBypassMention);
+	const shouldSendAckReaction = shouldAckReaction$1() && (!sourceRepliesAreToolOnly || allowToolOnlyStatusReaction || isRoomEvent);
+	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
+	}).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 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, {
+		sessionKey,
+		contextKey: `slack:message:${message.channel}:${message.ts ?? "unknown"}`
+	});
+	const envelopeFrom = resolveConversationLabel$1({
+		ChatType: chatType,
+		SenderName: senderName,
+		GroupSubject: isRoomish ? roomLabel : void 0,
+		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 storePath = resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId });
+	const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
+	const previousTimestamp = readSessionUpdatedAt({
+		storePath,
+		sessionKey
+	});
+	if (opts.source === "app_mention" && !ctx.botUserId && message.ts) {
+		const pendingHistory = ctx.channelHistories.get(historyKey);
+		if (pendingHistory) ctx.channelHistories.set(historyKey, pendingHistory.filter((entry) => entry.messageId !== message.ts));
+	}
+	const channelHistory = createChannelHistoryWindow({ historyMap: ctx.channelHistories });
+	const dmHistoryLimit = isDirectMessage ? resolveSlackDmHistoryLimit({
+		account,
+		userId: message.user,
+		defaultLimit: ctx.dmHistoryLimit
+	}) : 0;
+	let combinedBody = formatInboundEnvelope({
+		channel: "Slack",
+		from: envelopeFrom,
+		timestamp: resolveSlackTimestampMs(message.ts),
+		body: textWithId,
+		chatType,
+		sender: {
+			name: senderName,
+			id: senderId
+		},
+		previousTimestamp,
+		envelope: envelopeOptions
+	});
+	const dmHistoryContext = isDirectMessage && !isThreadReply && dmHistoryLimit > 0 && !previousTimestamp ? await resolveSlackDmHistoryContext({
+		ctx,
+		channelId: message.channel,
+		currentMessageTs: message.ts,
+		limit: dmHistoryLimit,
+		envelopeOptions
+	}) : {
+		body: void 0,
+		inboundHistory: void 0
+	};
+	if (dmHistoryContext.body) combinedBody = `${dmHistoryContext.body}\n\n${combinedBody}`;
+	if (isRoomish && ctx.historyLimit > 0) combinedBody = channelHistory.buildPendingContext({
+		historyKey,
+		limit: ctx.historyLimit,
+		currentMessage: combinedBody,
+		formatEntry: (entry) => formatInboundEnvelope({
+			channel: "Slack",
+			from: roomLabel,
+			timestamp: entry.timestamp,
+			body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} channel:${message.channel}]` : ""}`,
+			chatType: "channel",
+			senderLabel: entry.sender,
+			envelope: envelopeOptions
+		})
+	});
+	const slackTo = isDirectMessage ? `user:${message.user}` : `channel:${message.channel}`;
+	const { untrustedChannelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
+		isRoomish,
+		channelInfo,
+		channelConfig
+	});
+	const { threadStarterBody, threadHistoryBody, shouldSeedInitialThreadContext, threadLabel, threadStarterMedia } = await resolveSlackThreadContextData({
+		ctx,
+		account,
+		message,
+		isThreadReply,
+		threadTs,
+		threadStarter,
+		roomLabel,
+		storePath,
+		sessionKey,
+		forceInitialHistory: Boolean(directThreadRoutedToDmSession),
+		allowFromLower: threadContextAllowFromLower,
+		allowNameMatching: ctx.allowNameMatching,
+		contextVisibilityMode,
+		envelopeOptions,
+		effectiveDirectMedia
+	});
+	const effectiveMedia = effectiveDirectMedia ?? threadStarterMedia;
+	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? channelHistory.buildInboundHistory({
+		historyKey,
+		limit: ctx.historyLimit
+	}) : dmHistoryContext.inboundHistory;
+	const commandBody = textForCommandDetection.trim();
+	const supplementalThreadHistoryBody = directThreadRoutedToDmSession && !threadHistoryBody ? threadStarterBody : threadHistoryBody;
+	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? threadContext.messageThreadId;
+	const ctxPayload = buildChannelInboundEventContext({
+		channel: "slack",
+		accountId: route.accountId,
+		messageId: message.ts,
+		timestamp: resolveSlackTimestampMs(message.ts),
+		from: slackFrom,
+		sender: {
+			id: senderId,
+			name: senderName,
+			displayLabel: senderName,
+			isBot: isBotMessage || void 0
+		},
+		conversation: {
+			kind: chatType,
+			id: message.channel,
+			label: envelopeFrom,
+			spaceId: ctx.teamId || void 0,
+			threadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
+			nativeChannelId: message.channel
+		},
+		route: {
+			agentId: route.agentId,
+			accountId: route.accountId,
+			routeSessionKey: sessionKey,
+			parentSessionKey: threadKeys.parentSessionKey
+		},
+		reply: {
+			to: slackTo,
+			replyToId: threadContext.replyToId,
+			messageThreadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
+			nativeChannelId: message.channel
+		},
+		message: {
+			inboundEventKind,
+			body: combinedBody,
+			bodyForAgent: rawBody,
+			rawBody,
+			commandBody,
+			inboundHistory
+		},
+		access: {
+			mentions: {
+				canDetectMention: isRoomish,
+				wasMentioned: effectiveWasMentioned,
+				hasAnyMention: explicitlyMentioned || mentionedSubteamIds.length > 0,
+				implicitMentionKinds: matchedImplicitMentionKinds,
+				requireMention: shouldRequireMention,
+				effectiveWasMentioned
+			},
+			commands: { authorized: commandAuthorized }
+		},
+		media: toInboundMediaFacts(effectiveMedia),
+		supplemental: {
+			thread: {
+				starterBody: !directThreadRoutedToDmSession && shouldSeedInitialThreadContext ? threadStarterBody : void 0,
+				historyBody: supplementalThreadHistoryBody,
+				label: directThreadRoutedToDmSession ? void 0 : threadLabel
+			},
+			groupSystemPrompt
+		},
+		extra: {
+			GroupSubject: isRoomish ? roomLabel : void 0,
+			UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
+			TransportThreadId: directThreadRoutedToDmSession ? threadContext.messageThreadId : void 0,
+			SlackAssistantThread: assistantThreadContext ? true : void 0,
+			SlackAssistantThreadContextChannelId: assistantThreadContext?.channelId,
+			SlackAssistantThreadContextTeamId: assistantThreadContext?.teamId,
+			SlackAssistantThreadContextEnterpriseId: assistantThreadContext?.enterpriseId ?? void 0,
+			IsFirstThreadTurn: isThreadReply && threadTs && !directThreadRoutedToDmSession && shouldSeedInitialThreadContext ? true : void 0,
+			...buildSlackMentionContextPayload({
+				isRoomish,
+				effectiveWasMentioned,
+				explicitlyMentioned,
+				mentionedUserIds,
+				mentionedSubteamIds,
+				matchedImplicitMentionKinds,
+				mentionSource
+			})
+		}
+	});
+	ctxPayload.ReplyToMode = replyToMode;
+	if (isRoomish && !shouldRequireMention) channelHistory.record({
+		historyKey,
+		limit: ctx.historyLimit,
+		entry: {
+			sender: senderName,
+			body: rawBody,
+			timestamp: resolveSlackTimestampMs(message.ts),
+			messageId: message.ts
+		}
+	});
+	const pinnedMainDmOwner = isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist({
+		dmScope: cfg.session?.dmScope,
+		allowFrom: ctx.allowFrom,
+		normalizeEntry: normalizeSlackAllowOwnerEntry
+	}) : null;
+	const replyTarget = isDirectMessage ? `channel:${message.channel}` : ctxPayload.To ?? void 0;
+	if (!replyTarget) return null;
+	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,
+		sessionKey
+	});
+	return {
+		ctx,
+		account,
+		message,
+		...opts.relayIdentity ? { relayIdentity: opts.relayIdentity } : {},
+		route,
+		channelConfig,
+		replyTarget,
+		ctxPayload,
+		turn: {
+			storePath,
+			record: {
+				updateLastRoute: isDirectMessage ? {
+					sessionKey: updateLastRouteSessionKey,
+					channel: "slack",
+					to: `user:${message.user}`,
+					accountId: route.accountId,
+					threadId: effectiveMessageThreadId,
+					mainDmOwnerPin: updateLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner && message.user ? {
+						ownerRecipient: pinnedMainDmOwner,
+						senderRecipient: normalizeLowercaseStringOrEmpty(message.user),
+						onSkip: ({ ownerRecipient, senderRecipient }) => {
+							logVerbose(`slack: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`);
+						}
+					} : void 0
+				} : void 0,
+				onRecordError: (err) => {
+					ctx.logger.warn({
+						error: formatErrorMessage(err),
+						storePath,
+						sessionKey
+					}, "failed updating session meta");
+				}
+			},
+			history: isRoomish && shouldRequireMention ? {
+				isGroup: true,
+				historyKey,
+				historyMap: ctx.channelHistories,
+				limit: ctx.historyLimit
+			} : void 0
+		},
+		replyToMode,
+		...forcedAssistantReplyThreadTs ? { forcedReplyThreadTs: forcedAssistantReplyThreadTs } : {},
+		...assistantThreadContext ? { slackMessageMetadata: buildSlackAssistantThreadMetadata(assistantThreadContext) } : {},
+		requireMention: shouldRequireMention,
+		isDirectMessage,
+		isRoomish,
+		historyKey,
+		preview,
+		ackReactionMessageTs,
+		ackReactionValue,
+		ackReactionPromise
+	};
+}
+//#endregion
+export { dispatchPreparedSlackMessage, prepareSlackMessage };