@fased/fased 0.1.41 → 0.1.43

package/dist/plugin-sdk/slack-B6lIY1Jk.js

@@ -0,0 +1,3742 @@
+import { A as clearHistoryEntriesIfEnabled, E as DEFAULT_GROUP_HISTORY_LIMIT, Et as resolveChannelConfigWrites, F as removeAckReactionAfterReply, G as resolveEnvelopeFormatOptions, Gn as createDedupeCache, H as resolveInboundDebounceMs, I as shouldAckReaction, K as dispatchInboundMessage, Kn as pruneMapToMaxSize, Kt as hasControlCommand, N as recordPendingHistoryEntryIfEnabled, O as buildPendingHistoryContextFromMap, P as recordInboundSession, U as formatInboundEnvelope, V as createInboundDebouncer, Xn as readStoreAllowFromForDmPolicy, Xt as matchesMentionWithExplicit, Yt as buildMentionRegexes, b as logInboundDrop, d as issuePairingChallenge, dt as normalizeAllowListLower, er as resolveCommandAuthorizedFromAuthorizers, f as createTypingCallbacks, ft as normalizeSlackSlug, lt as allowListMatches, m as resolveMentionGatingWithBypass, mt as resolveSlackUserAllowed, pt as resolveSlackAllowListMatch, q as createReplyDispatcherWithTyping, tr as resolveControlCommandGate, ut as normalizeAllowList, wt as enqueueSystemEvent, x as logTypingFailure, xn as installRequestBodyLimitGuard, y as logAckFailure } from "./pi-embedded-runner-DMfkIj60.js";
+import { K as resolveSessionKey, S as readSessionUpdatedAt, w as updateLastRoute } from "./runtime-BUpqjZNM.js";
+import { r as createNonExitingRuntime } from "./subsystem-DBPNbQDQ.js";
+import { i as logVerbose, l as warn, p as getChildLogger, s as shouldLogVerbose, t as danger } from "./globals-B_jjtAje.js";
+import "./paths-BEmvSyOV.js";
+import "./utils-CYk9EKoq.js";
+import { Nt as resolveSlackNativeStreaming, Pt as resolveSlackStreamingMode, jt as mapStreamingModeToSlackLegacyDraftStreamMode, n as loadConfig, s as writeConfigFile } from "./config-DKNrb8oT.js";
+import "./agent-scope-BbgPlhtw.js";
+import { n as resolveConversationLabel } from "./conversation-label-BoVqak2R.js";
+import { c as normalizeMainKey, p as normalizeAccountId, u as resolveThreadSessionKeys } from "./session-key-HSJ2KQTc.js";
+import "./accounts-RHZyaB73.js";
+import { i as resolveSlackAccount, n as listSlackAccountIds, o as resolveSlackAppToken, r as resolveDefaultSlackAccountId, s as resolveSlackBotToken, t as listEnabledSlackAccounts } from "./accounts-CuqIKU8X.js";
+import "./logger-BbFvCoKk.js";
+import "./exec-DQ8j4Fm3.js";
+import "./accounts-Bz_2QZSt.js";
+import { S as resolveChannelEntryMatchWithFallback, v as applyChannelMatchMeta, y as buildChannelKeyCandidates } from "./allow-list-yqasgPpz.js";
+import { a as patchAllowlistUsersInConfigEntries, c as formatAllowlistMatchMeta, i as mergeAllowlist, n as buildAllowlistResolutionSummary, o as summarizeMapping, s as isDangerousNameMatchingEnabled, t as addAllowlistUserEntriesFromConfigEntry } from "./resolve-utils-DrvLA82C.js";
+import "./redact-CwCz68Mi.js";
+import "./github-copilot-token-Dgug856m.js";
+import "./retry-DycQ4ymF.js";
+import { l as resolveStorePath } from "./paths-B88DQEK8.js";
+import "./ip-BkeyFRJr.js";
+import { c as normalizeHostname } from "./ssrf-D_4q0mKh.js";
+import "./fetch-guard-CxXvFYq5.js";
+import "./send-DGUAXb2b.js";
+import { a as resolveOpenProviderRuntimeGroupPolicy, i as resolveDefaultGroupPolicy, o as warnMissingProviderGroupPolicyFallbackOnce } from "./links-D5ecKoG9.js";
+import "./wsl-Cw-xOsqF.js";
+import { a as upsertChannelPairingRequest } from "./pairing-store-BdOcH_GA.js";
+import { l as resolveTextChunkLimit } from "./chunk-CuJIMshx.js";
+import { a as resolveAckReaction, c as resolveHumanDelayConfig, n as createReplyPrefixOptions } from "./reply-prefix-CbPHNXlm.js";
+import "./tokens-Do_JU4Rh.js";
+import "./device-pairing-J1IH1jFl.js";
+import "./pairing-token-HQpaqod5.js";
+import { t as generateSecureToken } from "./secure-random-C2EhANj2.js";
+import "./diagnostic-C16gioN6.js";
+import "./diagnostic-session-state-B-9PL5r7.js";
+import "./optional-runtime-dependency-Bt_3Yigu.js";
+import "./image-ops-BSQmb-17.js";
+import "./wallet-status-CdxTkLWz.js";
+import "./pi-model-discovery-DQdXL_-F.js";
+import "./runtime-dependency-pUwxUAJp.js";
+import "./ws-CxmRDbD9.js";
+import "./path-alias-guards-BlIJ0AmG.js";
+import "./fs-safe-DztQeyQe.js";
+import "./markdown-tables-DrB-IM8r.js";
+import { a as fetchRemoteMedia } from "./media-D8pWjqEt.js";
+import "./send-DWB5HFdb.js";
+import { a as saveMediaBuffer } from "./outbound-attachment-C9oadpUP.js";
+import "./fetch-RV7QDF43.js";
+import "./thread-bindings.state-DYYR9qeT.js";
+import "./memory-search-DHSeU4pJ.js";
+import "./manager-DQ1dH8OM.js";
+import "./query-expansion-BM7lmqaP.js";
+import "./common-C90EHP1w.js";
+import { E as resolveNativeSkillsEnabled, T as resolveNativeCommandsEnabled, g as shouldHandleTextCommands } from "./commands-registry-DwQIFJmL.js";
+import "./skill-commands-DCnCOVR_.js";
+import { t as finalizeInboundContext } from "./inbound-context-BNCTzgjG.js";
+import "./directory-live-G7AN8y8N.js";
+import "./targets-BgSHco9b.js";
+import "./sandbox-paths-fc-HFGJr.js";
+import { n as resolveAgentRoute } from "./resolve-route-wp5xq4Ws.js";
+import "./render-K7NwXvVu.js";
+import "./tables-DX84FwPB.js";
+import { t as sendMessageSlack } from "./send-DUp9GIX8.js";
+import { r as resolveSlackWebClientOptions } from "./client-BTUzO_8g.js";
+import { a as listSlackPins, c as reactSlackMessage, d as removeSlackReaction, f as sendSlackMessage, i as listSlackEmojis, l as readSlackMessages, n as editSlackMessage, o as listSlackReactions, p as unpinSlackMessage, r as getSlackMemberInfo, s as pinSlackMessage, t as deleteSlackMessage, u as removeOwnSlackReactions } from "./actions-CysoQjk1.js";
+import { n as buildUntrustedChannelMetadata, t as chunkItems } from "./chunk-items-CxRDAM7m.js";
+import { t as createDraftStreamLoop } from "./draft-stream-loop-DZ1OAyye.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-C1sjzEsV.js";
+import { i as resolveSlackThreadTs, n as deliverReplies, t as createSlackReplyDeliveryPlan } from "./replies-BPFt4O-j.js";
+import { t as resolveSlackChannelAllowlist } from "./probe-DbhD54Aw.js";
+import { t as probeSlack } from "./probe-CJ6lN-jD.js";
+import SlackBolt from "@slack/bolt";
+
+//#region src/slack/http/registry.ts
+const slackHttpRoutes = /* @__PURE__ */ new Map();
+function normalizeSlackWebhookPath(path) {
+	const trimmed = path?.trim();
+	if (!trimmed) return "/slack/events";
+	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function registerSlackHttpHandler(params) {
+	const normalizedPath = normalizeSlackWebhookPath(params.path);
+	if (slackHttpRoutes.has(normalizedPath)) {
+		const suffix = params.accountId ? ` for account "${params.accountId}"` : "";
+		params.log?.(`slack: webhook path ${normalizedPath} already registered${suffix}`);
+		return () => {};
+	}
+	slackHttpRoutes.set(normalizedPath, params.handler);
+	return () => {
+		slackHttpRoutes.delete(normalizedPath);
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/commands.ts
+/**
+* Strip Slack mentions (<@U123>, <@U123|name>) so command detection works on
+* normalized text. Use in both prepare and debounce gate for consistency.
+*/
+function stripSlackMentionsForCommandDetection(text) {
+	return (text ?? "").replace(/<@[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeSlackSlashCommandName(raw) {
+	return raw.replace(/^\/+/, "");
+}
+function resolveSlackSlashCommandConfig(raw) {
+	const name = normalizeSlackSlashCommandName(raw?.name?.trim() || "fased") || "fased";
+	return {
+		enabled: raw?.enabled === true,
+		name,
+		sessionPrefix: raw?.sessionPrefix?.trim() || "slack:slash",
+		ephemeral: raw?.ephemeral !== false
+	};
+}
+function buildSlackSlashCommandMatcher(name) {
+	const escaped = normalizeSlackSlashCommandName(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`^/?${escaped}$`);
+}
+
+//#endregion
+//#region src/slack/monitor/policy.ts
+function isSlackChannelAllowedByPolicy(params) {
+	const { groupPolicy, channelAllowlistConfigured, channelAllowed } = params;
+	if (groupPolicy === "disabled") return false;
+	if (groupPolicy === "open") return true;
+	if (!channelAllowlistConfigured) return false;
+	return channelAllowed;
+}
+
+//#endregion
+//#region src/slack/monitor/channel-config.ts
+function firstDefined(...values) {
+	for (const value of values) if (typeof value !== "undefined") return value;
+}
+function resolveSlackChannelLabel(params) {
+	const channelName = params.channelName?.trim();
+	if (channelName) return `#${normalizeSlackSlug(channelName) || channelName}`;
+	const channelId = params.channelId?.trim();
+	return channelId ? `#${channelId}` : "unknown channel";
+}
+function resolveSlackChannelConfig(params) {
+	const { channelId, channelName, channels, defaultRequireMention } = params;
+	const entries = channels ?? {};
+	const keys = Object.keys(entries);
+	const normalizedName = channelName ? normalizeSlackSlug(channelName) : "";
+	const directName = channelName ? channelName.trim() : "";
+	const channelIdLower = channelId.toLowerCase();
+	const channelIdUpper = channelId.toUpperCase();
+	const match = resolveChannelEntryMatchWithFallback({
+		entries,
+		keys: buildChannelKeyCandidates(channelId, channelIdLower !== channelId ? channelIdLower : void 0, channelIdUpper !== channelId ? channelIdUpper : void 0, channelName ? `#${directName}` : void 0, directName, normalizedName),
+		wildcardKey: "*"
+	});
+	const { entry: matched, wildcardEntry: fallback } = match;
+	const requireMentionDefault = defaultRequireMention ?? true;
+	if (keys.length === 0) return {
+		allowed: true,
+		requireMention: requireMentionDefault
+	};
+	if (!matched && !fallback) return {
+		allowed: false,
+		requireMention: requireMentionDefault
+	};
+	const resolved = matched ?? fallback ?? {};
+	return applyChannelMatchMeta({
+		allowed: firstDefined(resolved.enabled, resolved.allow, fallback?.enabled, fallback?.allow, true) ?? true,
+		requireMention: firstDefined(resolved.requireMention, fallback?.requireMention, requireMentionDefault) ?? requireMentionDefault,
+		allowBots: firstDefined(resolved.allowBots, fallback?.allowBots),
+		users: firstDefined(resolved.users, fallback?.users),
+		skills: firstDefined(resolved.skills, fallback?.skills),
+		systemPrompt: firstDefined(resolved.systemPrompt, fallback?.systemPrompt)
+	}, match);
+}
+
+//#endregion
+//#region src/slack/monitor/context.ts
+function inferSlackChannelType(channelId) {
+	const trimmed = channelId?.trim();
+	if (!trimmed) return;
+	if (trimmed.startsWith("D")) return "im";
+	if (trimmed.startsWith("C")) return "channel";
+	if (trimmed.startsWith("G")) return "group";
+}
+function normalizeSlackChannelType(channelType, channelId) {
+	const normalized = channelType?.trim().toLowerCase();
+	const inferred = inferSlackChannelType(channelId);
+	if (normalized === "im" || normalized === "mpim" || normalized === "channel" || normalized === "group") {
+		if (inferred === "im" && normalized !== "im") return "im";
+		return normalized;
+	}
+	return inferred ?? "channel";
+}
+function createSlackMonitorContext(params) {
+	const channelHistories = /* @__PURE__ */ new Map();
+	const logger = getChildLogger({ module: "slack-auto-reply" });
+	const channelCache = /* @__PURE__ */ new Map();
+	const userCache = /* @__PURE__ */ new Map();
+	const seenMessages = createDedupeCache({
+		ttlMs: 6e4,
+		maxSize: 500
+	});
+	const allowFrom = normalizeAllowList(params.allowFrom);
+	const groupDmChannels = normalizeAllowList(params.groupDmChannels);
+	const defaultRequireMention = params.defaultRequireMention ?? true;
+	const markMessageSeen = (channelId, ts) => {
+		if (!channelId || !ts) return false;
+		return seenMessages.check(`${channelId}:${ts}`);
+	};
+	const resolveSlackSystemEventSessionKey = (p) => {
+		const channelId = p.channelId?.trim() ?? "";
+		if (!channelId) return params.mainKey;
+		const channelType = normalizeSlackChannelType(p.channelType, channelId);
+		const isDirectMessage = channelType === "im";
+		const isGroup = channelType === "mpim";
+		const from = isDirectMessage ? `slack:${channelId}` : isGroup ? `slack:group:${channelId}` : `slack:channel:${channelId}`;
+		const chatType = isDirectMessage ? "direct" : isGroup ? "group" : "channel";
+		return resolveSessionKey(params.sessionScope, {
+			From: from,
+			ChatType: chatType,
+			Provider: "slack"
+		}, params.mainKey);
+	};
+	const resolveChannelName = async (channelId) => {
+		const cached = channelCache.get(channelId);
+		if (cached) return cached;
+		try {
+			const info = await params.app.client.conversations.info({
+				token: params.botToken,
+				channel: channelId
+			});
+			const name = info.channel && "name" in info.channel ? info.channel.name : void 0;
+			const channel = info.channel ?? void 0;
+			const entry = {
+				name,
+				type: channel?.is_im ? "im" : channel?.is_mpim ? "mpim" : channel?.is_channel ? "channel" : channel?.is_group ? "group" : void 0,
+				topic: channel && "topic" in channel ? channel.topic?.value ?? void 0 : void 0,
+				purpose: channel && "purpose" in channel ? channel.purpose?.value ?? void 0 : void 0
+			};
+			channelCache.set(channelId, entry);
+			return entry;
+		} catch {
+			return {};
+		}
+	};
+	const resolveUserName = async (userId) => {
+		const cached = userCache.get(userId);
+		if (cached) return cached;
+		try {
+			const info = await params.app.client.users.info({
+				token: params.botToken,
+				user: userId
+			});
+			const profile = info.user?.profile;
+			const entry = { name: profile?.display_name || profile?.real_name || info.user?.name || void 0 };
+			userCache.set(userId, entry);
+			return entry;
+		} catch {
+			return {};
+		}
+	};
+	const setSlackThreadStatus = async (p) => {
+		if (!p.threadTs) return;
+		const payload = {
+			token: params.botToken,
+			channel_id: p.channelId,
+			thread_ts: p.threadTs,
+			status: p.status
+		};
+		const client = params.app.client;
+		try {
+			if (client.assistant?.threads?.setStatus) {
+				await client.assistant.threads.setStatus(payload);
+				return;
+			}
+			if (typeof client.apiCall === "function") await client.apiCall("assistant.threads.setStatus", payload);
+		} catch (err) {
+			logVerbose(`slack status update failed for channel ${p.channelId}: ${String(err)}`);
+		}
+	};
+	const isChannelAllowed = (p) => {
+		const channelType = normalizeSlackChannelType(p.channelType, p.channelId);
+		const isDirectMessage = channelType === "im";
+		const isGroupDm = channelType === "mpim";
+		const isRoom = channelType === "channel" || channelType === "group";
+		if (isDirectMessage && !params.dmEnabled) return false;
+		if (isGroupDm && !params.groupDmEnabled) return false;
+		if (isGroupDm && groupDmChannels.length > 0) {
+			const allowList = normalizeAllowListLower(groupDmChannels);
+			const candidates = [
+				p.channelId,
+				p.channelName ? `#${p.channelName}` : void 0,
+				p.channelName,
+				p.channelName ? normalizeSlackSlug(p.channelName) : void 0
+			].filter((value) => Boolean(value)).map((value) => value.toLowerCase());
+			if (!(allowList.includes("*") || candidates.some((candidate) => allowList.includes(candidate)))) return false;
+		}
+		if (isRoom && p.channelId) {
+			const channelConfig = resolveSlackChannelConfig({
+				channelId: p.channelId,
+				channelName: p.channelName,
+				channels: params.channelsConfig,
+				defaultRequireMention
+			});
+			const channelMatchMeta = formatAllowlistMatchMeta(channelConfig);
+			const channelAllowed = channelConfig?.allowed !== false;
+			const channelAllowlistConfigured = Boolean(params.channelsConfig) && Object.keys(params.channelsConfig ?? {}).length > 0;
+			if (!isSlackChannelAllowedByPolicy({
+				groupPolicy: params.groupPolicy,
+				channelAllowlistConfigured,
+				channelAllowed
+			})) {
+				logVerbose(`slack: drop channel ${p.channelId} (groupPolicy=${params.groupPolicy}, ${channelMatchMeta})`);
+				return false;
+			}
+			const hasExplicitConfig = Boolean(channelConfig?.matchSource);
+			if (!channelAllowed && (params.groupPolicy !== "open" || hasExplicitConfig)) {
+				logVerbose(`slack: drop channel ${p.channelId} (${channelMatchMeta})`);
+				return false;
+			}
+			logVerbose(`slack: allow channel ${p.channelId} (${channelMatchMeta})`);
+		}
+		return true;
+	};
+	const shouldDropMismatchedSlackEvent = (body) => {
+		if (!body || typeof body !== "object") return false;
+		const raw = body;
+		const incomingApiAppId = typeof raw.api_app_id === "string" ? raw.api_app_id : "";
+		const incomingTeamId = typeof raw.team_id === "string" ? raw.team_id : "";
+		if (params.apiAppId && incomingApiAppId && incomingApiAppId !== params.apiAppId) {
+			logVerbose(`slack: drop event with api_app_id=${incomingApiAppId} (expected ${params.apiAppId})`);
+			return true;
+		}
+		if (params.teamId && incomingTeamId && incomingTeamId !== params.teamId) {
+			logVerbose(`slack: drop event with team_id=${incomingTeamId} (expected ${params.teamId})`);
+			return true;
+		}
+		return false;
+	};
+	return {
+		cfg: params.cfg,
+		accountId: params.accountId,
+		botToken: params.botToken,
+		app: params.app,
+		runtime: params.runtime,
+		botUserId: params.botUserId,
+		teamId: params.teamId,
+		apiAppId: params.apiAppId,
+		historyLimit: params.historyLimit,
+		channelHistories,
+		sessionScope: params.sessionScope,
+		mainKey: params.mainKey,
+		dmEnabled: params.dmEnabled,
+		dmPolicy: params.dmPolicy,
+		allowFrom,
+		allowNameMatching: params.allowNameMatching,
+		groupDmEnabled: params.groupDmEnabled,
+		groupDmChannels,
+		defaultRequireMention,
+		channelsConfig: params.channelsConfig,
+		groupPolicy: params.groupPolicy,
+		useAccessGroups: params.useAccessGroups,
+		reactionMode: params.reactionMode,
+		reactionAllowlist: params.reactionAllowlist,
+		replyToMode: params.replyToMode,
+		threadHistoryScope: params.threadHistoryScope,
+		threadInheritParent: params.threadInheritParent,
+		slashCommand: params.slashCommand,
+		textLimit: params.textLimit,
+		ackReactionScope: params.ackReactionScope,
+		mediaMaxBytes: params.mediaMaxBytes,
+		removeAckAfterReply: params.removeAckAfterReply,
+		logger,
+		markMessageSeen,
+		shouldDropMismatchedSlackEvent,
+		resolveSlackSystemEventSessionKey,
+		isChannelAllowed,
+		resolveChannelName,
+		resolveUserName,
+		setSlackThreadStatus
+	};
+}
+
+//#endregion
+//#region src/slack/channel-migration.ts
+function resolveAccountChannels(cfg, accountId) {
+	if (!accountId) return {};
+	const normalized = normalizeAccountId(accountId);
+	const accounts = cfg.channels?.slack?.accounts;
+	if (!accounts || typeof accounts !== "object") return {};
+	const exact = accounts[normalized];
+	if (exact?.channels) return { channels: exact.channels };
+	const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalized.toLowerCase());
+	return { channels: matchKey ? accounts[matchKey]?.channels : void 0 };
+}
+function migrateSlackChannelsInPlace(channels, oldChannelId, newChannelId) {
+	if (!channels) return {
+		migrated: false,
+		skippedExisting: false
+	};
+	if (oldChannelId === newChannelId) return {
+		migrated: false,
+		skippedExisting: false
+	};
+	if (!Object.hasOwn(channels, oldChannelId)) return {
+		migrated: false,
+		skippedExisting: false
+	};
+	if (Object.hasOwn(channels, newChannelId)) return {
+		migrated: false,
+		skippedExisting: true
+	};
+	channels[newChannelId] = channels[oldChannelId];
+	delete channels[oldChannelId];
+	return {
+		migrated: true,
+		skippedExisting: false
+	};
+}
+function migrateSlackChannelConfig(params) {
+	const scopes = [];
+	let migrated = false;
+	let skippedExisting = false;
+	const accountChannels = resolveAccountChannels(params.cfg, params.accountId).channels;
+	if (accountChannels) {
+		const result = migrateSlackChannelsInPlace(accountChannels, params.oldChannelId, params.newChannelId);
+		if (result.migrated) {
+			migrated = true;
+			scopes.push("account");
+		}
+		if (result.skippedExisting) skippedExisting = true;
+	}
+	const globalChannels = params.cfg.channels?.slack?.channels;
+	if (globalChannels) {
+		const result = migrateSlackChannelsInPlace(globalChannels, params.oldChannelId, params.newChannelId);
+		if (result.migrated) {
+			migrated = true;
+			scopes.push("global");
+		}
+		if (result.skippedExisting) skippedExisting = true;
+	}
+	return {
+		migrated,
+		skippedExisting,
+		scopes
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/events/channels.ts
+function registerSlackChannelEvents(params) {
+	const { ctx } = params;
+	const enqueueChannelSystemEvent = (params) => {
+		if (!ctx.isChannelAllowed({
+			channelId: params.channelId,
+			channelName: params.channelName,
+			channelType: "channel"
+		})) return;
+		const label = resolveSlackChannelLabel({
+			channelId: params.channelId,
+			channelName: params.channelName
+		});
+		const sessionKey = ctx.resolveSlackSystemEventSessionKey({
+			channelId: params.channelId,
+			channelType: "channel"
+		});
+		enqueueSystemEvent(`Slack channel ${params.kind}: ${label}.`, {
+			sessionKey,
+			contextKey: `slack:channel:${params.kind}:${params.channelId ?? params.channelName ?? "unknown"}`
+		});
+	};
+	ctx.app.event("channel_created", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			const payload = event;
+			const channelId = payload.channel?.id;
+			const channelName = payload.channel?.name;
+			enqueueChannelSystemEvent({
+				kind: "created",
+				channelId,
+				channelName
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack channel created handler failed: ${String(err)}`));
+		}
+	});
+	ctx.app.event("channel_rename", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			const payload = event;
+			const channelId = payload.channel?.id;
+			enqueueChannelSystemEvent({
+				kind: "renamed",
+				channelId,
+				channelName: payload.channel?.name_normalized ?? payload.channel?.name
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack channel rename handler failed: ${String(err)}`));
+		}
+	});
+	ctx.app.event("channel_id_changed", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			const payload = event;
+			const oldChannelId = payload.old_channel_id;
+			const newChannelId = payload.new_channel_id;
+			if (!oldChannelId || !newChannelId) return;
+			const label = resolveSlackChannelLabel({
+				channelId: newChannelId,
+				channelName: (await ctx.resolveChannelName(newChannelId))?.name
+			});
+			ctx.runtime.log?.(warn(`[slack] Channel ID changed: ${oldChannelId} → ${newChannelId} (${label})`));
+			if (!resolveChannelConfigWrites({
+				cfg: ctx.cfg,
+				channelId: "slack",
+				accountId: ctx.accountId
+			})) {
+				ctx.runtime.log?.(warn("[slack] Config writes disabled; skipping channel config migration."));
+				return;
+			}
+			const currentConfig = loadConfig();
+			const migration = migrateSlackChannelConfig({
+				cfg: currentConfig,
+				accountId: ctx.accountId,
+				oldChannelId,
+				newChannelId
+			});
+			if (migration.migrated) {
+				migrateSlackChannelConfig({
+					cfg: ctx.cfg,
+					accountId: ctx.accountId,
+					oldChannelId,
+					newChannelId
+				});
+				await writeConfigFile(currentConfig);
+				ctx.runtime.log?.(warn("[slack] Channel config migrated and saved successfully."));
+			} else if (migration.skippedExisting) ctx.runtime.log?.(warn(`[slack] Channel config already exists for ${newChannelId}; leaving ${oldChannelId} unchanged`));
+			else ctx.runtime.log?.(warn(`[slack] No config found for old channel ID ${oldChannelId}; migration logged only`));
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack channel_id_changed handler failed: ${String(err)}`));
+		}
+	});
+}
+
+//#endregion
+//#region src/slack/modal-metadata.ts
+function normalizeString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function parseSlackModalPrivateMetadata(raw) {
+	if (typeof raw !== "string" || raw.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return {
+			sessionKey: normalizeString(parsed.sessionKey),
+			channelId: normalizeString(parsed.channelId),
+			channelType: normalizeString(parsed.channelType),
+			userId: normalizeString(parsed.userId)
+		};
+	} catch {
+		return {};
+	}
+}
+
+//#endregion
+//#region src/slack/monitor/auth.ts
+async function resolveSlackEffectiveAllowFrom(ctx, options) {
+	const storeAllowFrom = options?.includePairingStore === true ? await readStoreAllowFromForDmPolicy({
+		provider: "slack",
+		accountId: ctx.accountId,
+		dmPolicy: ctx.dmPolicy
+	}) : [];
+	const allowFrom = normalizeAllowList([...ctx.allowFrom, ...storeAllowFrom]);
+	return {
+		allowFrom,
+		allowFromLower: normalizeAllowListLower(allowFrom)
+	};
+}
+function isSlackSenderAllowListed(params) {
+	const { allowListLower, senderId, senderName, allowNameMatching } = params;
+	return allowListLower.length === 0 || allowListMatches({
+		allowList: allowListLower,
+		id: senderId,
+		name: senderName,
+		allowNameMatching
+	});
+}
+async function authorizeSlackSystemEventSender(params) {
+	const senderId = params.senderId?.trim();
+	if (!senderId) return {
+		allowed: false,
+		reason: "missing-sender"
+	};
+	const expectedSenderId = params.expectedSenderId?.trim();
+	if (expectedSenderId && expectedSenderId !== senderId) return {
+		allowed: false,
+		reason: "sender-mismatch"
+	};
+	const channelId = params.channelId?.trim();
+	let channelType = normalizeSlackChannelType(params.channelType, channelId);
+	let channelName;
+	if (channelId) {
+		const info = await params.ctx.resolveChannelName(channelId).catch(() => ({}));
+		channelName = info.name;
+		channelType = normalizeSlackChannelType(params.channelType ?? info.type, channelId);
+		if (!params.ctx.isChannelAllowed({
+			channelId,
+			channelName,
+			channelType
+		})) return {
+			allowed: false,
+			reason: "channel-not-allowed",
+			channelType,
+			channelName
+		};
+	}
+	const senderName = (await params.ctx.resolveUserName(senderId).catch(() => ({}))).name;
+	const resolveAllowFromLower = async (includePairingStore = false) => (await resolveSlackEffectiveAllowFrom(params.ctx, { includePairingStore })).allowFromLower;
+	if (channelType === "im") {
+		if (!params.ctx.dmEnabled || params.ctx.dmPolicy === "disabled") return {
+			allowed: false,
+			reason: "dm-disabled",
+			channelType,
+			channelName
+		};
+		if (params.ctx.dmPolicy !== "open") {
+			if (!isSlackSenderAllowListed({
+				allowListLower: await resolveAllowFromLower(true),
+				senderId,
+				senderName,
+				allowNameMatching: params.ctx.allowNameMatching
+			})) return {
+				allowed: false,
+				reason: "sender-not-allowlisted",
+				channelType,
+				channelName
+			};
+		}
+	} else if (!channelId) {
+		const allowFromLower = await resolveAllowFromLower(false);
+		if (allowFromLower.length > 0) {
+			if (!isSlackSenderAllowListed({
+				allowListLower: allowFromLower,
+				senderId,
+				senderName,
+				allowNameMatching: params.ctx.allowNameMatching
+			})) return {
+				allowed: false,
+				reason: "sender-not-allowlisted"
+			};
+		}
+	} else {
+		const channelConfig = resolveSlackChannelConfig({
+			channelId,
+			channelName,
+			channels: params.ctx.channelsConfig,
+			defaultRequireMention: params.ctx.defaultRequireMention
+		});
+		if (Array.isArray(channelConfig?.users) && channelConfig.users.length > 0) {
+			if (!resolveSlackUserAllowed({
+				allowList: channelConfig?.users,
+				userId: senderId,
+				userName: senderName,
+				allowNameMatching: params.ctx.allowNameMatching
+			})) return {
+				allowed: false,
+				reason: "sender-not-channel-allowed",
+				channelType,
+				channelName
+			};
+		}
+	}
+	return {
+		allowed: true,
+		channelType,
+		channelName
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/mrkdwn.ts
+function escapeSlackMrkdwn(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replace(/([*_`~])/g, "\\$1");
+}
+
+//#endregion
+//#region src/slack/monitor/events/interactions.ts
+const FASED_ACTION_PREFIX = "fased:";
+function readOptionValues(options) {
+	if (!Array.isArray(options)) return;
+	const values = options.map((option) => option && typeof option === "object" ? option.value : null).filter((value) => typeof value === "string" && value.trim().length > 0);
+	return values.length > 0 ? values : void 0;
+}
+function readOptionLabels(options) {
+	if (!Array.isArray(options)) return;
+	const labels = options.map((option) => option && typeof option === "object" ? option.text?.text ?? null : null).filter((label) => typeof label === "string" && label.trim().length > 0);
+	return labels.length > 0 ? labels : void 0;
+}
+function uniqueNonEmptyStrings(values) {
+	const unique = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of values) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (!trimmed || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		unique.push(trimmed);
+	}
+	return unique;
+}
+function collectRichTextFragments(value, out) {
+	if (!value || typeof value !== "object") return;
+	const typed = value;
+	if (typeof typed.text === "string" && typed.text.trim().length > 0) out.push(typed.text.trim());
+	if (Array.isArray(typed.elements)) for (const child of typed.elements) collectRichTextFragments(child, out);
+}
+function summarizeRichTextPreview(value) {
+	const fragments = [];
+	collectRichTextFragments(value, fragments);
+	if (fragments.length === 0) return;
+	const joined = fragments.join(" ").replace(/\s+/g, " ").trim();
+	if (!joined) return;
+	const max = 120;
+	return joined.length <= max ? joined : `${joined.slice(0, max - 1)}…`;
+}
+function readInteractionAction(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+	return raw;
+}
+function summarizeAction(action) {
+	const typed = action;
+	const actionType = typed.type;
+	const selectedUsers = uniqueNonEmptyStrings([...typed.selected_user ? [typed.selected_user] : [], ...Array.isArray(typed.selected_users) ? typed.selected_users : []]);
+	const selectedChannels = uniqueNonEmptyStrings([...typed.selected_channel ? [typed.selected_channel] : [], ...Array.isArray(typed.selected_channels) ? typed.selected_channels : []]);
+	const selectedConversations = uniqueNonEmptyStrings([...typed.selected_conversation ? [typed.selected_conversation] : [], ...Array.isArray(typed.selected_conversations) ? typed.selected_conversations : []]);
+	const selectedValues = uniqueNonEmptyStrings([
+		...typed.selected_option?.value ? [typed.selected_option.value] : [],
+		...readOptionValues(typed.selected_options) ?? [],
+		...selectedUsers,
+		...selectedChannels,
+		...selectedConversations
+	]);
+	const selectedLabels = uniqueNonEmptyStrings([...typed.selected_option?.text?.text ? [typed.selected_option.text.text] : [], ...readOptionLabels(typed.selected_options) ?? []]);
+	const inputValue = typeof typed.value === "string" ? typed.value : void 0;
+	const inputNumber = actionType === "number_input" && inputValue != null ? Number.parseFloat(inputValue) : void 0;
+	const parsedNumber = Number.isFinite(inputNumber) ? inputNumber : void 0;
+	const inputEmail = actionType === "email_text_input" && inputValue?.includes("@") ? inputValue : void 0;
+	let inputUrl;
+	if (actionType === "url_text_input" && inputValue) try {
+		inputUrl = new URL(inputValue).toString();
+	} catch {
+		inputUrl = void 0;
+	}
+	const richTextValue = actionType === "rich_text_input" ? typed.rich_text_value : void 0;
+	const richTextPreview = summarizeRichTextPreview(richTextValue);
+	return {
+		actionType,
+		inputKind: actionType === "number_input" ? "number" : actionType === "email_text_input" ? "email" : actionType === "url_text_input" ? "url" : actionType === "rich_text_input" ? "rich_text" : inputValue != null ? "text" : void 0,
+		value: typed.value,
+		selectedValues: selectedValues.length > 0 ? selectedValues : void 0,
+		selectedUsers: selectedUsers.length > 0 ? selectedUsers : void 0,
+		selectedChannels: selectedChannels.length > 0 ? selectedChannels : void 0,
+		selectedConversations: selectedConversations.length > 0 ? selectedConversations : void 0,
+		selectedLabels: selectedLabels.length > 0 ? selectedLabels : void 0,
+		selectedDate: typed.selected_date,
+		selectedTime: typed.selected_time,
+		selectedDateTime: typeof typed.selected_date_time === "number" ? typed.selected_date_time : void 0,
+		inputValue,
+		inputNumber: parsedNumber,
+		inputEmail,
+		inputUrl,
+		richTextValue,
+		richTextPreview,
+		workflowTriggerUrl: typed.workflow?.trigger_url,
+		workflowId: typed.workflow?.workflow_id
+	};
+}
+function isBulkActionsBlock(block) {
+	return block.type === "actions" && Array.isArray(block.elements) && block.elements.length > 0 && block.elements.every((el) => typeof el.action_id === "string" && el.action_id.includes("_all_"));
+}
+function formatInteractionSelectionLabel(params) {
+	if (params.summary.actionType === "button" && params.buttonText?.trim()) return params.buttonText.trim();
+	if (params.summary.selectedLabels?.length) {
+		if (params.summary.selectedLabels.length <= 3) return params.summary.selectedLabels.join(", ");
+		return `${params.summary.selectedLabels.slice(0, 3).join(", ")} +${params.summary.selectedLabels.length - 3}`;
+	}
+	if (params.summary.selectedValues?.length) {
+		if (params.summary.selectedValues.length <= 3) return params.summary.selectedValues.join(", ");
+		return `${params.summary.selectedValues.slice(0, 3).join(", ")} +${params.summary.selectedValues.length - 3}`;
+	}
+	if (params.summary.selectedDate) return params.summary.selectedDate;
+	if (params.summary.selectedTime) return params.summary.selectedTime;
+	if (typeof params.summary.selectedDateTime === "number") return (/* @__PURE__ */ new Date(params.summary.selectedDateTime * 1e3)).toISOString();
+	if (params.summary.richTextPreview) return params.summary.richTextPreview;
+	if (params.summary.value?.trim()) return params.summary.value.trim();
+	return params.actionId;
+}
+function formatInteractionConfirmationText(params) {
+	const actor = params.userId?.trim() ? ` by <@${params.userId.trim()}>` : "";
+	return `:white_check_mark: *${escapeSlackMrkdwn(params.selectedLabel)}* selected${actor}`;
+}
+function summarizeViewState(values) {
+	if (!values || typeof values !== "object") return [];
+	const entries = [];
+	for (const [blockId, blockValue] of Object.entries(values)) {
+		if (!blockValue || typeof blockValue !== "object") continue;
+		for (const [actionId, rawAction] of Object.entries(blockValue)) {
+			if (!rawAction || typeof rawAction !== "object") continue;
+			const actionSummary = summarizeAction(rawAction);
+			entries.push({
+				blockId,
+				actionId,
+				...actionSummary
+			});
+		}
+	}
+	return entries;
+}
+function resolveModalSessionRouting(params) {
+	const metadata = params.metadata;
+	if (metadata.sessionKey) return {
+		sessionKey: metadata.sessionKey,
+		channelId: metadata.channelId,
+		channelType: metadata.channelType
+	};
+	if (metadata.channelId) return {
+		sessionKey: params.ctx.resolveSlackSystemEventSessionKey({
+			channelId: metadata.channelId,
+			channelType: metadata.channelType
+		}),
+		channelId: metadata.channelId,
+		channelType: metadata.channelType
+	};
+	return { sessionKey: params.ctx.resolveSlackSystemEventSessionKey({}) };
+}
+function summarizeSlackViewLifecycleContext(view) {
+	const rootViewId = view.root_view_id;
+	const previousViewId = view.previous_view_id;
+	return {
+		rootViewId,
+		previousViewId,
+		externalId: view.external_id,
+		viewHash: view.hash,
+		isStackedView: Boolean(previousViewId)
+	};
+}
+function resolveSlackModalEventBase(params) {
+	const metadata = parseSlackModalPrivateMetadata(params.body.view?.private_metadata);
+	const callbackId = params.body.view?.callback_id ?? "unknown";
+	const userId = params.body.user?.id ?? "unknown";
+	const viewId = params.body.view?.id;
+	const inputs = summarizeViewState(params.body.view?.state?.values);
+	const sessionRouting = resolveModalSessionRouting({
+		ctx: params.ctx,
+		metadata
+	});
+	return {
+		callbackId,
+		userId,
+		expectedUserId: metadata.userId,
+		viewId,
+		sessionRouting,
+		payload: {
+			actionId: `view:${callbackId}`,
+			callbackId,
+			viewId,
+			userId,
+			teamId: params.body.team?.id,
+			...summarizeSlackViewLifecycleContext({
+				root_view_id: params.body.view?.root_view_id,
+				previous_view_id: params.body.view?.previous_view_id,
+				external_id: params.body.view?.external_id,
+				hash: params.body.view?.hash
+			}),
+			privateMetadata: params.body.view?.private_metadata,
+			routedChannelId: sessionRouting.channelId,
+			routedChannelType: sessionRouting.channelType,
+			inputs
+		}
+	};
+}
+async function emitSlackModalLifecycleEvent(params) {
+	const { callbackId, userId, expectedUserId, viewId, sessionRouting, payload } = resolveSlackModalEventBase({
+		ctx: params.ctx,
+		body: params.body
+	});
+	const isViewClosed = params.interactionType === "view_closed";
+	const isCleared = params.body.is_cleared === true;
+	const eventPayload = isViewClosed ? {
+		interactionType: params.interactionType,
+		...payload,
+		isCleared
+	} : {
+		interactionType: params.interactionType,
+		...payload
+	};
+	if (isViewClosed) params.ctx.runtime.log?.(`slack:interaction view_closed callback=${callbackId} user=${userId} cleared=${isCleared}`);
+	else params.ctx.runtime.log?.(`slack:interaction view_submission callback=${callbackId} user=${userId} inputs=${payload.inputs.length}`);
+	if (!expectedUserId) {
+		params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=missing-expected-user`);
+		return;
+	}
+	const auth = await authorizeSlackSystemEventSender({
+		ctx: params.ctx,
+		senderId: userId,
+		channelId: sessionRouting.channelId,
+		channelType: sessionRouting.channelType,
+		expectedSenderId: expectedUserId
+	});
+	if (!auth.allowed) {
+		params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=${auth.reason ?? "unauthorized"}`);
+		return;
+	}
+	enqueueSystemEvent(`Slack interaction: ${JSON.stringify(eventPayload)}`, {
+		sessionKey: sessionRouting.sessionKey,
+		contextKey: [
+			params.contextPrefix,
+			callbackId,
+			viewId,
+			userId
+		].filter(Boolean).join(":")
+	});
+}
+function registerModalLifecycleHandler(params) {
+	params.register(params.matcher, async ({ ack, body }) => {
+		await ack();
+		await emitSlackModalLifecycleEvent({
+			ctx: params.ctx,
+			body,
+			interactionType: params.interactionType,
+			contextPrefix: params.contextPrefix
+		});
+	});
+}
+function registerSlackInteractionEvents(params) {
+	const { ctx } = params;
+	if (typeof ctx.app.action !== "function") return;
+	ctx.app.action(new RegExp(`^${FASED_ACTION_PREFIX}`), async (args) => {
+		const { ack, body, action, respond } = args;
+		const typedBody = body;
+		await ack();
+		const typedAction = readInteractionAction(action);
+		if (!typedAction) {
+			ctx.runtime.log?.(`slack:interaction malformed action payload channel=${typedBody.channel?.id ?? typedBody.container?.channel_id ?? "unknown"} user=${typedBody.user?.id ?? "unknown"}`);
+			return;
+		}
+		const typedActionWithText = typedAction;
+		const actionId = typeof typedActionWithText.action_id === "string" ? typedActionWithText.action_id : "unknown";
+		const blockId = typedActionWithText.block_id;
+		const userId = typedBody.user?.id ?? "unknown";
+		const channelId = typedBody.channel?.id ?? typedBody.container?.channel_id;
+		const messageTs = typedBody.message?.ts ?? typedBody.container?.message_ts;
+		const threadTs = typedBody.container?.thread_ts;
+		const auth = await authorizeSlackSystemEventSender({
+			ctx,
+			senderId: userId,
+			channelId
+		});
+		if (!auth.allowed) {
+			ctx.runtime.log?.(`slack:interaction drop action=${actionId} user=${userId} channel=${channelId ?? "unknown"} reason=${auth.reason ?? "unauthorized"}`);
+			if (respond) try {
+				await respond({
+					text: "You are not authorized to use this control.",
+					response_type: "ephemeral"
+				});
+			} catch {}
+			return;
+		}
+		const actionSummary = summarizeAction(typedAction);
+		const eventPayload = {
+			interactionType: "block_action",
+			actionId,
+			blockId,
+			...actionSummary,
+			userId,
+			teamId: typedBody.team?.id,
+			triggerId: typedBody.trigger_id,
+			responseUrl: typedBody.response_url,
+			channelId,
+			messageTs,
+			threadTs
+		};
+		ctx.runtime.log?.(`slack:interaction action=${actionId} type=${actionSummary.actionType ?? "unknown"} user=${userId} channel=${channelId}`);
+		const sessionKey = ctx.resolveSlackSystemEventSessionKey({
+			channelId,
+			channelType: auth.channelType
+		});
+		const contextKey = [
+			"slack:interaction",
+			channelId,
+			messageTs,
+			actionId
+		].filter(Boolean).join(":");
+		enqueueSystemEvent(`Slack interaction: ${JSON.stringify(eventPayload)}`, {
+			sessionKey,
+			contextKey
+		});
+		const originalBlocks = typedBody.message?.blocks;
+		if (!Array.isArray(originalBlocks) || !channelId || !messageTs) return;
+		if (!blockId) return;
+		const selectedLabel = formatInteractionSelectionLabel({
+			actionId,
+			summary: actionSummary,
+			buttonText: typedActionWithText.text?.text
+		});
+		let updatedBlocks = originalBlocks.map((block) => {
+			const typedBlock = block;
+			if (typedBlock.type === "actions" && typedBlock.block_id === blockId) return {
+				type: "context",
+				elements: [{
+					type: "mrkdwn",
+					text: formatInteractionConfirmationText({
+						selectedLabel,
+						userId
+					})
+				}]
+			};
+			return block;
+		});
+		if (!updatedBlocks.some((block) => {
+			const typedBlock = block;
+			return typedBlock.type === "actions" && !isBulkActionsBlock(typedBlock);
+		})) updatedBlocks = updatedBlocks.filter((block, index) => {
+			const typedBlock = block;
+			if (isBulkActionsBlock(typedBlock)) return false;
+			if (typedBlock.type !== "divider") return true;
+			const next = updatedBlocks[index + 1];
+			return !next || !isBulkActionsBlock(next);
+		});
+		try {
+			await ctx.app.client.chat.update({
+				channel: channelId,
+				ts: messageTs,
+				text: typedBody.message?.text ?? "",
+				blocks: updatedBlocks
+			});
+		} catch {
+			if (!respond) return;
+			try {
+				await respond({
+					text: `Button "${actionId}" clicked!`,
+					response_type: "ephemeral"
+				});
+			} catch {}
+		}
+	});
+	if (typeof ctx.app.view !== "function") return;
+	const modalMatcher = new RegExp(`^${FASED_ACTION_PREFIX}`);
+	registerModalLifecycleHandler({
+		register: (matcher, handler) => ctx.app.view(matcher, handler),
+		matcher: modalMatcher,
+		ctx,
+		interactionType: "view_submission",
+		contextPrefix: "slack:interaction:view"
+	});
+	const viewClosed = ctx.app.viewClosed;
+	if (typeof viewClosed !== "function") return;
+	registerModalLifecycleHandler({
+		register: viewClosed,
+		matcher: modalMatcher,
+		ctx,
+		interactionType: "view_closed",
+		contextPrefix: "slack:interaction:view-closed"
+	});
+}
+
+//#endregion
+//#region src/slack/monitor/events/system-event-context.ts
+async function authorizeAndResolveSlackSystemEventContext(params) {
+	const { ctx, senderId, channelId, channelType, eventKind } = params;
+	const auth = await authorizeSlackSystemEventSender({
+		ctx,
+		senderId,
+		channelId,
+		channelType
+	});
+	if (!auth.allowed) {
+		logVerbose(`slack: drop ${eventKind} sender ${senderId ?? "unknown"} channel=${channelId ?? "unknown"} reason=${auth.reason ?? "unauthorized"}`);
+		return;
+	}
+	return {
+		channelLabel: resolveSlackChannelLabel({
+			channelId,
+			channelName: auth.channelName
+		}),
+		sessionKey: ctx.resolveSlackSystemEventSessionKey({
+			channelId,
+			channelType: auth.channelType
+		})
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/events/members.ts
+function registerSlackMemberEvents(params) {
+	const { ctx } = params;
+	const handleMemberChannelEvent = async (params) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(params.body)) return;
+			const payload = params.event;
+			const channelId = payload.channel;
+			const channelInfo = channelId ? await ctx.resolveChannelName(channelId) : {};
+			const channelType = payload.channel_type ?? channelInfo?.type;
+			const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+				ctx,
+				senderId: payload.user,
+				channelId,
+				channelType,
+				eventKind: `member-${params.verb}`
+			});
+			if (!ingressContext) return;
+			enqueueSystemEvent(`Slack: ${(payload.user ? await ctx.resolveUserName(payload.user) : {})?.name ?? payload.user ?? "someone"} ${params.verb} ${ingressContext.channelLabel}.`, {
+				sessionKey: ingressContext.sessionKey,
+				contextKey: `slack:member:${params.verb}:${channelId ?? "unknown"}:${payload.user ?? "unknown"}`
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack ${params.verb} handler failed: ${String(err)}`));
+		}
+	};
+	ctx.app.event("member_joined_channel", async ({ event, body }) => {
+		await handleMemberChannelEvent({
+			verb: "joined",
+			event,
+			body
+		});
+	});
+	ctx.app.event("member_left_channel", async ({ event, body }) => {
+		await handleMemberChannelEvent({
+			verb: "left",
+			event,
+			body
+		});
+	});
+}
+
+//#endregion
+//#region src/slack/monitor/events/messages.ts
+function registerSlackMessageEvents(params) {
+	const { ctx, handleSlackMessage } = params;
+	const resolveChangedSenderId = (changed) => changed.message?.user ?? changed.previous_message?.user ?? changed.message?.bot_id ?? changed.previous_message?.bot_id;
+	const resolveDeletedSenderId = (deleted) => deleted.previous_message?.user ?? deleted.previous_message?.bot_id;
+	const resolveThreadBroadcastSenderId = (thread) => thread.user ?? thread.message?.user ?? thread.message?.bot_id;
+	ctx.app.event("message", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			const message = event;
+			if (message.subtype === "message_changed") {
+				const changed = event;
+				const channelId = changed.channel;
+				const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+					ctx,
+					senderId: resolveChangedSenderId(changed),
+					channelId,
+					eventKind: "message_changed"
+				});
+				if (!ingressContext) return;
+				const messageId = changed.message?.ts ?? changed.previous_message?.ts;
+				enqueueSystemEvent(`Slack message edited in ${ingressContext.channelLabel}.`, {
+					sessionKey: ingressContext.sessionKey,
+					contextKey: `slack:message:changed:${channelId ?? "unknown"}:${messageId ?? changed.event_ts ?? "unknown"}`
+				});
+				return;
+			}
+			if (message.subtype === "message_deleted") {
+				const deleted = event;
+				const channelId = deleted.channel;
+				const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+					ctx,
+					senderId: resolveDeletedSenderId(deleted),
+					channelId,
+					eventKind: "message_deleted"
+				});
+				if (!ingressContext) return;
+				enqueueSystemEvent(`Slack message deleted in ${ingressContext.channelLabel}.`, {
+					sessionKey: ingressContext.sessionKey,
+					contextKey: `slack:message:deleted:${channelId ?? "unknown"}:${deleted.deleted_ts ?? deleted.event_ts ?? "unknown"}`
+				});
+				return;
+			}
+			if (message.subtype === "thread_broadcast") {
+				const thread = event;
+				const channelId = thread.channel;
+				const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+					ctx,
+					senderId: resolveThreadBroadcastSenderId(thread),
+					channelId,
+					eventKind: "thread_broadcast"
+				});
+				if (!ingressContext) return;
+				const messageId = thread.message?.ts ?? thread.event_ts;
+				enqueueSystemEvent(`Slack thread reply broadcast in ${ingressContext.channelLabel}.`, {
+					sessionKey: ingressContext.sessionKey,
+					contextKey: `slack:thread:broadcast:${channelId ?? "unknown"}:${messageId ?? "unknown"}`
+				});
+				return;
+			}
+			await handleSlackMessage(message, { source: "message" });
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack handler failed: ${String(err)}`));
+		}
+	});
+	ctx.app.event("app_mention", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			await handleSlackMessage(event, {
+				source: "app_mention",
+				wasMentioned: true
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack mention handler failed: ${String(err)}`));
+		}
+	});
+}
+
+//#endregion
+//#region src/slack/monitor/events/pins.ts
+async function handleSlackPinEvent(params) {
+	const { ctx, body, event, action, contextKeySuffix, errorLabel } = params;
+	try {
+		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+		const payload = event;
+		const channelId = payload.channel_id;
+		const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+			ctx,
+			senderId: payload.user,
+			channelId,
+			eventKind: "pin"
+		});
+		if (!ingressContext) return;
+		const userLabel = (payload.user ? await ctx.resolveUserName(payload.user) : {})?.name ?? payload.user ?? "someone";
+		const itemType = payload.item?.type ?? "item";
+		const messageId = payload.item?.message?.ts ?? payload.event_ts;
+		enqueueSystemEvent(`Slack: ${userLabel} ${action} a ${itemType} in ${ingressContext.channelLabel}.`, {
+			sessionKey: ingressContext.sessionKey,
+			contextKey: `slack:pin:${contextKeySuffix}:${channelId ?? "unknown"}:${messageId ?? "unknown"}`
+		});
+	} catch (err) {
+		ctx.runtime.error?.(danger(`slack ${errorLabel} handler failed: ${String(err)}`));
+	}
+}
+function registerSlackPinEvents(params) {
+	const { ctx } = params;
+	ctx.app.event("pin_added", async ({ event, body }) => {
+		await handleSlackPinEvent({
+			ctx,
+			body,
+			event,
+			action: "pinned",
+			contextKeySuffix: "added",
+			errorLabel: "pin added"
+		});
+	});
+	ctx.app.event("pin_removed", async ({ event, body }) => {
+		await handleSlackPinEvent({
+			ctx,
+			body,
+			event,
+			action: "unpinned",
+			contextKeySuffix: "removed",
+			errorLabel: "pin removed"
+		});
+	});
+}
+
+//#endregion
+//#region src/slack/monitor/events/reactions.ts
+function registerSlackReactionEvents(params) {
+	const { ctx } = params;
+	const handleReactionEvent = async (event, action) => {
+		try {
+			const item = event.item;
+			if (!item || item.type !== "message") return;
+			const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+				ctx,
+				senderId: event.user,
+				channelId: item.channel,
+				eventKind: "reaction"
+			});
+			if (!ingressContext) return;
+			const actorInfoPromise = event.user ? ctx.resolveUserName(event.user) : Promise.resolve(void 0);
+			const authorInfoPromise = event.item_user ? ctx.resolveUserName(event.item_user) : Promise.resolve(void 0);
+			const [actorInfo, authorInfo] = await Promise.all([actorInfoPromise, authorInfoPromise]);
+			const actorLabel = actorInfo?.name ?? event.user;
+			const emojiLabel = event.reaction ?? "emoji";
+			const authorLabel = authorInfo?.name ?? event.item_user;
+			const baseText = `Slack reaction ${action}: :${emojiLabel}: by ${actorLabel} in ${ingressContext.channelLabel} msg ${item.ts}`;
+			enqueueSystemEvent(authorLabel ? `${baseText} from ${authorLabel}` : baseText, {
+				sessionKey: ingressContext.sessionKey,
+				contextKey: `slack:reaction:${action}:${item.channel}:${item.ts}:${event.user}:${emojiLabel}`
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack reaction handler failed: ${String(err)}`));
+		}
+	};
+	ctx.app.event("reaction_added", async ({ event, body }) => {
+		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+		await handleReactionEvent(event, "added");
+	});
+	ctx.app.event("reaction_removed", async ({ event, body }) => {
+		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+		await handleReactionEvent(event, "removed");
+	});
+}
+
+//#endregion
+//#region src/slack/monitor/events.ts
+function registerSlackMonitorEvents(params) {
+	registerSlackMessageEvents({
+		ctx: params.ctx,
+		handleSlackMessage: params.handleSlackMessage
+	});
+	registerSlackReactionEvents({ ctx: params.ctx });
+	registerSlackMemberEvents({ ctx: params.ctx });
+	registerSlackChannelEvents({ ctx: params.ctx });
+	registerSlackPinEvents({ ctx: params.ctx });
+	registerSlackInteractionEvents({ ctx: params.ctx });
+}
+
+//#endregion
+//#region src/slack/draft-stream.ts
+const SLACK_STREAM_MAX_CHARS = 4e3;
+const DEFAULT_THROTTLE_MS = 1e3;
+function createSlackDraftStream(params) {
+	const maxChars = Math.min(params.maxChars ?? SLACK_STREAM_MAX_CHARS, SLACK_STREAM_MAX_CHARS);
+	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 lastSentText = "";
+	let stopped = false;
+	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;
+		}
+		if (trimmed === lastSentText) return;
+		lastSentText = trimmed;
+		try {
+			if (streamChannelId && streamMessageId) {
+				await edit(streamChannelId, streamMessageId, trimmed, {
+					token: params.token,
+					accountId: params.accountId
+				});
+				return;
+			}
+			const sent = await send(params.target, trimmed, {
+				token: params.token,
+				accountId: params.accountId,
+				threadTs: params.resolveThreadTs?.()
+			});
+			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: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	};
+	const loop = createDraftStreamLoop({
+		throttleMs,
+		isStopped: () => stopped,
+		sendOrEditStreamMessage
+	});
+	const stop = () => {
+		stopped = true;
+		loop.stop();
+	};
+	const clear = async () => {
+		stop();
+		await loop.waitForInFlight();
+		const channelId = streamChannelId;
+		const messageId = streamMessageId;
+		streamChannelId = void 0;
+		streamMessageId = void 0;
+		lastSentText = "";
+		if (!channelId || !messageId) return;
+		try {
+			await remove(channelId, messageId, {
+				token: params.token,
+				accountId: params.accountId
+			});
+		} catch (err) {
+			params.warn?.(`slack stream preview cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	};
+	const forceNewMessage = () => {
+		streamMessageId = void 0;
+		streamChannelId = void 0;
+		lastSentText = "";
+		loop.resetPending();
+	};
+	params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+	return {
+		update: loop.update,
+		flush: loop.flush,
+		clear,
+		stop,
+		forceNewMessage,
+		messageId: () => streamMessageId,
+		channelId: () => streamChannelId
+	};
+}
+
+//#endregion
+//#region src/slack/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
+	};
+}
+function buildStatusFinalPreviewText(updateCount) {
+	return `Status: thinking${".".repeat(Math.max(1, updateCount) % 3 + 1)}`;
+}
+
+//#endregion
+//#region src/slack/streaming.ts
+/**
+* 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, teamId, userId } = params;
+	logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}${teamId ? ` team=${teamId}` : ""}${userId ? ` user=${userId}` : ""}`);
+	const streamer = client.chatStream({
+		channel,
+		thread_ts: threadTs,
+		...teamId ? { recipient_team_id: teamId } : {},
+		...userId ? { recipient_user_id: userId } : {}
+	});
+	const session = {
+		streamer,
+		channel,
+		threadTs,
+		stopped: false
+	};
+	if (text) {
+		await streamer.append({ markdown_text: text });
+		logVerbose(`slack-stream: appended initial text (${text.length} chars)`);
+	}
+	return session;
+}
+/**
+* Append markdown text to an active Slack stream.
+*/
+async function appendSlackStream(params) {
+	const { session, text } = params;
+	if (session.stopped) {
+		logVerbose("slack-stream: attempted to append to a stopped stream, ignoring");
+		return;
+	}
+	if (!text) return;
+	await session.streamer.append({ markdown_text: text });
+	logVerbose(`slack-stream: appended ${text.length} chars`);
+}
+/**
+* Stop (finalize) a Slack stream.
+*
+* After calling this the stream message becomes a normal Slack message.
+* Optionally include final text to append before stopping.
+*/
+async function stopSlackStream(params) {
+	const { session, text } = params;
+	if (session.stopped) {
+		logVerbose("slack-stream: stream already stopped, ignoring duplicate stop");
+		return;
+	}
+	session.stopped = true;
+	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}${text ? ` (final text: ${text.length} chars)` : ""}`);
+	await session.streamer.stop(text ? { markdown_text: text } : void 0);
+	logVerbose("slack-stream: stream stopped");
+}
+
+//#endregion
+//#region src/slack/threading.ts
+function resolveSlackThreadContext(params) {
+	const incomingThreadTs = params.message.thread_ts;
+	const eventTs = params.message.event_ts;
+	const messageTs = params.message.ts ?? eventTs;
+	const isThreadReply = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0 && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
+	return {
+		incomingThreadTs,
+		messageTs,
+		isThreadReply,
+		replyToId: incomingThreadTs ?? messageTs,
+		messageThreadId: isThreadReply ? 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 src/slack/monitor/message-handler/dispatch.ts
+function hasMedia(payload) {
+	return Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+}
+function isSlackStreamingEnabled(params) {
+	if (params.mode !== "partial") return false;
+	return params.nativeStreaming;
+}
+function resolveSlackStreamingThreadHint(params) {
+	return resolveSlackThreadTs({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: false,
+		isThreadReply: params.isThreadReply
+	});
+}
+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 dispatchPreparedSlackMessage(prepared) {
+	const { ctx, account, message, route } = prepared;
+	const cfg = ctx.cfg;
+	const runtime = ctx.runtime;
+	if (prepared.isDirectMessage) {
+		const sessionCfg = cfg.session;
+		await updateLastRoute({
+			storePath: resolveStorePath(sessionCfg?.store, { agentId: route.agentId }),
+			sessionKey: route.mainSessionKey,
+			deliveryContext: {
+				channel: "slack",
+				to: `user:${message.user}`,
+				accountId: route.accountId,
+				threadId: prepared.ctxPayload.MessageThreadId
+			},
+			ctx: prepared.ctxPayload
+		});
+	}
+	const { statusThreadTs, isThreadReply } = resolveSlackThreadTargets({
+		message,
+		replyToMode: ctx.replyToMode
+	});
+	const messageTs = message.ts ?? message.event_ts;
+	const incomingThreadTs = message.thread_ts;
+	let didSetStatus = false;
+	const hasRepliedRef = { value: false };
+	const replyPlan = createSlackReplyDeliveryPlan({
+		replyToMode: ctx.replyToMode,
+		incomingThreadTs,
+		messageTs,
+		hasRepliedRef,
+		isThreadReply
+	});
+	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
+	const typingCallbacks = createTypingCallbacks({
+		start: async () => {
+			didSetStatus = true;
+			await ctx.setSlackThreadStatus({
+				channelId: message.channel,
+				threadTs: statusThreadTs,
+				status: "is typing..."
+			});
+		},
+		stop: async () => {
+			if (!didSetStatus) return;
+			didSetStatus = false;
+			await ctx.setSlackThreadStatus({
+				channelId: message.channel,
+				threadTs: statusThreadTs,
+				status: ""
+			});
+		},
+		onStartError: (err) => {
+			logTypingFailure({
+				log: (message) => runtime.error?.(danger(message)),
+				channel: "slack",
+				action: "start",
+				target: typingTarget,
+				error: err
+			});
+		},
+		onStopError: (err) => {
+			logTypingFailure({
+				log: (message) => runtime.error?.(danger(message)),
+				channel: "slack",
+				action: "stop",
+				target: typingTarget,
+				error: err
+			});
+		}
+	});
+	const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+		cfg,
+		agentId: route.agentId,
+		channel: "slack",
+		accountId: route.accountId
+	});
+	const slackStreaming = resolveSlackStreamingConfig({
+		streaming: account.config.streaming,
+		streamMode: account.config.streamMode,
+		nativeStreaming: account.config.nativeStreaming
+	});
+	const previewStreamingEnabled = slackStreaming.mode !== "off";
+	const useStreaming = shouldUseStreaming({
+		streamingEnabled: isSlackStreamingEnabled({
+			mode: slackStreaming.mode,
+			nativeStreaming: slackStreaming.nativeStreaming
+		}),
+		threadTs: resolveSlackStreamingThreadHint({
+			replyToMode: ctx.replyToMode,
+			incomingThreadTs,
+			messageTs,
+			isThreadReply
+		})
+	});
+	let streamSession = null;
+	let streamFailed = false;
+	const deliverNormally = async (payload, forcedThreadTs) => {
+		const replyThreadTs = forcedThreadTs ?? replyPlan.nextThreadTs();
+		await deliverReplies({
+			replies: [payload],
+			target: prepared.replyTarget,
+			token: ctx.botToken,
+			accountId: account.accountId,
+			runtime,
+			textLimit: ctx.textLimit,
+			replyThreadTs,
+			replyToMode: ctx.replyToMode
+		});
+		replyPlan.markSent();
+	};
+	const deliverWithStreaming = async (payload) => {
+		if (streamFailed || hasMedia(payload) || !payload.text?.trim()) {
+			await deliverNormally(payload, streamSession?.threadTs);
+			return;
+		}
+		const text = payload.text.trim();
+		let plannedThreadTs;
+		try {
+			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);
+					return;
+				}
+				streamSession = await startSlackStream({
+					client: ctx.app.client,
+					channel: message.channel,
+					threadTs: streamThreadTs,
+					text,
+					teamId: ctx.teamId,
+					userId: message.user
+				});
+				replyPlan.markSent();
+				return;
+			}
+			await appendSlackStream({
+				session: streamSession,
+				text: "\n" + text
+			});
+		} catch (err) {
+			runtime.error?.(danger(`slack-stream: streaming API call failed: ${String(err)}, falling back`));
+			streamFailed = true;
+			await deliverNormally(payload, streamSession?.threadTs ?? plannedThreadTs);
+		}
+	};
+	const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
+		...prefixOptions,
+		humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
+		typingCallbacks,
+		deliver: async (payload) => {
+			if (useStreaming) {
+				await deliverWithStreaming(payload);
+				return;
+			}
+			const mediaCount = payload.mediaUrls?.length ?? (payload.mediaUrl ? 1 : 0);
+			const draftMessageId = draftStream?.messageId();
+			const draftChannelId = draftStream?.channelId();
+			const finalText = payload.text;
+			if (previewStreamingEnabled && streamMode !== "status_final" && mediaCount === 0 && !payload.isError && typeof finalText === "string" && finalText.trim().length > 0 && typeof draftMessageId === "string" && typeof draftChannelId === "string") {
+				draftStream?.stop();
+				try {
+					await ctx.app.client.chat.update({
+						token: ctx.botToken,
+						channel: draftChannelId,
+						ts: draftMessageId,
+						text: finalText.trim()
+					});
+					return;
+				} catch (err) {
+					logVerbose(`slack: preview final edit failed; falling back to standard send (${String(err)})`);
+				}
+			} else if (previewStreamingEnabled && streamMode === "status_final" && hasStreamedMessage) try {
+				const statusChannelId = draftStream?.channelId();
+				const statusMessageId = draftStream?.messageId();
+				if (statusChannelId && statusMessageId) await ctx.app.client.chat.update({
+					token: ctx.botToken,
+					channel: statusChannelId,
+					ts: statusMessageId,
+					text: "Status: complete. Final answer posted below."
+				});
+			} catch (err) {
+				logVerbose(`slack: status_final completion update failed (${String(err)})`);
+			}
+			else if (mediaCount > 0) {
+				await draftStream?.clear();
+				hasStreamedMessage = false;
+			}
+			await deliverNormally(payload);
+		},
+		onError: (err, info) => {
+			runtime.error?.(danger(`slack ${info.kind} reply failed: ${String(err)}`));
+			typingCallbacks.onIdle?.();
+		}
+	});
+	const draftStream = createSlackDraftStream({
+		target: prepared.replyTarget,
+		token: ctx.botToken,
+		accountId: account.accountId,
+		maxChars: Math.min(ctx.textLimit, 4e3),
+		resolveThreadTs: () => replyPlan.peekThreadTs(),
+		log: logVerbose,
+		warn: logVerbose
+	});
+	let hasStreamedMessage = false;
+	const streamMode = slackStreaming.draftMode;
+	let appendRenderedText = "";
+	let appendSourceText = "";
+	let statusUpdateCount = 0;
+	const updateDraftFromPartial = (text) => {
+		const trimmed = text?.trimEnd();
+		if (!trimmed) return;
+		if (streamMode === "append") {
+			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") {
+			statusUpdateCount += 1;
+			if (statusUpdateCount > 1 && statusUpdateCount % 4 !== 0) return;
+			draftStream.update(buildStatusFinalPreviewText(statusUpdateCount));
+			hasStreamedMessage = true;
+			return;
+		}
+		draftStream.update(trimmed);
+		hasStreamedMessage = true;
+	};
+	const onDraftBoundary = useStreaming || !previewStreamingEnabled ? void 0 : async () => {
+		if (hasStreamedMessage) {
+			draftStream.forceNewMessage();
+			hasStreamedMessage = false;
+			appendRenderedText = "";
+			appendSourceText = "";
+			statusUpdateCount = 0;
+		}
+	};
+	const { queuedFinal, counts } = await dispatchInboundMessage({
+		ctx: prepared.ctxPayload,
+		cfg,
+		dispatcher,
+		replyOptions: {
+			...replyOptions,
+			skillFilter: prepared.channelConfig?.skills,
+			hasRepliedRef,
+			disableBlockStreaming: useStreaming ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : void 0,
+			onModelSelected,
+			onPartialReply: useStreaming ? void 0 : !previewStreamingEnabled ? void 0 : async (payload) => {
+				updateDraftFromPartial(payload.text);
+			},
+			onAssistantMessageStart: onDraftBoundary,
+			onReasoningEnd: onDraftBoundary
+		}
+	});
+	await draftStream.flush();
+	draftStream.stop();
+	markDispatchIdle();
+	const finalStream = streamSession;
+	if (finalStream && !finalStream.stopped) try {
+		await stopSlackStream({ session: finalStream });
+	} catch (err) {
+		runtime.error?.(danger(`slack-stream: failed to stop stream: ${String(err)}`));
+	}
+	if (!(queuedFinal || (counts.block ?? 0) > 0 || (counts.final ?? 0) > 0)) {
+		await draftStream.clear();
+		if (prepared.isRoomish) clearHistoryEntriesIfEnabled({
+			historyMap: ctx.channelHistories,
+			historyKey: prepared.historyKey,
+			limit: ctx.historyLimit
+		});
+		return;
+	}
+	if (shouldLogVerbose()) {
+		const finalCount = counts.final;
+		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
+	}
+	removeAckReactionAfterReply({
+		removeAfterReply: ctx.removeAckAfterReply,
+		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
+			});
+		}
+	});
+	if (prepared.isRoomish) clearHistoryEntriesIfEnabled({
+		historyMap: ctx.channelHistories,
+		historyKey: prepared.historyKey,
+		limit: ctx.historyLimit
+	});
+}
+
+//#endregion
+//#region src/slack/monitor/dm-auth.ts
+async function authorizeSlackDirectMessage(params) {
+	if (!params.ctx.dmEnabled || params.ctx.dmPolicy === "disabled") {
+		await params.onDisabled();
+		return false;
+	}
+	if (params.ctx.dmPolicy === "open") return true;
+	const senderName = (await params.resolveSenderName(params.senderId))?.name ?? void 0;
+	const allowMatch = resolveSlackAllowListMatch({
+		allowList: params.allowFromLower,
+		id: params.senderId,
+		name: senderName,
+		allowNameMatching: params.ctx.allowNameMatching
+	});
+	const allowMatchMeta = formatAllowlistMatchMeta(allowMatch);
+	if (allowMatch.allowed) return true;
+	if (params.ctx.dmPolicy === "pairing") {
+		await issuePairingChallenge({
+			channel: "slack",
+			senderId: params.senderId,
+			senderIdLine: `Your Slack user id: ${params.senderId}`,
+			meta: { name: senderName },
+			upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+				channel: "slack",
+				id,
+				accountId: params.accountId,
+				meta
+			}),
+			sendPairingReply: params.sendPairingReply,
+			onCreated: () => {
+				params.log(`slack pairing request sender=${params.senderId} name=${senderName ?? "unknown"} (${allowMatchMeta})`);
+			},
+			onReplyError: (err) => {
+				params.log(`slack pairing reply failed for ${params.senderId}: ${String(err)}`);
+			}
+		});
+		return false;
+	}
+	await params.onUnauthorized({
+		allowMatchMeta,
+		senderName
+	});
+	return false;
+}
+
+//#endregion
+//#region src/slack/monitor/media.ts
+function isSlackHostname(hostname) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) return false;
+	return [
+		"slack.com",
+		"slack-edge.com",
+		"slack-files.com"
+	].some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
+}
+function assertSlackFileUrl(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		throw new Error(`Invalid Slack file URL: ${rawUrl}`);
+	}
+	if (parsed.protocol !== "https:") throw new Error(`Refusing Slack file URL with non-HTTPS protocol: ${parsed.protocol}`);
+	if (!isSlackHostname(parsed.hostname)) throw new Error(`Refusing to send Slack token to non-Slack host "${parsed.hostname}" (url: ${rawUrl})`);
+	return parsed;
+}
+function resolveRequestUrl(input) {
+	if (typeof input === "string") return input;
+	if (input instanceof URL) return input.toString();
+	if ("url" in input && typeof input.url === "string") return input.url;
+	throw new Error("Unsupported fetch input: expected string, URL, or Request");
+}
+function createSlackMediaFetch(token) {
+	let includeAuth = true;
+	return async (input, init) => {
+		const url = resolveRequestUrl(input);
+		const { headers: initHeaders, redirect: _redirect, ...rest } = init ?? {};
+		const headers = new Headers(initHeaders);
+		if (includeAuth) {
+			includeAuth = false;
+			const parsed = assertSlackFileUrl(url);
+			headers.set("Authorization", `Bearer ${token}`);
+			return fetch(parsed.href, {
+				...rest,
+				headers,
+				redirect: "manual"
+			});
+		}
+		headers.delete("Authorization");
+		return fetch(url, {
+			...rest,
+			headers,
+			redirect: "manual"
+		});
+	};
+}
+/**
+* Slack voice messages (audio clips, huddle recordings) carry a `subtype` of
+* `"slack_audio"` but are served with a `video/*` MIME type (e.g. `video/mp4`,
+* `video/webm`).  Override the primary type to `audio/` so the
+* media-understanding pipeline routes them to transcription.
+*/
+function resolveSlackMediaMimetype(file, fetchedContentType) {
+	const mime = fetchedContentType ?? file.mimetype;
+	if (file.subtype === "slack_audio" && mime?.startsWith("video/")) return mime.replace("video/", "audio/");
+	return mime;
+}
+const MAX_SLACK_MEDIA_FILES = 8;
+const MAX_SLACK_MEDIA_CONCURRENCY = 3;
+const MAX_SLACK_FORWARDED_ATTACHMENTS = 8;
+function isForwardedSlackAttachment(attachment) {
+	return attachment.is_share === true;
+}
+function resolveForwardedAttachmentImageUrl(attachment) {
+	const rawUrl = attachment.image_url?.trim();
+	if (!rawUrl) return null;
+	try {
+		const parsed = new URL(rawUrl);
+		if (parsed.protocol !== "https:" || !isSlackHostname(parsed.hostname)) return null;
+		return parsed.toString();
+	} catch {
+		return null;
+	}
+}
+async function mapLimit(items, limit, fn) {
+	if (items.length === 0) return [];
+	const results = [];
+	results.length = items.length;
+	let nextIndex = 0;
+	const workerCount = Math.max(1, Math.min(limit, items.length));
+	await Promise.all(Array.from({ length: workerCount }, async () => {
+		while (true) {
+			const idx = nextIndex++;
+			if (idx >= items.length) return;
+			results[idx] = await fn(items[idx]);
+		}
+	}));
+	return results;
+}
+/**
+* Downloads all files attached to a Slack message and returns them as an array.
+* Returns `null` when no files could be downloaded.
+*/
+async function resolveSlackMedia(params) {
+	const files = params.files ?? [];
+	const results = (await mapLimit(files.length > MAX_SLACK_MEDIA_FILES ? files.slice(0, MAX_SLACK_MEDIA_FILES) : files, MAX_SLACK_MEDIA_CONCURRENCY, async (file) => {
+		const url = file.url_private_download ?? file.url_private;
+		if (!url) return null;
+		try {
+			const fetched = await fetchRemoteMedia({
+				url,
+				fetchImpl: createSlackMediaFetch(params.token),
+				filePathHint: file.name,
+				maxBytes: params.maxBytes
+			});
+			if (fetched.buffer.byteLength > params.maxBytes) return null;
+			const effectiveMime = resolveSlackMediaMimetype(file, fetched.contentType);
+			const saved = await saveMediaBuffer(fetched.buffer, effectiveMime, "inbound", params.maxBytes);
+			const label = fetched.fileName ?? file.name;
+			const contentType = effectiveMime ?? saved.contentType;
+			return {
+				path: saved.path,
+				...contentType ? { contentType } : {},
+				placeholder: label ? `[Slack file: ${label}]` : "[Slack file]"
+			};
+		} catch {
+			return null;
+		}
+	})).filter((entry) => Boolean(entry));
+	return results.length > 0 ? results : null;
+}
+/** Extracts text and media from forwarded-message attachments. Returns null when empty. */
+async function resolveSlackAttachmentContent(params) {
+	const attachments = params.attachments;
+	if (!attachments || attachments.length === 0) return null;
+	const forwardedAttachments = attachments.filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
+	if (forwardedAttachments.length === 0) return null;
+	const textBlocks = [];
+	const allMedia = [];
+	for (const att of forwardedAttachments) {
+		const text = att.text?.trim() || att.fallback?.trim();
+		if (text) {
+			const author = att.author_name;
+			const heading = author ? `[Forwarded message from ${author}]` : "[Forwarded message]";
+			textBlocks.push(`${heading}\n${text}`);
+		}
+		const imageUrl = resolveForwardedAttachmentImageUrl(att);
+		if (imageUrl) try {
+			const fetched = await fetchRemoteMedia({
+				url: imageUrl,
+				maxBytes: params.maxBytes
+			});
+			if (fetched.buffer.byteLength <= params.maxBytes) {
+				const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", params.maxBytes);
+				const label = fetched.fileName ?? "forwarded image";
+				allMedia.push({
+					path: saved.path,
+					contentType: fetched.contentType ?? saved.contentType,
+					placeholder: `[Forwarded image: ${label}]`
+				});
+			}
+		} catch {}
+		if (att.files && att.files.length > 0) {
+			const fileMedia = await resolveSlackMedia({
+				files: att.files,
+				token: params.token,
+				maxBytes: params.maxBytes
+			});
+			if (fileMedia) allMedia.push(...fileMedia);
+		}
+	}
+	const combinedText = textBlocks.join("\n\n");
+	if (!combinedText && allMedia.length === 0) return null;
+	return {
+		text: combinedText,
+		media: allMedia
+	};
+}
+const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
+const THREAD_STARTER_CACHE_TTL_MS = 360 * 6e4;
+const THREAD_STARTER_CACHE_MAX = 2e3;
+function evictThreadStarterCache() {
+	const now = Date.now();
+	for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) if (now - entry.cachedAt > THREAD_STARTER_CACHE_TTL_MS) THREAD_STARTER_CACHE.delete(cacheKey);
+	if (THREAD_STARTER_CACHE.size <= THREAD_STARTER_CACHE_MAX) return;
+	const excess = THREAD_STARTER_CACHE.size - THREAD_STARTER_CACHE_MAX;
+	let removed = 0;
+	for (const cacheKey of THREAD_STARTER_CACHE.keys()) {
+		THREAD_STARTER_CACHE.delete(cacheKey);
+		removed += 1;
+		if (removed >= excess) break;
+	}
+}
+async function resolveSlackThreadStarter(params) {
+	evictThreadStarterCache();
+	const cacheKey = `${params.channelId}:${params.threadTs}`;
+	const cached = THREAD_STARTER_CACHE.get(cacheKey);
+	if (cached && Date.now() - cached.cachedAt <= THREAD_STARTER_CACHE_TTL_MS) return cached.value;
+	if (cached) THREAD_STARTER_CACHE.delete(cacheKey);
+	try {
+		const message = (await params.client.conversations.replies({
+			channel: params.channelId,
+			ts: params.threadTs,
+			limit: 1,
+			inclusive: true
+		}))?.messages?.[0];
+		const text = (message?.text ?? "").trim();
+		if (!message || !text) return null;
+		const starter = {
+			text,
+			userId: message.user,
+			ts: message.ts,
+			files: message.files
+		};
+		if (THREAD_STARTER_CACHE.has(cacheKey)) THREAD_STARTER_CACHE.delete(cacheKey);
+		THREAD_STARTER_CACHE.set(cacheKey, {
+			value: starter,
+			cachedAt: Date.now()
+		});
+		evictThreadStarterCache();
+		return starter;
+	} catch {
+		return null;
+	}
+}
+/**
+* Fetches the most recent messages in a Slack thread (excluding the current message).
+* Used to populate thread context when a new thread session starts.
+*
+* Uses cursor pagination and keeps only the latest N retained messages so long threads
+* still produce up-to-date context without unbounded memory growth.
+*/
+async function resolveSlackThreadHistory(params) {
+	const maxMessages = params.limit ?? 20;
+	if (!Number.isFinite(maxMessages) || maxMessages <= 0) return [];
+	const fetchLimit = 200;
+	const retained = [];
+	let cursor;
+	try {
+		do {
+			const response = await params.client.conversations.replies({
+				channel: params.channelId,
+				ts: params.threadTs,
+				limit: fetchLimit,
+				inclusive: true,
+				...cursor ? { cursor } : {}
+			});
+			for (const msg of response.messages ?? []) {
+				if (!msg.text?.trim() && !msg.files?.length) continue;
+				if (params.currentMessageTs && msg.ts === params.currentMessageTs) continue;
+				retained.push(msg);
+				if (retained.length > maxMessages) retained.shift();
+			}
+			const next = response.response_metadata?.next_cursor;
+			cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : void 0;
+		} while (cursor);
+		return retained.map((msg) => ({
+			text: msg.text?.trim() ? msg.text : `[attached: ${msg.files?.map((f) => f.name ?? "file").join(", ")}]`,
+			userId: msg.user,
+			botId: msg.bot_id,
+			ts: msg.ts,
+			files: msg.files
+		}));
+	} catch {
+		return [];
+	}
+}
+
+//#endregion
+//#region src/slack/monitor/room-context.ts
+function resolveSlackRoomContextHints(params) {
+	if (!params.isRoomish) return {};
+	const untrustedChannelMetadata = buildUntrustedChannelMetadata({
+		source: "slack",
+		label: "Slack channel description",
+		entries: [params.channelInfo?.topic, params.channelInfo?.purpose]
+	});
+	const systemPromptParts = [params.channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
+	return {
+		untrustedChannelMetadata,
+		groupSystemPrompt: systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : void 0
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/message-handler/prepare.ts
+async function prepareSlackMessage(params) {
+	const { ctx, account, message, opts } = params;
+	const cfg = ctx.cfg;
+	let channelInfo = {};
+	let channelType = message.channel_type;
+	if (!channelType || channelType !== "im") {
+		channelInfo = await ctx.resolveChannelName(message.channel);
+		channelType = channelType ?? channelInfo.type;
+	}
+	const channelName = channelInfo?.name;
+	const resolvedChannelType = normalizeSlackChannelType(channelType, message.channel);
+	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,
+		defaultRequireMention: ctx.defaultRequireMention
+	}) : null;
+	const allowBots = channelConfig?.allowBots ?? account.config?.allowBots ?? cfg.channels?.slack?.allowBots ?? false;
+	const isBotMessage = Boolean(message.bot_id);
+	if (isBotMessage) {
+		if (message.user && ctx.botUserId && message.user === ctx.botUserId) return null;
+		if (!allowBots) {
+			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, {
+					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;
+	}
+	const route = resolveAgentRoute({
+		cfg,
+		channel: "slack",
+		accountId: account.accountId,
+		teamId: ctx.teamId || void 0,
+		peer: {
+			kind: isDirectMessage ? "direct" : isRoom ? "channel" : "group",
+			id: isDirectMessage ? message.user ?? "unknown" : message.channel
+		}
+	});
+	const baseSessionKey = route.sessionKey;
+	const threadContext = resolveSlackThreadContext({
+		message,
+		replyToMode: ctx.replyToMode
+	});
+	const threadTs = threadContext.incomingThreadTs;
+	const isThreadReply = threadContext.isThreadReply;
+	const threadKeys = resolveThreadSessionKeys({
+		baseSessionKey,
+		threadId: isThreadReply ? threadTs : void 0,
+		parentSessionKey: isThreadReply && ctx.threadInheritParent ? baseSessionKey : void 0
+	});
+	const sessionKey = threadKeys.sessionKey;
+	const historyKey = isThreadReply && ctx.threadHistoryScope === "thread" ? sessionKey : message.channel;
+	const mentionRegexes = buildMentionRegexes(cfg, route.agentId);
+	const hasAnyMention = /<@[^>]+>/.test(message.text ?? "");
+	const explicitlyMentioned = Boolean(ctx.botUserId && message.text?.includes(`<@${ctx.botUserId}>`));
+	const wasMentioned = opts.wasMentioned ?? (!isDirectMessage && matchesMentionWithExplicit({
+		text: message.text ?? "",
+		mentionRegexes,
+		explicit: {
+			hasAnyMention,
+			isExplicitlyMentioned: explicitlyMentioned,
+			canResolveExplicit: Boolean(ctx.botUserId)
+		}
+	}));
+	const implicitMention = Boolean(!isDirectMessage && ctx.botUserId && message.thread_ts && message.parent_user_id === ctx.botUserId);
+	const senderName = (message.user ? await ctx.resolveUserName(message.user) : null)?.name ?? message.username?.trim() ?? message.user ?? message.bot_id ?? "unknown";
+	const channelUserAuthorized = isRoom ? resolveSlackUserAllowed({
+		allowList: channelConfig?.users,
+		userId: senderId,
+		userName: senderName,
+		allowNameMatching: ctx.allowNameMatching
+	}) : true;
+	if (isRoom && !channelUserAuthorized) {
+		logVerbose(`Blocked unauthorized slack sender ${senderId} (not in channel users)`);
+		return null;
+	}
+	const allowTextCommands = shouldHandleTextCommands({
+		cfg,
+		surface: "slack"
+	});
+	const hasControlCommandInMessage = hasControlCommand(stripSlackMentionsForCommandDetection(message.text ?? ""), cfg);
+	const ownerAuthorized = resolveSlackAllowListMatch({
+		allowList: allowFromLower,
+		id: senderId,
+		name: senderName,
+		allowNameMatching: ctx.allowNameMatching
+	}).allowed;
+	const channelUsersAllowlistConfigured = isRoom && Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
+	const channelCommandAuthorized = isRoom && channelUsersAllowlistConfigured ? resolveSlackUserAllowed({
+		allowList: channelConfig?.users,
+		userId: senderId,
+		userName: senderName,
+		allowNameMatching: ctx.allowNameMatching
+	}) : false;
+	const commandGate = resolveControlCommandGate({
+		useAccessGroups: ctx.useAccessGroups,
+		authorizers: [{
+			configured: allowFromLower.length > 0,
+			allowed: ownerAuthorized
+		}, {
+			configured: channelUsersAllowlistConfigured,
+			allowed: channelCommandAuthorized
+		}],
+		allowTextCommands,
+		hasControlCommand: hasControlCommandInMessage
+	});
+	const commandAuthorized = commandGate.commandAuthorized;
+	if (isRoomish && commandGate.shouldBlock) {
+		logInboundDrop({
+			log: logVerbose,
+			channel: "slack",
+			reason: "control command (unauthorized)",
+			target: senderId
+		});
+		return null;
+	}
+	const shouldRequireMention = isRoom ? channelConfig?.requireMention ?? ctx.defaultRequireMention : false;
+	const canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
+	const mentionGate = resolveMentionGatingWithBypass({
+		isGroup: isRoom,
+		requireMention: Boolean(shouldRequireMention),
+		canDetectMention,
+		wasMentioned,
+		implicitMention,
+		hasAnyMention,
+		allowTextCommands,
+		hasControlCommand: hasControlCommandInMessage,
+		commandAuthorized
+	});
+	const effectiveWasMentioned = mentionGate.effectiveWasMentioned;
+	if (isRoom && shouldRequireMention && mentionGate.shouldSkip) {
+		ctx.logger.info({
+			channel: message.channel,
+			reason: "no-mention"
+		}, "skipping channel message");
+		const pendingText = (message.text ?? "").trim();
+		const fallbackFile = message.files?.[0]?.name ? `[Slack file: ${message.files[0].name}]` : message.files?.length ? "[Slack file]" : "";
+		const pendingBody = pendingText || fallbackFile;
+		recordPendingHistoryEntryIfEnabled({
+			historyMap: ctx.channelHistories,
+			historyKey,
+			limit: ctx.historyLimit,
+			entry: pendingBody ? {
+				sender: senderName,
+				body: pendingBody,
+				timestamp: message.ts ? Math.round(Number(message.ts) * 1e3) : void 0,
+				messageId: message.ts
+			} : null
+		});
+		return null;
+	}
+	const media = await resolveSlackMedia({
+		files: message.files,
+		token: ctx.botToken,
+		maxBytes: ctx.mediaMaxBytes
+	});
+	const attachmentContent = await resolveSlackAttachmentContent({
+		attachments: message.attachments,
+		token: ctx.botToken,
+		maxBytes: ctx.mediaMaxBytes
+	});
+	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
+	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
+	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((m) => m.placeholder).join(" ") : void 0;
+	const fileOnlyFallback = !mediaPlaceholder && (message.files?.length ?? 0) > 0 ? message.files.slice(0, MAX_SLACK_MEDIA_FILES).map((f) => f.name?.trim() || "file").join(", ") : void 0;
+	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
+	const rawBody = [
+		(message.text ?? "").trim(),
+		attachmentContent?.text,
+		mediaPlaceholder,
+		fileOnlyPlaceholder
+	].filter(Boolean).join("\n") || "";
+	if (!rawBody) return null;
+	const ackReaction = resolveAckReaction(cfg, route.agentId, {
+		channel: "slack",
+		accountId: account.accountId
+	});
+	const ackReactionValue = ackReaction ?? "";
+	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
+		scope: ctx.ackReactionScope,
+		isDirect: isDirectMessage,
+		isGroup: isRoomish,
+		isMentionableGroup: isRoom,
+		requireMention: Boolean(shouldRequireMention),
+		canDetectMention,
+		effectiveWasMentioned,
+		shouldBypassMention: mentionGate.shouldBypassMention
+	}));
+	const ackReactionMessageTs = message.ts;
+	const ackReactionPromise = shouldAckReaction$1() && 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}: ${String(err)}`);
+		return false;
+	}) : null;
+	const roomLabel = channelName ? `#${channelName}` : `#${message.channel}`;
+	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}: ${preview}`, {
+		sessionKey,
+		contextKey: `slack:message:${message.channel}:${message.ts ?? "unknown"}`
+	});
+	const envelopeFrom = resolveConversationLabel({
+		ChatType: isDirectMessage ? "direct" : "channel",
+		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: route.sessionKey
+	});
+	let combinedBody = formatInboundEnvelope({
+		channel: "Slack",
+		from: envelopeFrom,
+		timestamp: message.ts ? Math.round(Number(message.ts) * 1e3) : void 0,
+		body: textWithId,
+		chatType: isDirectMessage ? "direct" : "channel",
+		sender: {
+			name: senderName,
+			id: senderId
+		},
+		previousTimestamp,
+		envelope: envelopeOptions
+	});
+	if (isRoomish && ctx.historyLimit > 0) combinedBody = buildPendingHistoryContextFromMap({
+		historyMap: ctx.channelHistories,
+		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
+	});
+	let threadStarterBody;
+	let threadHistoryBody;
+	let threadSessionPreviousTimestamp;
+	let threadLabel;
+	let threadStarterMedia = null;
+	if (isThreadReply && threadTs) {
+		const starter = await resolveSlackThreadStarter({
+			channelId: message.channel,
+			threadTs,
+			client: ctx.app.client
+		});
+		if (starter?.text) {
+			threadStarterBody = starter.text;
+			const snippet = starter.text.replace(/\s+/g, " ").slice(0, 80);
+			threadLabel = `Slack thread ${roomLabel}${snippet ? `: ${snippet}` : ""}`;
+			if (!effectiveDirectMedia && starter.files && starter.files.length > 0) {
+				threadStarterMedia = await resolveSlackMedia({
+					files: starter.files,
+					token: ctx.botToken,
+					maxBytes: ctx.mediaMaxBytes
+				});
+				if (threadStarterMedia) logVerbose(`slack: hydrated thread starter file ${threadStarterMedia.map((m) => m.placeholder).join(", ")} from root message`);
+			}
+		} else threadLabel = `Slack thread ${roomLabel}`;
+		const threadInitialHistoryLimit = account.config?.thread?.initialHistoryLimit ?? 20;
+		threadSessionPreviousTimestamp = readSessionUpdatedAt({
+			storePath,
+			sessionKey
+		});
+		if (threadInitialHistoryLimit > 0) {
+			const threadHistory = await resolveSlackThreadHistory({
+				channelId: message.channel,
+				threadTs,
+				client: ctx.app.client,
+				currentMessageTs: message.ts,
+				limit: threadInitialHistoryLimit
+			});
+			if (threadHistory.length > 0) {
+				const uniqueUserIds = [...new Set(threadHistory.map((m) => m.userId).filter((id) => Boolean(id)))];
+				const userMap = /* @__PURE__ */ new Map();
+				await Promise.all(uniqueUserIds.map(async (id) => {
+					const user = await ctx.resolveUserName(id);
+					if (user) userMap.set(id, user);
+				}));
+				const historyParts = [];
+				for (const historyMsg of threadHistory) {
+					const msgSenderName = (historyMsg.userId ? userMap.get(historyMsg.userId) : null)?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
+					const role = Boolean(historyMsg.botId) ? "assistant" : "user";
+					const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${message.channel}]`;
+					historyParts.push(formatInboundEnvelope({
+						channel: "Slack",
+						from: `${msgSenderName} (${role})`,
+						timestamp: historyMsg.ts ? Math.round(Number(historyMsg.ts) * 1e3) : void 0,
+						body: msgWithId,
+						chatType: "channel",
+						envelope: envelopeOptions
+					}));
+				}
+				threadHistoryBody = historyParts.join("\n\n");
+				logVerbose(`slack: populated thread history with ${threadHistory.length} messages for new session`);
+			}
+		}
+	}
+	const effectiveMedia = effectiveDirectMedia ?? threadStarterMedia;
+	const firstMedia = effectiveMedia?.[0];
+	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? (ctx.channelHistories.get(historyKey) ?? []).map((entry) => ({
+		sender: entry.sender,
+		body: entry.body,
+		timestamp: entry.timestamp
+	})) : void 0;
+	const ctxPayload = finalizeInboundContext({
+		Body: combinedBody,
+		BodyForAgent: rawBody,
+		InboundHistory: inboundHistory,
+		RawBody: rawBody,
+		CommandBody: rawBody,
+		From: slackFrom,
+		To: slackTo,
+		SessionKey: sessionKey,
+		AccountId: route.accountId,
+		ChatType: isDirectMessage ? "direct" : "channel",
+		ConversationLabel: envelopeFrom,
+		GroupSubject: isRoomish ? roomLabel : void 0,
+		GroupSystemPrompt: isRoomish ? groupSystemPrompt : void 0,
+		UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
+		SenderName: senderName,
+		SenderId: senderId,
+		Provider: "slack",
+		Surface: "slack",
+		MessageSid: message.ts,
+		ReplyToId: threadContext.replyToId,
+		MessageThreadId: threadContext.messageThreadId,
+		ParentSessionKey: threadKeys.parentSessionKey,
+		ThreadStarterBody: threadStarterBody,
+		ThreadHistoryBody: threadHistoryBody,
+		IsFirstThreadTurn: isThreadReply && threadTs && !threadSessionPreviousTimestamp ? true : void 0,
+		ThreadLabel: threadLabel,
+		Timestamp: message.ts ? Math.round(Number(message.ts) * 1e3) : void 0,
+		WasMentioned: isRoomish ? effectiveWasMentioned : void 0,
+		MediaPath: firstMedia?.path,
+		MediaType: firstMedia?.contentType,
+		MediaUrl: firstMedia?.path,
+		MediaPaths: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.path) : void 0,
+		MediaUrls: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.path) : void 0,
+		MediaTypes: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.contentType ?? "") : void 0,
+		CommandAuthorized: commandAuthorized,
+		OriginatingChannel: "slack",
+		OriginatingTo: slackTo
+	});
+	await recordInboundSession({
+		storePath,
+		sessionKey,
+		ctx: ctxPayload,
+		updateLastRoute: isDirectMessage ? {
+			sessionKey: route.mainSessionKey,
+			channel: "slack",
+			to: `user:${message.user}`,
+			accountId: route.accountId,
+			threadId: threadContext.messageThreadId
+		} : void 0,
+		onRecordError: (err) => {
+			ctx.logger.warn({
+				error: String(err),
+				storePath,
+				sessionKey
+			}, "failed updating session meta");
+		}
+	});
+	const replyTarget = ctxPayload.To ?? void 0;
+	if (!replyTarget) return null;
+	if (shouldLogVerbose()) logVerbose(`slack inbound: channel=${message.channel} from=${slackFrom} preview="${preview}"`);
+	return {
+		ctx,
+		account,
+		message,
+		route,
+		channelConfig,
+		replyTarget,
+		ctxPayload,
+		isDirectMessage,
+		isRoomish,
+		historyKey,
+		preview,
+		ackReactionMessageTs,
+		ackReactionValue,
+		ackReactionPromise
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/thread-resolution.ts
+const DEFAULT_THREAD_TS_CACHE_TTL_MS = 6e4;
+const DEFAULT_THREAD_TS_CACHE_MAX = 500;
+const normalizeThreadTs = (threadTs) => {
+	const trimmed = threadTs?.trim();
+	return trimmed ? trimmed : void 0;
+};
+async function resolveThreadTsFromHistory(params) {
+	try {
+		const response = await params.client.conversations.history({
+			channel: params.channelId,
+			latest: params.messageTs,
+			oldest: params.messageTs,
+			inclusive: true,
+			limit: 1
+		});
+		return normalizeThreadTs((response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0])?.thread_ts);
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`slack inbound: failed to resolve thread_ts via conversations.history for channel=${params.channelId} ts=${params.messageTs}: ${String(err)}`);
+		return;
+	}
+}
+function createSlackThreadTsResolver(params) {
+	const ttlMs = Math.max(0, params.cacheTtlMs ?? DEFAULT_THREAD_TS_CACHE_TTL_MS);
+	const maxSize = Math.max(0, params.maxSize ?? DEFAULT_THREAD_TS_CACHE_MAX);
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	const getCached = (key, now) => {
+		const entry = cache.get(key);
+		if (!entry) return;
+		if (ttlMs > 0 && now - entry.updatedAt > ttlMs) {
+			cache.delete(key);
+			return;
+		}
+		cache.delete(key);
+		cache.set(key, {
+			...entry,
+			updatedAt: now
+		});
+		return entry.threadTs;
+	};
+	const setCached = (key, threadTs, now) => {
+		cache.delete(key);
+		cache.set(key, {
+			threadTs,
+			updatedAt: now
+		});
+		pruneMapToMaxSize(cache, maxSize);
+	};
+	return { resolve: async (request) => {
+		const { message } = request;
+		if (!message.parent_user_id || message.thread_ts || !message.ts) return message;
+		const cacheKey = `${message.channel}:${message.ts}`;
+		const cached = getCached(cacheKey, Date.now());
+		if (cached !== void 0) return cached ? {
+			...message,
+			thread_ts: cached
+		} : message;
+		if (shouldLogVerbose()) logVerbose(`slack inbound: missing thread_ts for thread reply channel=${message.channel} ts=${message.ts} source=${request.source}`);
+		let pending = inflight.get(cacheKey);
+		if (!pending) {
+			pending = resolveThreadTsFromHistory({
+				client: params.client,
+				channelId: message.channel,
+				messageTs: message.ts
+			});
+			inflight.set(cacheKey, pending);
+		}
+		let resolved;
+		try {
+			resolved = await pending;
+		} finally {
+			inflight.delete(cacheKey);
+		}
+		setCached(cacheKey, resolved ?? null, Date.now());
+		if (resolved) {
+			if (shouldLogVerbose()) logVerbose(`slack inbound: resolved missing thread_ts channel=${message.channel} ts=${message.ts} -> thread_ts=${resolved}`);
+			return {
+				...message,
+				thread_ts: resolved
+			};
+		}
+		if (shouldLogVerbose()) logVerbose(`slack inbound: could not resolve missing thread_ts channel=${message.channel} ts=${message.ts}`);
+		return message;
+	} };
+}
+
+//#endregion
+//#region src/slack/monitor/message-handler.ts
+function createSlackMessageHandler(params) {
+	const { ctx, account } = params;
+	const debounceMs = resolveInboundDebounceMs({
+		cfg: ctx.cfg,
+		channel: "slack"
+	});
+	const threadTsResolver = createSlackThreadTsResolver({ client: ctx.app.client });
+	const debouncer = createInboundDebouncer({
+		debounceMs,
+		buildKey: (entry) => {
+			const senderId = entry.message.user ?? entry.message.bot_id;
+			if (!senderId) return null;
+			const messageTs = entry.message.ts ?? entry.message.event_ts;
+			const threadKey = entry.message.thread_ts ? `${entry.message.channel}:${entry.message.thread_ts}` : entry.message.parent_user_id && messageTs ? `${entry.message.channel}:maybe-thread:${messageTs}` : entry.message.channel;
+			return `slack:${ctx.accountId}:${threadKey}:${senderId}`;
+		},
+		shouldDebounce: (entry) => {
+			const text = entry.message.text ?? "";
+			if (!text.trim()) return false;
+			if (entry.message.files && entry.message.files.length > 0) return false;
+			return !hasControlCommand(stripSlackMentionsForCommandDetection(text), ctx.cfg);
+		},
+		onFlush: async (entries) => {
+			const last = entries.at(-1);
+			if (!last) return;
+			const combinedText = entries.length === 1 ? last.message.text ?? "" : entries.map((entry) => entry.message.text ?? "").filter(Boolean).join("\n");
+			const combinedMentioned = entries.some((entry) => Boolean(entry.opts.wasMentioned));
+			const prepared = await prepareSlackMessage({
+				ctx,
+				account,
+				message: {
+					...last.message,
+					text: combinedText
+				},
+				opts: {
+					...last.opts,
+					wasMentioned: combinedMentioned || last.opts.wasMentioned
+				}
+			});
+			if (!prepared) return;
+			if (entries.length > 1) {
+				const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
+				if (ids.length > 0) {
+					prepared.ctxPayload.MessageSids = ids;
+					prepared.ctxPayload.MessageSidFirst = ids[0];
+					prepared.ctxPayload.MessageSidLast = ids[ids.length - 1];
+				}
+			}
+			await dispatchPreparedSlackMessage(prepared);
+		},
+		onError: (err) => {
+			ctx.runtime.error?.(`slack inbound debounce flush failed: ${String(err)}`);
+		}
+	});
+	return async (message, opts) => {
+		if (opts.source === "message" && message.type !== "message") return;
+		if (opts.source === "message" && message.subtype && message.subtype !== "file_share" && message.subtype !== "bot_message") return;
+		if (ctx.markMessageSeen(message.channel, message.ts)) return;
+		const resolvedMessage = await threadTsResolver.resolve({
+			message,
+			source: opts.source
+		});
+		await debouncer.enqueue({
+			message: resolvedMessage,
+			opts
+		});
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/external-arg-menu-store.ts
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES = 18;
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_LENGTH = Math.ceil(SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES * 8 / 6);
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN = new RegExp(`^[A-Za-z0-9_-]{${SLACK_EXTERNAL_ARG_MENU_TOKEN_LENGTH}}$`);
+const SLACK_EXTERNAL_ARG_MENU_TTL_MS = 600 * 1e3;
+const SLACK_EXTERNAL_ARG_MENU_PREFIX = "fased_cmdarg_ext:";
+function pruneSlackExternalArgMenuStore(store, now) {
+	for (const [token, entry] of store.entries()) if (entry.expiresAt <= now) store.delete(token);
+}
+function createSlackExternalArgMenuToken(store) {
+	let token = "";
+	do
+		token = generateSecureToken(SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES);
+	while (store.has(token));
+	return token;
+}
+function createSlackExternalArgMenuStore() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		create(params, now = Date.now()) {
+			pruneSlackExternalArgMenuStore(store, now);
+			const token = createSlackExternalArgMenuToken(store);
+			store.set(token, {
+				choices: params.choices,
+				userId: params.userId,
+				expiresAt: now + SLACK_EXTERNAL_ARG_MENU_TTL_MS
+			});
+			return token;
+		},
+		readToken(raw) {
+			if (typeof raw !== "string" || !raw.startsWith(SLACK_EXTERNAL_ARG_MENU_PREFIX)) return;
+			const token = raw.slice(17).trim();
+			return SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN.test(token) ? token : void 0;
+		},
+		get(token, now = Date.now()) {
+			pruneSlackExternalArgMenuStore(store, now);
+			return store.get(token);
+		}
+	};
+}
+
+//#endregion
+//#region src/slack/monitor/slash.ts
+const SLACK_COMMAND_ARG_ACTION_ID = "fased_cmdarg";
+const SLACK_COMMAND_ARG_VALUE_PREFIX = "cmdarg";
+const SLACK_COMMAND_ARG_BUTTON_ROW_SIZE = 5;
+const SLACK_COMMAND_ARG_OVERFLOW_MIN = 3;
+const SLACK_COMMAND_ARG_OVERFLOW_MAX = 5;
+const SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX = 100;
+const SLACK_COMMAND_ARG_SELECT_OPTION_VALUE_MAX = 75;
+const SLACK_HEADER_TEXT_MAX = 150;
+const slackExternalArgMenuStore = createSlackExternalArgMenuStore();
+function truncatePlainText(value, max) {
+	const trimmed = value.trim();
+	if (trimmed.length <= max) return trimmed;
+	if (max <= 1) return trimmed.slice(0, max);
+	return `${trimmed.slice(0, max - 1)}…`;
+}
+function buildSlackArgMenuConfirm(params) {
+	return {
+		title: {
+			type: "plain_text",
+			text: "Confirm selection"
+		},
+		text: {
+			type: "mrkdwn",
+			text: `Run */${escapeSlackMrkdwn(params.command)}* with *${escapeSlackMrkdwn(params.arg)}* set to this value?`
+		},
+		confirm: {
+			type: "plain_text",
+			text: "Run command"
+		},
+		deny: {
+			type: "plain_text",
+			text: "Cancel"
+		}
+	};
+}
+function storeSlackExternalArgMenu(params) {
+	return slackExternalArgMenuStore.create({
+		choices: params.choices,
+		userId: params.userId
+	});
+}
+function readSlackExternalArgMenuToken(raw) {
+	return slackExternalArgMenuStore.readToken(raw);
+}
+let commandsRegistry;
+async function getCommandsRegistry() {
+	if (!commandsRegistry) commandsRegistry = await import("./commands-registry-DwQIFJmL.js").then((n) => n.n);
+	return commandsRegistry;
+}
+function encodeSlackCommandArgValue(parts) {
+	return [
+		SLACK_COMMAND_ARG_VALUE_PREFIX,
+		encodeURIComponent(parts.command),
+		encodeURIComponent(parts.arg),
+		encodeURIComponent(parts.value),
+		encodeURIComponent(parts.userId)
+	].join("|");
+}
+function parseSlackCommandArgValue(raw) {
+	if (!raw) return null;
+	const parts = raw.split("|");
+	if (parts.length !== 5 || parts[0] !== SLACK_COMMAND_ARG_VALUE_PREFIX) return null;
+	const [, command, arg, value, userId] = parts;
+	if (!command || !arg || !value || !userId) return null;
+	const decode = (text) => {
+		try {
+			return decodeURIComponent(text);
+		} catch {
+			return null;
+		}
+	};
+	const decodedCommand = decode(command);
+	const decodedArg = decode(arg);
+	const decodedValue = decode(value);
+	const decodedUserId = decode(userId);
+	if (!decodedCommand || !decodedArg || !decodedValue || !decodedUserId) return null;
+	return {
+		command: decodedCommand,
+		arg: decodedArg,
+		value: decodedValue,
+		userId: decodedUserId
+	};
+}
+function buildSlackArgMenuOptions(choices) {
+	return choices.map((choice) => ({
+		text: {
+			type: "plain_text",
+			text: choice.label.slice(0, 75)
+		},
+		value: choice.value
+	}));
+}
+function buildSlackCommandArgMenuBlocks(params) {
+	const encodedChoices = params.choices.map((choice) => ({
+		label: choice.label,
+		value: encodeSlackCommandArgValue({
+			command: params.command,
+			arg: params.arg,
+			value: choice.value,
+			userId: params.userId
+		})
+	}));
+	const canUseStaticSelect = encodedChoices.every((choice) => choice.value.length <= SLACK_COMMAND_ARG_SELECT_OPTION_VALUE_MAX);
+	const canUseOverflow = canUseStaticSelect && encodedChoices.length >= SLACK_COMMAND_ARG_OVERFLOW_MIN && encodedChoices.length <= SLACK_COMMAND_ARG_OVERFLOW_MAX;
+	const canUseExternalSelect = params.supportsExternalSelect && canUseStaticSelect && encodedChoices.length > SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX;
+	const rows = canUseOverflow ? [{
+		type: "actions",
+		elements: [{
+			type: "overflow",
+			action_id: SLACK_COMMAND_ARG_ACTION_ID,
+			confirm: buildSlackArgMenuConfirm({
+				command: params.command,
+				arg: params.arg
+			}),
+			options: buildSlackArgMenuOptions(encodedChoices)
+		}]
+	}] : canUseExternalSelect ? [{
+		type: "actions",
+		block_id: `${SLACK_EXTERNAL_ARG_MENU_PREFIX}${params.createExternalMenuToken(encodedChoices)}`,
+		elements: [{
+			type: "external_select",
+			action_id: SLACK_COMMAND_ARG_ACTION_ID,
+			confirm: buildSlackArgMenuConfirm({
+				command: params.command,
+				arg: params.arg
+			}),
+			min_query_length: 0,
+			placeholder: {
+				type: "plain_text",
+				text: `Search ${params.arg}`
+			}
+		}]
+	}] : encodedChoices.length <= SLACK_COMMAND_ARG_BUTTON_ROW_SIZE || !canUseStaticSelect ? chunkItems(encodedChoices, SLACK_COMMAND_ARG_BUTTON_ROW_SIZE).map((choices) => ({
+		type: "actions",
+		elements: choices.map((choice) => ({
+			type: "button",
+			action_id: SLACK_COMMAND_ARG_ACTION_ID,
+			text: {
+				type: "plain_text",
+				text: choice.label
+			},
+			value: choice.value,
+			confirm: buildSlackArgMenuConfirm({
+				command: params.command,
+				arg: params.arg
+			})
+		}))
+	})) : chunkItems(encodedChoices, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX).map((choices, index) => ({
+		type: "actions",
+		elements: [{
+			type: "static_select",
+			action_id: SLACK_COMMAND_ARG_ACTION_ID,
+			confirm: buildSlackArgMenuConfirm({
+				command: params.command,
+				arg: params.arg
+			}),
+			placeholder: {
+				type: "plain_text",
+				text: index === 0 ? `Choose ${params.arg}` : `Choose ${params.arg} (${index + 1})`
+			},
+			options: buildSlackArgMenuOptions(choices)
+		}]
+	}));
+	const headerText = truncatePlainText(`/${params.command}: choose ${params.arg}`, SLACK_HEADER_TEXT_MAX);
+	const sectionText = truncatePlainText(params.title, 3e3);
+	const contextText = truncatePlainText(`Select one option to continue /${params.command} (${params.arg})`, 3e3);
+	return [
+		{
+			type: "header",
+			text: {
+				type: "plain_text",
+				text: headerText
+			}
+		},
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: sectionText
+			}
+		},
+		{
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: contextText
+			}]
+		},
+		...rows
+	];
+}
+async function registerSlackMonitorSlashCommands(params) {
+	const { ctx, account } = params;
+	const cfg = ctx.cfg;
+	const runtime = ctx.runtime;
+	const supportsInteractiveArgMenus = typeof ctx.app.action === "function";
+	const supportsExternalArgMenus = typeof ctx.app.options === "function";
+	const slashCommand = resolveSlackSlashCommandConfig(ctx.slashCommand ?? account.config.slashCommand);
+	const handleSlashCommand = async (p) => {
+		const { command, ack, respond, prompt, commandArgs, commandDefinition } = p;
+		try {
+			if (!prompt.trim()) {
+				await ack({
+					text: "Message required.",
+					response_type: "ephemeral"
+				});
+				return;
+			}
+			await ack();
+			if (ctx.botUserId && command.user_id === ctx.botUserId) return;
+			const channelInfo = await ctx.resolveChannelName(command.channel_id);
+			const channelType = normalizeSlackChannelType(channelInfo?.type ?? (command.channel_name === "directmessage" ? "im" : void 0), command.channel_id);
+			const isDirectMessage = channelType === "im";
+			const isGroupDm = channelType === "mpim";
+			const isRoom = channelType === "channel" || channelType === "group";
+			const isRoomish = isRoom || isGroupDm;
+			if (!ctx.isChannelAllowed({
+				channelId: command.channel_id,
+				channelName: channelInfo?.name,
+				channelType
+			})) {
+				await respond({
+					text: "This channel is not allowed.",
+					response_type: "ephemeral"
+				});
+				return;
+			}
+			const { allowFromLower: effectiveAllowFromLower } = await resolveSlackEffectiveAllowFrom(ctx, { includePairingStore: isDirectMessage });
+			let commandAuthorized = false;
+			let channelConfig = null;
+			if (isDirectMessage) {
+				if (!await authorizeSlackDirectMessage({
+					ctx,
+					accountId: ctx.accountId,
+					senderId: command.user_id,
+					allowFromLower: effectiveAllowFromLower,
+					resolveSenderName: ctx.resolveUserName,
+					sendPairingReply: async (text) => {
+						await respond({
+							text,
+							response_type: "ephemeral"
+						});
+					},
+					onDisabled: async () => {
+						await respond({
+							text: "Slack DMs are disabled.",
+							response_type: "ephemeral"
+						});
+					},
+					onUnauthorized: async ({ allowMatchMeta }) => {
+						logVerbose(`slack: blocked slash sender ${command.user_id} (dmPolicy=${ctx.dmPolicy}, ${allowMatchMeta})`);
+						await respond({
+							text: "You are not authorized to use this command.",
+							response_type: "ephemeral"
+						});
+					},
+					log: logVerbose
+				})) return;
+			}
+			if (isRoom) {
+				channelConfig = resolveSlackChannelConfig({
+					channelId: command.channel_id,
+					channelName: channelInfo?.name,
+					channels: ctx.channelsConfig,
+					defaultRequireMention: ctx.defaultRequireMention
+				});
+				if (ctx.useAccessGroups) {
+					const channelAllowlistConfigured = Boolean(ctx.channelsConfig) && Object.keys(ctx.channelsConfig ?? {}).length > 0;
+					const channelAllowed = channelConfig?.allowed !== false;
+					if (!isSlackChannelAllowedByPolicy({
+						groupPolicy: ctx.groupPolicy,
+						channelAllowlistConfigured,
+						channelAllowed
+					})) {
+						await respond({
+							text: "This channel is not allowed.",
+							response_type: "ephemeral"
+						});
+						return;
+					}
+					const hasExplicitConfig = Boolean(channelConfig?.matchSource);
+					if (!channelAllowed && (ctx.groupPolicy !== "open" || hasExplicitConfig)) {
+						await respond({
+							text: "This channel is not allowed.",
+							response_type: "ephemeral"
+						});
+						return;
+					}
+				}
+			}
+			const senderName = (await ctx.resolveUserName(command.user_id))?.name ?? command.user_name ?? command.user_id;
+			const channelUsersAllowlistConfigured = isRoom && Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
+			const channelUserAllowed = channelUsersAllowlistConfigured ? resolveSlackUserAllowed({
+				allowList: channelConfig?.users,
+				userId: command.user_id,
+				userName: senderName,
+				allowNameMatching: ctx.allowNameMatching
+			}) : false;
+			if (channelUsersAllowlistConfigured && !channelUserAllowed) {
+				await respond({
+					text: "You are not authorized to use this command here.",
+					response_type: "ephemeral"
+				});
+				return;
+			}
+			const ownerAllowed = resolveSlackAllowListMatch({
+				allowList: effectiveAllowFromLower,
+				id: command.user_id,
+				name: senderName,
+				allowNameMatching: ctx.allowNameMatching
+			}).allowed;
+			commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
+				useAccessGroups: ctx.useAccessGroups,
+				authorizers: [{
+					configured: effectiveAllowFromLower.length > 0,
+					allowed: ownerAllowed
+				}],
+				modeWhenAccessGroupsOff: "configured"
+			});
+			if (isRoomish) {
+				commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
+					useAccessGroups: ctx.useAccessGroups,
+					authorizers: [{
+						configured: effectiveAllowFromLower.length > 0,
+						allowed: ownerAllowed
+					}, {
+						configured: channelUsersAllowlistConfigured,
+						allowed: channelUserAllowed
+					}],
+					modeWhenAccessGroupsOff: "configured"
+				});
+				if (ctx.useAccessGroups && !commandAuthorized) {
+					await respond({
+						text: "You are not authorized to use this command.",
+						response_type: "ephemeral"
+					});
+					return;
+				}
+			}
+			if (commandDefinition && supportsInteractiveArgMenus) {
+				const menu = (await getCommandsRegistry()).resolveCommandArgMenu({
+					command: commandDefinition,
+					args: commandArgs,
+					cfg
+				});
+				if (menu) {
+					const commandLabel = commandDefinition.nativeName ?? commandDefinition.key;
+					const title = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${commandLabel}.`;
+					await respond({
+						text: title,
+						blocks: buildSlackCommandArgMenuBlocks({
+							title,
+							command: commandLabel,
+							arg: menu.arg.name,
+							choices: menu.choices,
+							userId: command.user_id,
+							supportsExternalSelect: supportsExternalArgMenus,
+							createExternalMenuToken: (choices) => storeSlackExternalArgMenu({
+								choices,
+								userId: command.user_id
+							})
+						}),
+						response_type: "ephemeral"
+					});
+					return;
+				}
+			}
+			const channelName = channelInfo?.name;
+			const roomLabel = channelName ? `#${channelName}` : `#${command.channel_id}`;
+			const [{ resolveAgentRoute }, { finalizeInboundContext }, { dispatchReplyWithDispatcher }] = await Promise.all([
+				import("./resolve-route-wp5xq4Ws.js").then((n) => n.r),
+				import("./inbound-context-BNCTzgjG.js").then((n) => n.n),
+				import("./pi-embedded-runner-DMfkIj60.js").then((n) => n.B)
+			]);
+			const [{ resolveConversationLabel }, { createReplyPrefixOptions }, { recordSessionMetaFromInbound, resolveStorePath }] = await Promise.all([
+				import("./conversation-label-BoVqak2R.js").then((n) => n.t),
+				import("./reply-prefix-CbPHNXlm.js").then((n) => n.r),
+				import("./runtime-BUpqjZNM.js").then((n) => n.m)
+			]);
+			const route = resolveAgentRoute({
+				cfg,
+				channel: "slack",
+				accountId: account.accountId,
+				teamId: ctx.teamId || void 0,
+				peer: {
+					kind: isDirectMessage ? "direct" : isRoom ? "channel" : "group",
+					id: isDirectMessage ? command.user_id : command.channel_id
+				}
+			});
+			const { untrustedChannelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
+				isRoomish,
+				channelInfo,
+				channelConfig
+			});
+			const ctxPayload = finalizeInboundContext({
+				Body: prompt,
+				BodyForAgent: prompt,
+				RawBody: prompt,
+				CommandBody: prompt,
+				CommandArgs: commandArgs,
+				From: isDirectMessage ? `slack:${command.user_id}` : isRoom ? `slack:channel:${command.channel_id}` : `slack:group:${command.channel_id}`,
+				To: `slash:${command.user_id}`,
+				ChatType: isDirectMessage ? "direct" : "channel",
+				ConversationLabel: resolveConversationLabel({
+					ChatType: isDirectMessage ? "direct" : "channel",
+					SenderName: senderName,
+					GroupSubject: isRoomish ? roomLabel : void 0,
+					From: isDirectMessage ? `slack:${command.user_id}` : isRoom ? `slack:channel:${command.channel_id}` : `slack:group:${command.channel_id}`
+				}) ?? (isDirectMessage ? senderName : roomLabel),
+				GroupSubject: isRoomish ? roomLabel : void 0,
+				GroupSystemPrompt: isRoomish ? groupSystemPrompt : void 0,
+				UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
+				SenderName: senderName,
+				SenderId: command.user_id,
+				Provider: "slack",
+				Surface: "slack",
+				WasMentioned: true,
+				MessageSid: command.trigger_id,
+				Timestamp: Date.now(),
+				SessionKey: `agent:${route.agentId}:${slashCommand.sessionPrefix}:${command.user_id}`.toLowerCase(),
+				CommandTargetSessionKey: route.sessionKey,
+				AccountId: route.accountId,
+				CommandSource: "native",
+				CommandAuthorized: commandAuthorized,
+				OriginatingChannel: "slack",
+				OriginatingTo: `user:${command.user_id}`
+			});
+			const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+			try {
+				await recordSessionMetaFromInbound({
+					storePath,
+					sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+					ctx: ctxPayload
+				});
+			} catch (err) {
+				runtime.error?.(danger(`slack slash: failed updating session meta: ${String(err)}`));
+			}
+			const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+				cfg,
+				agentId: route.agentId,
+				channel: "slack",
+				accountId: route.accountId
+			});
+			const deliverSlashPayloads = async (replies) => {
+				const [{ deliverSlackSlashReplies }, { resolveChunkMode }, { resolveMarkdownTableMode }] = await Promise.all([
+					import("./replies-BPFt4O-j.js").then((n) => n.r),
+					import("./chunk-CuJIMshx.js").then((n) => n.s),
+					import("./markdown-tables-DrB-IM8r.js").then((n) => n.t)
+				]);
+				await deliverSlackSlashReplies({
+					replies,
+					respond,
+					ephemeral: slashCommand.ephemeral,
+					textLimit: ctx.textLimit,
+					chunkMode: resolveChunkMode(cfg, "slack", route.accountId),
+					tableMode: resolveMarkdownTableMode({
+						cfg,
+						channel: "slack",
+						accountId: route.accountId
+					})
+				});
+			};
+			const { counts } = await dispatchReplyWithDispatcher({
+				ctx: ctxPayload,
+				cfg,
+				dispatcherOptions: {
+					...prefixOptions,
+					deliver: async (payload) => deliverSlashPayloads([payload]),
+					onError: (err, info) => {
+						runtime.error?.(danger(`slack slash ${info.kind} reply failed: ${String(err)}`));
+					}
+				},
+				replyOptions: {
+					skillFilter: channelConfig?.skills,
+					onModelSelected
+				}
+			});
+			if (counts.final + counts.tool + counts.block === 0) await deliverSlashPayloads([]);
+		} catch (err) {
+			runtime.error?.(danger(`slack slash handler failed: ${String(err)}`));
+			await respond({
+				text: "Sorry, something went wrong handling that command.",
+				response_type: "ephemeral"
+			});
+		}
+	};
+	const nativeEnabled = resolveNativeCommandsEnabled({
+		providerId: "slack",
+		providerSetting: account.config.commands?.native,
+		globalSetting: cfg.commands?.native
+	});
+	const nativeSkillsEnabled = resolveNativeSkillsEnabled({
+		providerId: "slack",
+		providerSetting: account.config.commands?.nativeSkills,
+		globalSetting: cfg.commands?.nativeSkills
+	});
+	let reg;
+	let nativeCommands = [];
+	if (nativeEnabled) {
+		reg = await getCommandsRegistry();
+		const skillCommands = nativeSkillsEnabled ? (await import("./skill-commands-DCnCOVR_.js").then((n) => n.a)).listSkillCommandsForAgents({ cfg }) : [];
+		nativeCommands = reg.listNativeCommandSpecsForConfig(cfg, {
+			skillCommands,
+			provider: "slack"
+		});
+	}
+	if (nativeCommands.length > 0) {
+		const registry = reg;
+		if (!registry) throw new Error("Missing commands registry for native Slack commands.");
+		for (const command of nativeCommands) ctx.app.command(`/${command.name}`, async ({ command: cmd, ack, respond }) => {
+			const commandDefinition = registry.findCommandByNativeName(command.name, "slack");
+			const rawText = cmd.text?.trim() ?? "";
+			const commandArgs = commandDefinition ? registry.parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
+			await handleSlashCommand({
+				command: cmd,
+				ack,
+				respond,
+				prompt: commandDefinition ? registry.buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`,
+				commandArgs,
+				commandDefinition: commandDefinition ?? void 0
+			});
+		});
+	} else if (slashCommand.enabled) ctx.app.command(buildSlackSlashCommandMatcher(slashCommand.name), async ({ command, ack, respond }) => {
+		await handleSlashCommand({
+			command,
+			ack,
+			respond,
+			prompt: command.text?.trim() ?? ""
+		});
+	});
+	else logVerbose("slack: slash commands disabled");
+	if (nativeCommands.length === 0 || !supportsInteractiveArgMenus) return;
+	const registerArgOptions = () => {
+		const appWithOptions = ctx.app;
+		if (typeof appWithOptions.options !== "function") return;
+		appWithOptions.options(SLACK_COMMAND_ARG_ACTION_ID, async ({ ack, body }) => {
+			const typedBody = body;
+			const token = readSlackExternalArgMenuToken(typedBody.actions?.[0]?.block_id ?? typedBody.block_id);
+			if (!token) {
+				await ack({ options: [] });
+				return;
+			}
+			const entry = slackExternalArgMenuStore.get(token);
+			if (!entry) {
+				await ack({ options: [] });
+				return;
+			}
+			const requesterUserId = typedBody.user?.id?.trim();
+			if (!requesterUserId || requesterUserId !== entry.userId) {
+				await ack({ options: [] });
+				return;
+			}
+			const query = typedBody.value?.trim().toLowerCase() ?? "";
+			await ack({ options: entry.choices.filter((choice) => !query || choice.label.toLowerCase().includes(query)).slice(0, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX).map((choice) => ({
+				text: {
+					type: "plain_text",
+					text: choice.label.slice(0, 75)
+				},
+				value: choice.value
+			})) });
+		});
+	};
+	registerArgOptions();
+	const registerArgAction = (actionId) => {
+		ctx.app.action(actionId, async (args) => {
+			const { ack, body, respond } = args;
+			const action = args.action;
+			await ack();
+			const respondFn = respond ?? (async (payload) => {
+				if (!body.channel?.id || !body.user?.id) return;
+				await ctx.app.client.chat.postEphemeral({
+					token: ctx.botToken,
+					channel: body.channel.id,
+					user: body.user.id,
+					text: payload.text,
+					blocks: payload.blocks
+				});
+			});
+			const parsed = parseSlackCommandArgValue(action?.value ?? action?.selected_option?.value);
+			if (!parsed) {
+				await respondFn({
+					text: "Sorry, that button is no longer valid.",
+					response_type: "ephemeral"
+				});
+				return;
+			}
+			if (body.user?.id && parsed.userId !== body.user.id) {
+				await respondFn({
+					text: "That menu is for another user.",
+					response_type: "ephemeral"
+				});
+				return;
+			}
+			const reg = await getCommandsRegistry();
+			const commandDefinition = reg.findCommandByNativeName(parsed.command, "slack");
+			const commandArgs = { values: { [parsed.arg]: parsed.value } };
+			const prompt = commandDefinition ? reg.buildCommandTextFromArgs(commandDefinition, commandArgs) : `/${parsed.command} ${parsed.value}`;
+			const user = body.user;
+			const userName = user && "name" in user && user.name ? user.name : user && "username" in user && user.username ? user.username : user?.id ?? "";
+			const triggerId = "trigger_id" in body ? body.trigger_id : void 0;
+			await handleSlashCommand({
+				command: {
+					user_id: user?.id ?? "",
+					user_name: userName,
+					channel_id: body.channel?.id ?? "",
+					channel_name: body.channel?.name ?? body.channel?.id ?? "",
+					trigger_id: triggerId
+				},
+				ack: async () => {},
+				respond: respondFn,
+				prompt,
+				commandArgs,
+				commandDefinition: commandDefinition ?? void 0
+			});
+		});
+	};
+	registerArgAction(SLACK_COMMAND_ARG_ACTION_ID);
+}
+
+//#endregion
+//#region src/slack/monitor/provider.ts
+const slackBoltModule = SlackBolt;
+const { App, HTTPReceiver } = (slackBoltModule.App ? slackBoltModule : slackBoltModule.default) ?? slackBoltModule;
+const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
+const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
+function parseApiAppIdFromAppToken(raw) {
+	const token = raw?.trim();
+	if (!token) return;
+	return /^xapp-\d-([a-z0-9]+)-/i.exec(token)?.[1]?.toUpperCase();
+}
+async function monitorSlackProvider(opts = {}) {
+	const cfg = opts.config ?? loadConfig();
+	let account = resolveSlackAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const historyLimit = Math.max(0, account.config.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+	const sessionCfg = cfg.session;
+	const sessionScope = sessionCfg?.scope ?? "per-sender";
+	const mainKey = normalizeMainKey(sessionCfg?.mainKey);
+	const slackMode = opts.mode ?? account.config.mode ?? "socket";
+	const slackWebhookPath = normalizeSlackWebhookPath(account.config.webhookPath);
+	const signingSecret = account.config.signingSecret?.trim();
+	const botToken = resolveSlackBotToken(opts.botToken ?? account.botToken);
+	const appToken = resolveSlackAppToken(opts.appToken ?? account.appToken);
+	if (!botToken || slackMode !== "http" && !appToken) {
+		const missing = slackMode === "http" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : `Slack bot + app tokens missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken/appToken or SLACK_BOT_TOKEN/SLACK_APP_TOKEN for default).`;
+		throw new Error(missing);
+	}
+	if (slackMode === "http" && !signingSecret) throw new Error(`Slack signing secret missing for account "${account.accountId}" (set channels.slack.signingSecret or channels.slack.accounts.${account.accountId}.signingSecret).`);
+	const runtime = opts.runtime ?? createNonExitingRuntime();
+	const slackCfg = account.config;
+	const dmConfig = slackCfg.dm;
+	const dmEnabled = dmConfig?.enabled ?? true;
+	const dmPolicy = slackCfg.dmPolicy ?? dmConfig?.policy ?? "pairing";
+	let allowFrom = slackCfg.allowFrom ?? dmConfig?.allowFrom;
+	const groupDmEnabled = dmConfig?.groupEnabled ?? false;
+	const groupDmChannels = dmConfig?.groupChannels;
+	let channelsConfig = slackCfg.channels;
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: cfg.channels?.slack !== void 0,
+		groupPolicy: slackCfg.groupPolicy,
+		defaultGroupPolicy
+	});
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied,
+		providerKey: "slack",
+		accountId: account.accountId,
+		log: (message) => runtime.log?.(warn(message))
+	});
+	const resolveToken = slackCfg.userToken?.trim() || botToken;
+	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const reactionMode = slackCfg.reactionNotifications ?? "own";
+	const reactionAllowlist = slackCfg.reactionAllowlist ?? [];
+	const replyToMode = slackCfg.replyToMode ?? "off";
+	const threadHistoryScope = slackCfg.thread?.historyScope ?? "thread";
+	const threadInheritParent = slackCfg.thread?.inheritParent ?? false;
+	const slashCommand = resolveSlackSlashCommandConfig(opts.slashCommand ?? slackCfg.slashCommand);
+	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId);
+	const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
+	const mediaMaxBytes = (opts.mediaMaxMb ?? slackCfg.mediaMaxMb ?? 20) * 1024 * 1024;
+	const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
+	const receiver = slackMode === "http" ? new HTTPReceiver({
+		signingSecret: signingSecret ?? "",
+		endpoints: slackWebhookPath
+	}) : null;
+	const clientOptions = resolveSlackWebClientOptions();
+	const app = new App(slackMode === "socket" ? {
+		token: botToken,
+		appToken,
+		socketMode: true,
+		clientOptions
+	} : {
+		token: botToken,
+		receiver: receiver ?? void 0,
+		clientOptions
+	});
+	const slackHttpHandler = slackMode === "http" && receiver ? async (req, res) => {
+		const guard = installRequestBodyLimitGuard(req, res, {
+			maxBytes: SLACK_WEBHOOK_MAX_BODY_BYTES,
+			timeoutMs: SLACK_WEBHOOK_BODY_TIMEOUT_MS,
+			responseFormat: "text"
+		});
+		if (guard.isTripped()) return;
+		try {
+			await Promise.resolve(receiver.requestListener(req, res));
+		} catch (err) {
+			if (!guard.isTripped()) throw err;
+		} finally {
+			guard.dispose();
+		}
+	} : null;
+	let unregisterHttpHandler = null;
+	let botUserId = "";
+	let teamId = "";
+	let apiAppId = "";
+	const expectedApiAppIdFromAppToken = parseApiAppIdFromAppToken(appToken);
+	try {
+		const auth = await app.client.auth.test({ token: botToken });
+		botUserId = auth.user_id ?? "";
+		teamId = auth.team_id ?? "";
+		apiAppId = auth.api_app_id ?? "";
+	} catch {}
+	if (apiAppId && expectedApiAppIdFromAppToken && apiAppId !== expectedApiAppIdFromAppToken) runtime.error?.(`slack token mismatch: bot token api_app_id=${apiAppId} but app token looks like api_app_id=${expectedApiAppIdFromAppToken}`);
+	const ctx = createSlackMonitorContext({
+		cfg,
+		accountId: account.accountId,
+		botToken,
+		app,
+		runtime,
+		botUserId,
+		teamId,
+		apiAppId,
+		historyLimit,
+		sessionScope,
+		mainKey,
+		dmEnabled,
+		dmPolicy,
+		allowFrom,
+		allowNameMatching: isDangerousNameMatchingEnabled(slackCfg),
+		groupDmEnabled,
+		groupDmChannels,
+		defaultRequireMention: slackCfg.requireMention,
+		channelsConfig,
+		groupPolicy,
+		useAccessGroups,
+		reactionMode,
+		reactionAllowlist,
+		replyToMode,
+		threadHistoryScope,
+		threadInheritParent,
+		slashCommand,
+		textLimit,
+		ackReactionScope,
+		mediaMaxBytes,
+		removeAckAfterReply
+	});
+	registerSlackMonitorEvents({
+		ctx,
+		account,
+		handleSlackMessage: createSlackMessageHandler({
+			ctx,
+			account
+		})
+	});
+	await registerSlackMonitorSlashCommands({
+		ctx,
+		account
+	});
+	if (slackMode === "http" && slackHttpHandler) unregisterHttpHandler = registerSlackHttpHandler({
+		path: slackWebhookPath,
+		handler: slackHttpHandler,
+		log: runtime.log,
+		accountId: account.accountId
+	});
+	if (resolveToken) (async () => {
+		if (opts.abortSignal?.aborted) return;
+		if (channelsConfig && Object.keys(channelsConfig).length > 0) try {
+			const entries = Object.keys(channelsConfig).filter((key) => key !== "*");
+			if (entries.length > 0) {
+				const resolved = await resolveSlackChannelAllowlist({
+					token: resolveToken,
+					entries
+				});
+				const nextChannels = { ...channelsConfig };
+				const mapping = [];
+				const unresolved = [];
+				for (const entry of resolved) {
+					const source = channelsConfig?.[entry.input];
+					if (!source) continue;
+					if (!entry.resolved || !entry.id) {
+						unresolved.push(entry.input);
+						continue;
+					}
+					mapping.push(`${entry.input}→${entry.id}${entry.archived ? " (archived)" : ""}`);
+					const existing = nextChannels[entry.id] ?? {};
+					nextChannels[entry.id] = {
+						...source,
+						...existing
+					};
+				}
+				channelsConfig = nextChannels;
+				ctx.channelsConfig = nextChannels;
+				summarizeMapping("slack channels", mapping, unresolved, runtime);
+			}
+		} catch (err) {
+			runtime.log?.(`slack channel resolve failed; using config entries. ${String(err)}`);
+		}
+		const allowEntries = allowFrom?.filter((entry) => String(entry).trim() && String(entry).trim() !== "*") ?? [];
+		if (allowEntries.length > 0) try {
+			const { mapping, unresolved, additions } = buildAllowlistResolutionSummary(await resolveSlackUserAllowlist({
+				token: resolveToken,
+				entries: allowEntries.map((entry) => String(entry))
+			}), { formatResolved: (entry) => {
+				const note = entry.note ? ` (${entry.note})` : "";
+				return `${entry.input}→${entry.id}${note}`;
+			} });
+			allowFrom = mergeAllowlist({
+				existing: allowFrom,
+				additions
+			});
+			ctx.allowFrom = normalizeAllowList(allowFrom);
+			summarizeMapping("slack users", mapping, unresolved, runtime);
+		} catch (err) {
+			runtime.log?.(`slack user resolve failed; using config entries. ${String(err)}`);
+		}
+		if (channelsConfig && Object.keys(channelsConfig).length > 0) {
+			const userEntries = /* @__PURE__ */ new Set();
+			for (const channel of Object.values(channelsConfig)) addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
+			if (userEntries.size > 0) try {
+				const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(await resolveSlackUserAllowlist({
+					token: resolveToken,
+					entries: Array.from(userEntries)
+				}));
+				const nextChannels = patchAllowlistUsersInConfigEntries({
+					entries: channelsConfig,
+					resolvedMap
+				});
+				channelsConfig = nextChannels;
+				ctx.channelsConfig = nextChannels;
+				summarizeMapping("slack channel users", mapping, unresolved, runtime);
+			} catch (err) {
+				runtime.log?.(`slack channel user resolve failed; using config entries. ${String(err)}`);
+			}
+		}
+	})();
+	const stopOnAbort = () => {
+		if (opts.abortSignal?.aborted && slackMode === "socket") app.stop();
+	};
+	opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+	try {
+		if (slackMode === "socket") {
+			await app.start();
+			runtime.log?.("slack socket mode connected");
+		} else runtime.log?.(`slack http mode listening at ${slackWebhookPath}`);
+		if (opts.abortSignal?.aborted) return;
+		await new Promise((resolve) => {
+			opts.abortSignal?.addEventListener("abort", () => resolve(), { once: true });
+		});
+	} finally {
+		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+		unregisterHttpHandler?.();
+		await app.stop().catch(() => void 0);
+	}
+}
+
+//#endregion
+export { monitorSlackProvider };