@openclaw/slack 2026.7.2-beta.7 → 2026.7.34

package/dist/.setup/provider-Bjv1R5E2.mjs

@@ -0,0 +1,4720 @@
+import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.mjs";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as formatSlackBotTokenIdentityWarning } from "./accounts-uGn8E6uq.mjs";
+import { B as isSlackExecApprovalAuthorizedSender, D as isSlackAnyNativeApprovalClientEnabled, R as isSlackApprovalAuthorizedSender, a as SLACK_TEXT_LIMIT, b as truncateSlackText, c as formatSlackError, d as normalizeAllowListLower, f as normalizeSlackAllowOwnerEntry, l as allowListMatches, m as resolveSlackAllowListMatch, p as normalizeSlackSlug, u as normalizeAllowList } from "./reply-blocks-Cwu6LYJI.mjs";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-BLw4HEPS.mjs";
+import { c as resolveSlackWebClientOptions } from "./client-B6i83rHk.mjs";
+import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.mjs";
+import { i as setSlackDefaultSendIdentity } from "./send-DEOvcVM4.mjs";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CivvCeZv.mjs";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-D5Qb64BJ.mjs";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-C6VVHqUf.mjs";
+import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeStringEntriesLower, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeAccountId, normalizeMainKey, resolveAgentRoute, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
+import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
+import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { computeBackoff, createNonExitingRuntime, createSubsystemLogger, danger, getChildLogger, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
+import { chunkItems } from "openclaw/plugin-sdk/text-chunking";
+import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { parseExecApprovalCommandText } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
+import { createDedupeCache, createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
+import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, recordInboundSession, resolveConversationLabel as resolveConversationLabel$1, resolvePluginConversationBindingApproval, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
+import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
+import { DEFAULT_GROUP_HISTORY_LIMIT } from "openclaw/plugin-sdk/reply-history";
+import { installRequestBodyLimitGuard } from "openclaw/plugin-sdk/webhook-request-guards";
+import { getRuntimeConfig, getRuntimeConfig as getRuntimeConfig$1, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { getSessionEntry, readSessionUpdatedAt, resolveChannelResetConfig, resolveSessionKey, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
+import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy as resolveOpenProviderRuntimeGroupPolicy$1, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { loadModelCatalog, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
+import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
+import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
+import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
+import { formatCommandArgMenuTitle, resolveCommandAuthorization, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride } from "openclaw/plugin-sdk/command-auth-native";
+import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
+import { createInteractiveConversationBindingHelpers, dispatchPluginInteractiveHandler } from "openclaw/plugin-sdk/plugin-runtime";
+import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
+import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
+import { buildUntrustedChannelMetadata } from "openclaw/plugin-sdk/security-runtime";
+//#region extensions/slack/src/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(normalizeOptionalString(raw?.name) ?? "openclaw") || "openclaw";
+	return {
+		enabled: raw?.enabled === true,
+		name,
+		sessionPrefix: normalizeOptionalString(raw?.sessionPrefix) ?? "slack:slash",
+		ephemeral: raw?.ephemeral !== false
+	};
+}
+function buildSlackSlashCommandMatcher(name) {
+	const escaped = normalizeSlackSlashCommandName(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`^/?${escaped}$`);
+}
+//#endregion
+//#region extensions/slack/src/monitor/channel-type.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 = normalizeOptionalLowercaseString(channelType);
+	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 resolveSlackChatType(channelType) {
+	if (channelType === "im") return "direct";
+	if (channelType === "mpim") return "group";
+	return "channel";
+}
+//#endregion
+//#region extensions/slack/src/monitor/context.ts
+const SLACK_ASSISTANT_THREAD_CONTEXT_METADATA_EVENT = "assistant_thread_context";
+function buildSlackAssistantThreadMetadata(context) {
+	const eventPayload = {};
+	if (context.channelId) eventPayload.channel_id = context.channelId;
+	if (context.teamId) eventPayload.team_id = context.teamId;
+	if (context.enterpriseId) eventPayload.enterprise_id = context.enterpriseId;
+	return {
+		event_type: SLACK_ASSISTANT_THREAD_CONTEXT_METADATA_EVENT,
+		event_payload: eventPayload
+	};
+}
+function parseSlackAssistantThreadMetadata(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const metadata = value;
+	if (metadata.event_type !== SLACK_ASSISTANT_THREAD_CONTEXT_METADATA_EVENT) return;
+	const payload = metadata.event_payload;
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
+	const record = payload;
+	const stringField = (key) => {
+		const raw = record[key];
+		return typeof raw === "string" && raw.trim() ? raw.trim() : void 0;
+	};
+	return {
+		channelId: stringField("channel_id"),
+		teamId: stringField("team_id"),
+		enterpriseId: stringField("enterprise_id")
+	};
+}
+const SLACK_ASSISTANT_CONTEXT_TTL_MS = 864e5;
+const SLACK_ASSISTANT_CONTEXT_CLEANUP_INTERVAL_MS = 6e5;
+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 assistantThreadContexts = /* @__PURE__ */ new Map();
+	let lastAssistantContextCleanupAt = Date.now();
+	const allowFrom = normalizeAllowList(params.allowFrom);
+	const groupDmChannels = normalizeAllowList(params.groupDmChannels);
+	const groupDmChannelsLower = normalizeAllowListLower(groupDmChannels);
+	const defaultRequireMention = params.defaultRequireMention ?? true;
+	const hasChannelAllowlistConfig = Object.keys(params.channelsConfig ?? {}).length > 0;
+	const channelsConfigKeys = Object.keys(params.channelsConfig ?? {});
+	const markMessageSeen = (channelId, ts) => {
+		if (!channelId || !ts) return false;
+		return seenMessages.check(`${channelId}:${ts}`);
+	};
+	const releaseSeenMessage = (channelId, ts) => {
+		if (!channelId || !ts) return;
+		seenMessages.delete(`${channelId}:${ts}`);
+	};
+	const assistantContextKey = (channelId, threadTs) => `${channelId}:${threadTs}`;
+	const cleanupAssistantThreadContexts = () => {
+		const now = Date.now();
+		if (now - lastAssistantContextCleanupAt < SLACK_ASSISTANT_CONTEXT_CLEANUP_INTERVAL_MS) return;
+		lastAssistantContextCleanupAt = now;
+		const cutoff = now - SLACK_ASSISTANT_CONTEXT_TTL_MS;
+		for (const [key, entry] of assistantThreadContexts) if (entry.updatedAt < cutoff) assistantThreadContexts.delete(key);
+	};
+	const getSlackAssistantThreadContext = (channelId, threadTs) => {
+		if (!channelId || !threadTs) return;
+		const key = assistantContextKey(channelId, threadTs);
+		const entry = assistantThreadContexts.get(key);
+		if (!entry) return;
+		if (Date.now() - entry.updatedAt > SLACK_ASSISTANT_CONTEXT_TTL_MS) {
+			assistantThreadContexts.delete(key);
+			return;
+		}
+		return entry;
+	};
+	const saveSlackAssistantThreadContext = (context) => {
+		cleanupAssistantThreadContexts();
+		assistantThreadContexts.set(assistantContextKey(context.assistantChannelId, context.threadTs), {
+			...context,
+			updatedAt: Date.now()
+		});
+	};
+	const resolveSlackSystemEventSessionKey = (p) => {
+		const channelId = normalizeOptionalString(p.channelId) ?? "";
+		const senderId = normalizeOptionalString(p.senderId) ?? "";
+		const channelType = normalizeSlackChannelType(p.channelType, channelId);
+		const isDirectMessage = channelType === "im";
+		if (!channelId && (!isDirectMessage || !senderId)) return params.mainKey;
+		const isGroup = channelType === "mpim";
+		const from = isDirectMessage ? `slack:${channelId || senderId}` : isGroup ? `slack:group:${channelId}` : `slack:channel:${channelId}`;
+		const chatType = isDirectMessage ? "direct" : isGroup ? "group" : "channel";
+		try {
+			const peerKind = isDirectMessage ? "direct" : isGroup ? "group" : "channel";
+			const peerId = isDirectMessage ? senderId : channelId;
+			if (peerId) {
+				const route = resolveAgentRoute({
+					cfg: params.cfg,
+					channel: "slack",
+					accountId: params.accountId,
+					teamId: params.teamId,
+					peer: {
+						kind: peerKind,
+						id: peerId
+					}
+				});
+				const threadTs = normalizeOptionalString(p.threadTs);
+				const baseConversationId = isDirectMessage ? `user:${senderId}` : channelId;
+				const threadBindingRoute = threadTs ? resolveRuntimeConversationBindingRoute({
+					route,
+					conversation: {
+						channel: "slack",
+						accountId: params.accountId,
+						conversationId: threadTs,
+						parentConversationId: baseConversationId
+					}
+				}) : null;
+				const runtimeRoute = threadBindingRoute?.boundSessionKey || threadBindingRoute?.bindingRecord ? threadBindingRoute : resolveRuntimeConversationBindingRoute({
+					route,
+					conversation: {
+						channel: "slack",
+						accountId: params.accountId,
+						conversationId: baseConversationId
+					}
+				});
+				if (runtimeRoute.boundSessionKey) return runtimeRoute.route.sessionKey;
+				return resolveThreadSessionKeys({
+					baseSessionKey: runtimeRoute.route.sessionKey,
+					threadId: threadTs,
+					parentSessionKey: threadTs && params.threadInheritParent ? runtimeRoute.route.sessionKey : void 0
+				}).sessionKey;
+			}
+		} catch {}
+		const legacySessionKey = resolveSessionKey(params.sessionScope, {
+			From: from,
+			ChatType: chatType,
+			Provider: "slack"
+		}, params.mainKey, resolveDefaultAgentId(params.cfg));
+		return resolveThreadSessionKeys({
+			baseSessionKey: legacySessionKey,
+			threadId: normalizeOptionalString(p.threadTs),
+			parentSessionKey: normalizeOptionalString(p.threadTs) && params.threadInheritParent ? legacySessionKey : void 0
+		}).sessionKey;
+	};
+	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;
+		try {
+			await params.app.client.assistant.threads.setStatus({
+				token: params.botToken,
+				channel_id: p.channelId,
+				thread_ts: p.threadTs,
+				status: p.status,
+				...p.loadingMessages?.length ? { loading_messages: p.loadingMessages.slice(0, 10) } : {}
+			});
+		} catch (err) {
+			logVerbose(`slack status update failed for channel ${p.channelId}: ${formatSlackError(err)}`);
+		}
+	};
+	const setSlackAssistantSuggestedPrompts = async (p) => {
+		const prompts = p.prompts.map((prompt) => ({
+			title: prompt.title.trim(),
+			message: prompt.message.trim()
+		})).filter((prompt) => prompt.title && prompt.message).slice(0, 4);
+		if (prompts.length === 0) return false;
+		try {
+			await params.app.client.assistant.threads.setSuggestedPrompts({
+				token: params.botToken,
+				channel_id: p.channelId,
+				thread_ts: p.threadTs,
+				...p.title?.trim() ? { title: p.title.trim() } : {},
+				prompts
+			});
+			return true;
+		} catch (err) {
+			logVerbose(`slack suggested prompts update failed for channel ${p.channelId}: ${formatSlackError(err)}`);
+			return false;
+		}
+	};
+	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 candidates = [
+				p.channelId,
+				p.channelName ? `#${p.channelName}` : void 0,
+				p.channelName,
+				p.channelName ? normalizeSlackSlug(p.channelName) : void 0
+			].filter((value) => Boolean(value)).map((value) => normalizeLowercaseStringOrEmpty(value));
+			if (!(groupDmChannelsLower.includes("*") || candidates.some((candidate) => groupDmChannelsLower.includes(candidate)))) return false;
+		}
+		if (isRoom && p.channelId) {
+			const channelConfig = resolveSlackChannelConfig({
+				channelId: p.channelId,
+				channelName: p.channelName,
+				channels: params.channelsConfig,
+				channelKeys: channelsConfigKeys,
+				defaultRequireMention,
+				allowNameMatching: params.allowNameMatching
+			});
+			const channelMatchMeta = formatAllowlistMatchMeta(channelConfig);
+			const channelAllowed = channelConfig?.allowed !== false;
+			const channelAllowlistConfigured = hasChannelAllowlistConfig;
+			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 : 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,
+		channelRuntime: params.channelRuntime,
+		botUserId: params.botUserId,
+		botId: params.botId,
+		teamId: params.teamId,
+		apiAppId: params.apiAppId,
+		historyLimit: params.historyLimit,
+		dmHistoryLimit: Math.max(0, params.dmHistoryLimit ?? 0),
+		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,
+		channelsConfigKeys,
+		groupPolicy: params.groupPolicy,
+		useAccessGroups: params.useAccessGroups,
+		reactionMode: params.reactionMode,
+		reactionAllowlist: params.reactionAllowlist,
+		replyToMode: params.replyToMode,
+		threadHistoryScope: params.threadHistoryScope,
+		threadInheritParent: params.threadInheritParent,
+		threadRequireExplicitMention: params.threadRequireExplicitMention,
+		slashCommand: params.slashCommand,
+		textLimit: params.textLimit,
+		ackReactionScope: params.ackReactionScope,
+		typingReaction: params.typingReaction,
+		mediaMaxBytes: params.mediaMaxBytes,
+		removeAckAfterReply: params.removeAckAfterReply,
+		logger,
+		markMessageSeen,
+		releaseSeenMessage,
+		shouldDropMismatchedSlackEvent,
+		resolveSlackSystemEventSessionKey,
+		isChannelAllowed,
+		resolveChannelName,
+		resolveUserName,
+		setSlackThreadStatus,
+		getSlackAssistantThreadContext,
+		saveSlackAssistantThreadContext,
+		setSlackAssistantSuggestedPrompts
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/assistant.ts
+const DEFAULT_ASSISTANT_PROMPTS = [
+	{
+		title: "What can you do?",
+		message: "What can you help me with?"
+	},
+	{
+		title: "Summarize this channel",
+		message: "Summarize the recent activity in this channel."
+	},
+	{
+		title: "Draft a reply",
+		message: "Help me draft a reply."
+	}
+];
+function normalizeAssistantThread(event, getPrevious) {
+	const thread = event.assistant_thread;
+	if (!thread) return null;
+	const channelId = thread.channel_id?.trim();
+	const threadTs = thread.thread_ts?.trim();
+	if (!channelId || !threadTs) return null;
+	const previous = getPrevious?.(channelId, threadTs);
+	const threadContext = thread.context;
+	const eventContext = event.context;
+	const resolveContextString = (key, previousValue) => threadContext?.[key]?.trim() || eventContext?.[key]?.trim() || previousValue;
+	const enterpriseId = (() => {
+		if (threadContext && "enterprise_id" in threadContext) return threadContext.enterprise_id === null ? null : threadContext.enterprise_id?.trim() || previous?.enterpriseId;
+		if (eventContext && "enterprise_id" in eventContext) return eventContext.enterprise_id === null ? null : eventContext.enterprise_id?.trim() || previous?.enterpriseId;
+		return previous?.enterpriseId;
+	})();
+	return {
+		assistantChannelId: channelId,
+		threadTs,
+		userId: thread.user_id?.trim() || previous?.userId,
+		channelId: resolveContextString("channel_id", previous?.channelId),
+		teamId: resolveContextString("team_id", previous?.teamId),
+		enterpriseId
+	};
+}
+async function persistAssistantThreadMetadata(params) {
+	const { ctx, assistantThread } = params;
+	try {
+		const initialMessage = ((await ctx.app.client.conversations.replies({
+			token: ctx.botToken,
+			channel: assistantThread.assistantChannelId,
+			ts: assistantThread.threadTs,
+			oldest: assistantThread.threadTs,
+			include_all_metadata: true,
+			limit: 4
+		})).messages ?? []).find((message) => !message.subtype && message.user === ctx.botUserId && message.ts);
+		if (!initialMessage?.ts) return;
+		await ctx.app.client.chat.update({
+			token: ctx.botToken,
+			channel: assistantThread.assistantChannelId,
+			ts: initialMessage.ts,
+			text: initialMessage.text ?? "",
+			blocks: Array.isArray(initialMessage.blocks) ? initialMessage.blocks : [],
+			metadata: buildSlackAssistantThreadMetadata(assistantThread)
+		});
+	} catch (err) {
+		logVerbose(`slack assistant thread metadata persist failed for channel ${assistantThread.assistantChannelId}: ${formatErrorMessage(err)}`);
+	}
+}
+function registerSlackAssistantEvents(params) {
+	const { ctx, trackEvent } = params;
+	const slackApp = ctx.app;
+	slackApp.event("assistant_thread_started", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const assistantThread = normalizeAssistantThread(event, ctx.getSlackAssistantThreadContext);
+			if (!assistantThread) {
+				logVerbose("slack assistant_thread_started dropped: missing assistant thread channel/thread");
+				return;
+			}
+			ctx.saveSlackAssistantThreadContext(assistantThread);
+			await ctx.setSlackAssistantSuggestedPrompts({
+				channelId: assistantThread.assistantChannelId,
+				threadTs: assistantThread.threadTs,
+				title: "Try asking",
+				prompts: DEFAULT_ASSISTANT_PROMPTS
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack assistant_thread_started handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+	slackApp.event("assistant_thread_context_changed", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const assistantThread = normalizeAssistantThread(event, ctx.getSlackAssistantThreadContext);
+			if (!assistantThread) {
+				logVerbose("slack assistant_thread_context_changed dropped: missing assistant thread channel/thread");
+				return;
+			}
+			ctx.saveSlackAssistantThreadContext(assistantThread);
+			await persistAssistantThreadMetadata({
+				ctx,
+				assistantThread
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack assistant_thread_context_changed handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+}
+//#endregion
+//#region extensions/slack/src/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) => normalizeLowercaseStringOrEmpty(key) === normalizeLowercaseStringOrEmpty(normalized));
+	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 extensions/slack/src/monitor/events/channels.ts
+function registerSlackChannelEvents(params) {
+	const { ctx, trackEvent } = params;
+	const enqueueChannelSystemEvent = (paramsLocal) => {
+		if (!ctx.isChannelAllowed({
+			channelId: paramsLocal.channelId,
+			channelName: paramsLocal.channelName,
+			channelType: "channel"
+		})) return;
+		const label = resolveSlackChannelLabel({
+			channelId: paramsLocal.channelId,
+			channelName: paramsLocal.channelName
+		});
+		const sessionKey = ctx.resolveSlackSystemEventSessionKey({
+			channelId: paramsLocal.channelId,
+			channelType: "channel"
+		});
+		enqueueSystemEvent(`Slack channel ${paramsLocal.kind}: ${label}.`, {
+			sessionKey,
+			contextKey: `slack:channel:${paramsLocal.kind}:${paramsLocal.channelId ?? paramsLocal.channelName ?? "unknown"}`
+		});
+	};
+	ctx.app.event("channel_created", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			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: ${formatErrorMessage(err)}`));
+		}
+	});
+	ctx.app.event("channel_rename", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const payload = event;
+			const channelId = payload.channel?.id;
+			const channelName = payload.channel?.name_normalized ?? payload.channel?.name;
+			enqueueChannelSystemEvent({
+				kind: "renamed",
+				channelId,
+				channelName
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack channel rename handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+	ctx.app.event("channel_id_changed", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const payload = event;
+			const oldChannelId = payload.old_channel_id;
+			const newChannelId = payload.new_channel_id;
+			if (!oldChannelId || !newChannelId) return;
+			const channelInfo = await ctx.resolveChannelName(newChannelId);
+			const label = resolveSlackChannelLabel({
+				channelId: newChannelId,
+				channelName: channelInfo?.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 migration = migrateSlackChannelConfig({
+				cfg: getRuntimeConfig(),
+				accountId: ctx.accountId,
+				oldChannelId,
+				newChannelId
+			});
+			if (migration.migrated) {
+				migrateSlackChannelConfig({
+					cfg: ctx.cfg,
+					accountId: ctx.accountId,
+					oldChannelId,
+					newChannelId
+				});
+				await mutateConfigFile({
+					afterWrite: { mode: "auto" },
+					mutate: (draft) => {
+						migrateSlackChannelConfig({
+							cfg: draft,
+							accountId: ctx.accountId,
+							oldChannelId,
+							newChannelId
+						});
+					}
+				});
+				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: ${formatErrorMessage(err)}`));
+		}
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/home.ts
+function buildSlackHomeView() {
+	return {
+		type: "home",
+		callback_id: "openclaw:home",
+		blocks: [
+			{
+				type: "header",
+				text: {
+					type: "plain_text",
+					text: "OpenClaw"
+				}
+			},
+			{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: "Send a DM, mention OpenClaw in a channel, or use `/openclaw` to start a session."
+				}
+			},
+			{
+				type: "context",
+				elements: [{
+					type: "mrkdwn",
+					text: "This Home tab is safe to show to any workspace member who opens the app."
+				}]
+			}
+		]
+	};
+}
+function registerSlackHomeEvents(params) {
+	const { ctx, trackEvent } = params;
+	ctx.app.event("app_home_opened", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const payload = event;
+			if (!payload.user || payload.tab === "messages") return;
+			await ctx.app.client.views.publish({
+				token: ctx.botToken,
+				user_id: payload.user,
+				view: buildSlackHomeView()
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack app home handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+}
+//#endregion
+//#region extensions/slack/src/interactive-dispatch.ts
+async function dispatchSlackPluginInteractiveHandler(params) {
+	return await dispatchPluginInteractiveHandler({
+		channel: "slack",
+		data: params.data,
+		dedupeId: params.interactionId,
+		onMatched: params.onMatched,
+		invoke: ({ registration, namespace, payload }) => registration.handler({
+			...params.ctx,
+			channel: "slack",
+			interaction: {
+				...params.ctx.interaction,
+				data: params.data,
+				namespace,
+				payload
+			},
+			respond: params.respond,
+			...createInteractiveConversationBindingHelpers({
+				registration,
+				senderId: params.ctx.senderId,
+				conversation: {
+					channel: "slack",
+					accountId: params.ctx.accountId,
+					conversationId: params.ctx.conversationId,
+					parentConversationId: params.ctx.parentConversationId,
+					threadId: params.ctx.threadId
+				}
+			})
+		})
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/auth.ts
+let slackChannelMembersCache = /* @__PURE__ */ new WeakMap();
+const DEFAULT_CHANNEL_MEMBERS_CACHE_TTL_MS = 6e4;
+const CHANNEL_MEMBERS_CACHE_MAX = 512;
+const SLACK_CHANNEL_ID = "slack";
+const SLACK_USER_NAME_KIND = "plugin:slack-user-name";
+function normalizeSlackUserId(raw) {
+	const value = (raw ?? "").trim().toLowerCase();
+	if (!value) return "";
+	const mention = value.match(/^<@([a-z0-9_]+)>$/i);
+	if (mention?.[1]) return mention[1];
+	return value.replace(/^(slack:|user:)/, "");
+}
+function isSlackStableUserId(value) {
+	return /^[ubw][a-z0-9_]+$/i.test(value);
+}
+function normalizeSlackStableEntry(entry) {
+	const normalized = entry.trim().toLowerCase();
+	if (!normalized) return null;
+	const userId = normalizeSlackUserId(normalized);
+	return isSlackStableUserId(userId) ? userId : null;
+}
+function normalizeSlackNameEntry(entry) {
+	const normalized = entry.trim().toLowerCase();
+	if (!normalized || normalizeSlackStableEntry(normalized)) return null;
+	return normalized.replace(/^slack:/, "") || null;
+}
+function normalizeSlackNameSubject(value) {
+	return value.trim().toLowerCase() || null;
+}
+function normalizeSlackNameSlugEntry(entry) {
+	const name = normalizeSlackNameEntry(entry);
+	if (!name) return null;
+	const slug = normalizeSlackSlug(name);
+	return slug && slug !== name ? slug : null;
+}
+const slackIngressIdentity = defineStableChannelIngressIdentity({
+	key: "senderId",
+	kind: "stable-id",
+	normalizeEntry: normalizeSlackStableEntry,
+	normalizeSubject: normalizeSlackUserId,
+	sensitivity: "pii",
+	aliases: [["senderName", normalizeSlackNameEntry], ["senderNameSlug", normalizeSlackNameSlugEntry]].map(([key, normalizeEntry]) => ({
+		key,
+		kind: SLACK_USER_NAME_KIND,
+		normalizeEntry,
+		normalizeSubject: normalizeSlackNameSubject,
+		dangerous: true,
+		sensitivity: "pii"
+	}))
+});
+function createSlackIngressSubject(params) {
+	const senderId = normalizeSlackUserId(params.senderId);
+	const senderName = params.senderName?.trim().toLowerCase();
+	return {
+		stableId: senderId,
+		aliases: {
+			senderName,
+			senderNameSlug: senderName ? normalizeSlackSlug(senderName) : void 0
+		}
+	};
+}
+function createSlackIngressResolver(ctx) {
+	return createChannelIngressResolver({
+		channelId: SLACK_CHANNEL_ID,
+		accountId: ctx.accountId,
+		identity: slackIngressIdentity,
+		cfg: ctx.cfg
+	});
+}
+function readSlackCacheTtlMs(envName, fallback) {
+	const raw = process.env[envName]?.trim();
+	if (!raw) return fallback;
+	const parsed = /^\d+$/.test(raw) ? Number(raw) : NaN;
+	return Number.isSafeInteger(parsed) ? parsed : fallback;
+}
+function getChannelMembersCache(ctx) {
+	const existing = slackChannelMembersCache.get(ctx);
+	if (existing) return existing;
+	const next = /* @__PURE__ */ new Map();
+	slackChannelMembersCache.set(ctx, next);
+	return next;
+}
+function pruneChannelMembersCache(cache) {
+	while (cache.size > CHANNEL_MEMBERS_CACHE_MAX) {
+		const oldest = cache.keys().next();
+		if (oldest.done) return;
+		cache.delete(oldest.value);
+	}
+}
+function buildBaseAllowFrom(ctx) {
+	return normalizeAllowListLower(normalizeAllowList(ctx.allowFrom));
+}
+async function resolveSlackEffectiveAllowFrom(ctx, options) {
+	const base = buildBaseAllowFrom(ctx);
+	if (options?.includePairingStore !== true) return base;
+	let storeAllowFrom;
+	try {
+		const resolved = await readChannelIngressStoreAllowFromForDmPolicy({
+			provider: "slack",
+			accountId: ctx.accountId,
+			dmPolicy: ctx.dmPolicy
+		});
+		storeAllowFrom = Array.isArray(resolved) ? resolved : [];
+	} catch {
+		storeAllowFrom = [];
+	}
+	return normalizeAllowListLower([...base, ...storeAllowFrom]);
+}
+async function fetchSlackChannelMemberIds(ctx, channelId) {
+	const members = /* @__PURE__ */ new Set();
+	let cursor;
+	do {
+		const response = await ctx.app.client.conversations.members({
+			token: ctx.botToken,
+			channel: channelId,
+			limit: 999,
+			...cursor ? { cursor } : {}
+		});
+		for (const member of normalizeAllowListLower(response.members)) members.add(member);
+		const nextCursor = response.response_metadata?.next_cursor?.trim();
+		cursor = nextCursor ? nextCursor : void 0;
+	} while (cursor);
+	return members;
+}
+async function resolveSlackChannelMemberIds(ctx, channelId) {
+	const cache = getChannelMembersCache(ctx);
+	const key = `${ctx.accountId}:${channelId}`;
+	const ttlMs = readSlackCacheTtlMs("OPENCLAW_SLACK_CHANNEL_MEMBERS_CACHE_TTL_MS", DEFAULT_CHANNEL_MEMBERS_CACHE_TTL_MS);
+	const rawNowMs = Date.now();
+	const nowMs = asDateTimestampMs(rawNowMs);
+	const cached = cache.get(key);
+	if (cached?.members) {
+		if (ttlMs > 0 && nowMs !== void 0 && cached.expiresAtMs >= nowMs) return cached.members;
+		cache.delete(key);
+	}
+	if (cached?.pending) return await cached.pending;
+	const pending = fetchSlackChannelMemberIds(ctx, channelId);
+	const pendingExpiresAtMs = ttlMs > 0 ? resolveExpiresAtMsFromDurationMs(ttlMs, { nowMs: rawNowMs }) : void 0;
+	cache.set(key, {
+		expiresAtMs: pendingExpiresAtMs ?? 0,
+		pending
+	});
+	pruneChannelMembersCache(cache);
+	try {
+		const members = await pending;
+		const membersExpiresAtMs = ttlMs > 0 ? resolveExpiresAtMsFromDurationMs(ttlMs) : void 0;
+		if (membersExpiresAtMs !== void 0) {
+			cache.set(key, {
+				expiresAtMs: membersExpiresAtMs,
+				members
+			});
+			pruneChannelMembersCache(cache);
+		} else cache.delete(key);
+		return members;
+	} finally {
+		if (cache.get(key)?.pending === pending) cache.delete(key);
+	}
+}
+function resolveExplicitSlackOwnerIds(allowFromLower) {
+	const ownerIds = /* @__PURE__ */ new Set();
+	for (const entry of allowFromLower) {
+		const ownerId = normalizeSlackAllowOwnerEntry(entry);
+		if (ownerId) ownerIds.add(ownerId);
+	}
+	return [...ownerIds];
+}
+async function authorizeSlackBotRoomMessage(params) {
+	const channelUserAllowList = normalizeAllowListLower(params.channelUsers).filter((entry) => entry !== "*");
+	if (channelUserAllowList.length > 0 && allowListMatches({
+		allowList: channelUserAllowList,
+		id: params.senderId,
+		name: params.senderName,
+		allowNameMatching: params.ctx.allowNameMatching
+	})) return true;
+	const explicitOwnerIds = resolveExplicitSlackOwnerIds(params.allowFromLower);
+	if (explicitOwnerIds.length === 0) {
+		logVerbose(`slack: drop bot message ${params.senderId} in ${params.channelId} (no explicit owner id for presence check)`);
+		return false;
+	}
+	try {
+		const channelMemberIds = await resolveSlackChannelMemberIds(params.ctx, params.channelId);
+		if (explicitOwnerIds.some((ownerId) => channelMemberIds.has(ownerId))) return true;
+		logVerbose(`slack: drop bot message ${params.senderId} in ${params.channelId} (no owner present)`);
+	} catch (error) {
+		logVerbose(`slack: drop bot message ${params.senderId} in ${params.channelId} (owner presence lookup failed: ${formatErrorMessage(error)})`);
+	}
+	return false;
+}
+function wildcardWhenOpen(entries) {
+	return entries.length > 0 ? [...entries] : ["*"];
+}
+function slackIngressConversationKind(channelType) {
+	return channelType === "im" ? "direct" : channelType === "mpim" ? "group" : "channel";
+}
+async function resolveSlackCommandIngress(params) {
+	const isDirectMessage = params.channelType === "im";
+	const channelUsers = normalizeAllowListLower(params.channelUsers);
+	const channelUsersConfigured = !isDirectMessage && channelUsers.length > 0;
+	return await createSlackIngressResolver(params.ctx).message({
+		subject: createSlackIngressSubject({
+			senderId: params.senderId,
+			senderName: params.senderName
+		}),
+		conversation: {
+			kind: slackIngressConversationKind(params.channelType),
+			id: params.channelId
+		},
+		event: {
+			kind: params.eventKind ?? "message",
+			authMode: "inbound",
+			mayPair: false
+		},
+		dmPolicy: isDirectMessage ? "open" : "disabled",
+		groupPolicy: channelUsersConfigured ? "allowlist" : "open",
+		policy: {
+			groupAllowFromFallbackToAllowFrom: false,
+			mutableIdentifierMatching: params.ctx.allowNameMatching ? "enabled" : "disabled",
+			...params.activation ? { activation: params.activation } : {}
+		},
+		mentionFacts: params.mentionFacts,
+		allowFrom: isDirectMessage ? ["*"] : params.ownerAllowFromLower,
+		groupAllowFrom: channelUsersConfigured ? channelUsers : [],
+		command: {
+			allowTextCommands: params.allowTextCommands,
+			hasControlCommand: params.hasControlCommand,
+			modeWhenAccessGroupsOff: params.modeWhenAccessGroupsOff,
+			...isDirectMessage ? { commandOwnerAllowFrom: params.ownerAllowFromLower } : {}
+		}
+	});
+}
+async function decideSlackSystemIngress(params) {
+	const isDirectMessage = params.channelType === "im";
+	const channelUsers = normalizeAllowListLower(params.channelUsers);
+	const channelUsersConfigured = !isDirectMessage && channelUsers.length > 0;
+	const ownerAllowFrom = params.interactiveEvent && channelUsersConfigured ? params.ownerAllowFromLower.filter((entry) => entry !== "*") : params.ownerAllowFromLower;
+	const hasAnyCommandAllowlist = ownerAllowFrom.length > 0 || channelUsersConfigured;
+	const groupAllowFrom = (() => {
+		if (isDirectMessage) return [];
+		if (params.interactiveEvent && hasAnyCommandAllowlist) return channelUsersConfigured ? channelUsers : [];
+		if (channelUsersConfigured) return channelUsers;
+		return params.channelId ? ["*"] : wildcardWhenOpen(params.ownerAllowFromLower);
+	})();
+	return (await createSlackIngressResolver(params.ctx).message({
+		subject: createSlackIngressSubject({
+			senderId: params.senderId,
+			senderName: params.senderName
+		}),
+		conversation: {
+			kind: slackIngressConversationKind(params.channelType),
+			id: params.channelId ?? "slack-system"
+		},
+		event: {
+			kind: params.interactiveEvent ? "button" : "system",
+			authMode: params.interactiveEvent && hasAnyCommandAllowlist ? "command" : "inbound",
+			mayPair: false
+		},
+		dmPolicy: isDirectMessage ? "open" : "disabled",
+		groupPolicy: params.interactiveEvent && hasAnyCommandAllowlist ? "open" : channelUsersConfigured || !params.channelId && params.ownerAllowFromLower.length > 0 ? "allowlist" : "open",
+		policy: {
+			groupAllowFromFallbackToAllowFrom: false,
+			mutableIdentifierMatching: params.ctx.allowNameMatching ? "enabled" : "disabled"
+		},
+		allowFrom: isDirectMessage ? wildcardWhenOpen(params.ownerAllowFromLower) : ownerAllowFrom,
+		groupAllowFrom,
+		command: params.interactiveEvent && hasAnyCommandAllowlist ? {
+			useAccessGroups: true,
+			allowTextCommands: true,
+			modeWhenAccessGroupsOff: "configured",
+			commandOwnerAllowFrom: ownerAllowFrom
+		} : void 0
+	})).ingress;
+}
+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"
+	};
+	if (params.interactiveEvent && !expectedSenderId) return {
+		allowed: false,
+		reason: "missing-expected-sender"
+	};
+	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;
+		const resolvedTypeSource = params.channelType ?? info.type;
+		channelType = normalizeSlackChannelType(resolvedTypeSource, channelId);
+		if (!params.ctx.isChannelAllowed({
+			channelId,
+			channelName,
+			channelType
+		})) return {
+			allowed: false,
+			reason: "channel-not-allowed",
+			channelType,
+			channelName
+		};
+		if (params.interactiveEvent) {
+			const inferredFromId = inferSlackChannelType(channelId);
+			const sourceNormalized = typeof resolvedTypeSource === "string" ? resolvedTypeSource.toLowerCase().trim() : void 0;
+			if (inferredFromId === void 0 && !(sourceNormalized === "im" || sourceNormalized === "mpim" || sourceNormalized === "channel" || sourceNormalized === "group")) return {
+				allowed: false,
+				reason: "ambiguous-channel-type",
+				channelType,
+				channelName
+			};
+		}
+	}
+	const senderName = (await params.ctx.resolveUserName(senderId).catch(() => ({}))).name;
+	const ingressChannelType = channelType ?? "channel";
+	if (ingressChannelType === "im") {
+		if (!params.ctx.dmEnabled || params.ctx.dmPolicy === "disabled") return {
+			allowed: false,
+			reason: "dm-disabled",
+			channelType,
+			channelName
+		};
+	}
+	const allowFromLower = await resolveSlackEffectiveAllowFrom(params.ctx, { includePairingStore: ingressChannelType === "im" });
+	const channelConfig = channelId ? resolveSlackChannelConfig({
+		channelId,
+		channelName,
+		channels: params.ctx.channelsConfig,
+		channelKeys: params.ctx.channelsConfigKeys,
+		defaultRequireMention: params.ctx.defaultRequireMention,
+		allowNameMatching: params.ctx.allowNameMatching
+	}) : null;
+	const channelUsersAllowlistConfigured = Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
+	if ((await decideSlackSystemIngress({
+		ctx: params.ctx,
+		senderId,
+		senderName,
+		channelType: ingressChannelType,
+		channelId,
+		ownerAllowFromLower: allowFromLower,
+		channelUsers: channelConfig?.users,
+		interactiveEvent: params.interactiveEvent === true
+	})).decision === "allow") return {
+		allowed: true,
+		channelType,
+		channelName
+	};
+	if (channelType === "im" || !channelId) return {
+		allowed: false,
+		reason: "sender-not-allowlisted",
+		...channelId ? {
+			channelType,
+			channelName
+		} : {}
+	};
+	return {
+		allowed: false,
+		reason: params.interactiveEvent && channelUsersAllowlistConfigured && allowFromLower.length > 0 ? "sender-not-authorized" : channelUsersAllowlistConfigured ? "sender-not-channel-allowed" : "sender-not-allowlisted",
+		channelType,
+		channelName
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/mrkdwn.ts
+function escapeSlackMrkdwn(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replace(/([*_`~])/g, "\\$1");
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/interactions.block-actions.ts
+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) {
+	return normalizeUniqueTrimmedStringList(values);
+}
+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 : truncateSlackText(joined, max);
+}
+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 ? parseStrictFiniteNumber(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 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") {
+		const selectedDateTime = timestampMsToIsoString(params.summary.selectedDateTime * 1e3);
+		if (selectedDateTime) return selectedDateTime;
+	}
+	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 userId = normalizeOptionalString(params.userId);
+	const actor = userId ? ` by <@${userId}>` : "";
+	return `:white_check_mark: *${escapeSlackMrkdwn(params.selectedLabel)}* selected${actor}`;
+}
+function buildSlackPluginInteractionData(params) {
+	const actionId = normalizeOptionalString(params.actionId) ?? "";
+	if (!actionId) return null;
+	const payload = normalizeOptionalString(params.summary.value) || params.summary.selectedValues?.map((value) => normalizeOptionalString(value)).find(Boolean) || "";
+	if (actionId === "openclaw:reply_button" || actionId === "openclaw:reply_select" || actionId.startsWith(`openclaw:reply_button:`) || actionId.startsWith(`openclaw:reply_select:`)) return payload || null;
+	return payload ? `${actionId}:${payload}` : actionId;
+}
+function isSlackReplyActionId(actionId) {
+	return actionId === "openclaw:reply_button" || actionId === "openclaw:reply_select" || actionId.startsWith(`openclaw:reply_button:`) || actionId.startsWith(`openclaw:reply_select:`);
+}
+function isSlackReplyLinkAction(parsed) {
+	if (parsed.actionId === "openclaw:reply_link" || parsed.actionId.startsWith(`openclaw:reply_link:`)) return true;
+	const legacyUrl = normalizeOptionalString(parsed.typedAction.url);
+	return Boolean(legacyUrl && isSlackReplyActionId(parsed.actionId));
+}
+function buildSlackPluginInteractionId(params) {
+	const primaryValue = normalizeOptionalString(params.summary.value) || params.summary.selectedValues?.map((value) => normalizeOptionalString(value)).find(Boolean) || "";
+	return [
+		normalizeOptionalString(params.userId) ?? "",
+		normalizeOptionalString(params.channelId) ?? "",
+		normalizeOptionalString(params.messageTs) ?? "",
+		normalizeOptionalString(params.triggerId) ?? "",
+		normalizeOptionalString(params.actionId) ?? "",
+		primaryValue
+	].join(":");
+}
+function parseSlackBlockAction(params) {
+	const typedBody = params.body;
+	const typedAction = readInteractionAction(params.action);
+	if (!typedAction) {
+		params.log?.(`slack:interaction malformed action payload channel=${typedBody.channel?.id ?? typedBody.container?.channel_id ?? "unknown"} user=${typedBody.user?.id ?? "unknown"}`);
+		return null;
+	}
+	const typedActionWithText = typedAction;
+	return {
+		typedBody,
+		typedAction,
+		typedActionWithText,
+		actionId: typeof typedActionWithText.action_id === "string" ? typedActionWithText.action_id : "unknown",
+		blockId: typedActionWithText.block_id,
+		userId: typedBody.user?.id ?? "unknown",
+		channelId: typedBody.channel?.id ?? typedBody.container?.channel_id,
+		messageTs: typedBody.message?.ts ?? typedBody.container?.message_ts,
+		threadTs: typedBody.container?.thread_ts ?? typedBody.message?.thread_ts,
+		actionSummary: summarizeAction(typedAction)
+	};
+}
+async function respondEphemeral(respond, text) {
+	if (!respond) return;
+	try {
+		await respond({
+			text,
+			response_type: "ephemeral"
+		});
+	} catch {}
+}
+async function updateSlackInteractionMessage(params) {
+	if (!params.channelId || !params.messageTs) return;
+	await params.ctx.app.client.chat.update({
+		channel: params.channelId,
+		ts: params.messageTs,
+		text: params.text,
+		...params.blocks ? { blocks: params.blocks } : {}
+	});
+}
+async function authorizeSlackBlockAction(params) {
+	const auth = await authorizeSlackSystemEventSender({
+		ctx: params.ctx,
+		senderId: params.parsed.userId,
+		channelId: params.parsed.channelId,
+		expectedSenderId: params.parsed.userId,
+		interactiveEvent: true
+	});
+	if (auth.allowed) return auth;
+	params.ctx.runtime.log?.(`slack:interaction drop action=${params.parsed.actionId} user=${params.parsed.userId} channel=${params.parsed.channelId ?? "unknown"} reason=${auth.reason ?? "unauthorized"}`);
+	await respondEphemeral(params.respond, "You are not authorized to use this control.");
+	return { allowed: false };
+}
+async function handleSlackPluginBindingApproval(params) {
+	const pluginBindingApproval = parsePluginBindingApprovalCustomId(params.pluginInteractionData);
+	if (!pluginBindingApproval) return false;
+	const resolved = await resolvePluginConversationBindingApproval({
+		approvalId: pluginBindingApproval.approvalId,
+		decision: pluginBindingApproval.decision,
+		senderId: params.parsed.userId
+	});
+	try {
+		await updateSlackInteractionMessage({
+			ctx: params.ctx,
+			channelId: params.parsed.channelId,
+			messageTs: params.parsed.messageTs,
+			text: params.parsed.typedBody.message?.text ?? "",
+			blocks: []
+		});
+	} catch {}
+	await respondEphemeral(params.respond, buildPluginBindingResolvedText(resolved));
+	return true;
+}
+async function handleSlackExecApprovalInteraction(params) {
+	const approval = parseExecApprovalCommandText(params.pluginInteractionData);
+	if (!approval) return false;
+	const pluginApprovalAuthorizedSender = isSlackApprovalAuthorizedSender({
+		cfg: params.ctx.cfg,
+		accountId: params.ctx.accountId,
+		senderId: params.parsed.userId
+	});
+	const execApprovalAuthorizedSender = isSlackExecApprovalAuthorizedSender({
+		cfg: params.ctx.cfg,
+		accountId: params.ctx.accountId,
+		senderId: params.parsed.userId
+	});
+	const isPluginApproval = approval.approvalId.startsWith("plugin:");
+	const resolveUnprefixedAsPlugin = !isPluginApproval && !execApprovalAuthorizedSender && pluginApprovalAuthorizedSender;
+	const authorized = isPluginApproval ? pluginApprovalAuthorizedSender : execApprovalAuthorizedSender || resolveUnprefixedAsPlugin;
+	const allowPluginFallback = !isPluginApproval && execApprovalAuthorizedSender && pluginApprovalAuthorizedSender;
+	if (!authorized) {
+		params.ctx.runtime.log?.(`slack:interaction drop exec approval user=${params.parsed.userId} (not authorized)`);
+		await respondEphemeral(params.respond, "You are not authorized to approve this request.");
+		return true;
+	}
+	try {
+		await resolveApprovalOverGateway({
+			cfg: params.ctx.cfg,
+			approvalId: approval.approvalId,
+			decision: approval.decision,
+			senderId: params.parsed.userId,
+			allowPluginFallback,
+			...resolveUnprefixedAsPlugin ? { resolveMethod: "plugin" } : {},
+			clientDisplayName: `Slack approval (${params.parsed.userId.trim() || "unknown"})`
+		});
+	} catch (error) {
+		params.ctx.runtime.log?.(`slack:interaction exec approval resolve failed id=${approval.approvalId}: ${String(error)}`);
+		throw error;
+	}
+	try {
+		await updateSlackInteractionMessage({
+			ctx: params.ctx,
+			channelId: params.parsed.channelId,
+			messageTs: params.parsed.messageTs,
+			text: params.parsed.typedBody.message?.text ?? "",
+			blocks: []
+		});
+	} catch {}
+	return true;
+}
+async function dispatchSlackPluginInteraction(params) {
+	const pluginInteractionId = buildSlackPluginInteractionId({
+		userId: params.parsed.userId,
+		channelId: params.parsed.channelId,
+		messageTs: params.parsed.messageTs,
+		triggerId: params.parsed.typedBody.trigger_id,
+		actionId: params.parsed.actionId,
+		summary: params.parsed.actionSummary
+	});
+	if (await handleSlackPluginBindingApproval({
+		ctx: params.ctx,
+		parsed: params.parsed,
+		pluginInteractionData: params.pluginInteractionData,
+		respond: params.respond
+	})) return true;
+	const pluginResult = await dispatchSlackPluginInteractiveHandler({
+		data: params.pluginInteractionData,
+		interactionId: pluginInteractionId,
+		ctx: {
+			accountId: params.ctx.accountId,
+			interactionId: pluginInteractionId,
+			conversationId: params.parsed.channelId ?? "",
+			parentConversationId: void 0,
+			threadId: params.parsed.threadTs,
+			senderId: params.parsed.userId,
+			senderUsername: void 0,
+			auth: params.auth,
+			interaction: {
+				kind: params.parsed.actionSummary.actionType === "button" ? "button" : "select",
+				actionId: params.parsed.actionId,
+				blockId: params.parsed.blockId,
+				messageTs: params.parsed.messageTs,
+				threadTs: params.parsed.threadTs,
+				value: params.parsed.actionSummary.value,
+				selectedValues: params.parsed.actionSummary.selectedValues,
+				selectedLabels: params.parsed.actionSummary.selectedLabels,
+				triggerId: params.parsed.typedBody.trigger_id,
+				responseUrl: params.parsed.typedBody.response_url
+			}
+		},
+		respond: {
+			acknowledge: async () => {},
+			reply: async ({ text, responseType }) => {
+				if (!text) return;
+				await params.respond?.({
+					text,
+					response_type: responseType ?? "ephemeral"
+				});
+			},
+			followUp: async ({ text, responseType }) => {
+				if (!text) return;
+				await params.respond?.({
+					text,
+					response_type: responseType ?? "ephemeral"
+				});
+			},
+			editMessage: async ({ text, blocks }) => {
+				await updateSlackInteractionMessage({
+					ctx: params.ctx,
+					channelId: params.parsed.channelId,
+					messageTs: params.parsed.messageTs,
+					text: text ?? params.parsed.typedBody.message?.text ?? "",
+					blocks: Array.isArray(blocks) ? blocks : void 0
+				});
+			}
+		}
+	});
+	return pluginResult.matched && pluginResult.handled;
+}
+async function resolveSlackBlockActionCommandAuthorized(params) {
+	const commandsAllowFrom = params.ctx.cfg.commands?.allowFrom;
+	if (commandsAllowFrom != null && typeof commandsAllowFrom === "object" && (Array.isArray(commandsAllowFrom.slack) || Array.isArray(commandsAllowFrom["*"]))) return resolveCommandAuthorization({
+		ctx: {
+			Provider: "slack",
+			Surface: "slack",
+			OriginatingChannel: "slack",
+			AccountId: params.ctx.accountId,
+			ChatType: params.auth.channelType === "im" ? "direct" : "group",
+			From: params.parsed.channelId ? `slack:${params.parsed.channelId}` : "slack",
+			SenderId: params.parsed.userId
+		},
+		cfg: params.ctx.cfg,
+		commandAuthorized: false
+	}).isAuthorizedSender;
+	const isDirectMessage = params.auth.channelType === "im";
+	const isRoom = params.auth.channelType === "channel" || params.auth.channelType === "group";
+	const allowFromLower = await resolveSlackEffectiveAllowFrom(params.ctx, { includePairingStore: isDirectMessage });
+	const senderName = (await params.ctx.resolveUserName(params.parsed.userId).catch(() => void 0))?.name;
+	let channelUsers = [];
+	if (isRoom && params.parsed.channelId) {
+		const channelConfig = resolveSlackChannelConfig({
+			channelId: params.parsed.channelId,
+			channelName: params.auth.channelName,
+			channels: params.ctx.channelsConfig,
+			channelKeys: params.ctx.channelsConfigKeys,
+			defaultRequireMention: params.ctx.defaultRequireMention,
+			allowNameMatching: params.ctx.allowNameMatching
+		});
+		channelUsers = Array.isArray(channelConfig?.users) ? channelConfig.users : [];
+	}
+	return (await resolveSlackCommandIngress({
+		ctx: params.ctx,
+		senderId: params.parsed.userId,
+		senderName,
+		channelType: params.auth.channelType ?? "channel",
+		channelId: params.parsed.channelId ?? "slack-interaction",
+		ownerAllowFromLower: allowFromLower,
+		channelUsers,
+		allowTextCommands: false,
+		hasControlCommand: true,
+		eventKind: "button",
+		modeWhenAccessGroupsOff: "configured"
+	})).commandAccess.authorized;
+}
+function enqueueSlackBlockActionEvent(params) {
+	const eventPayload = {
+		interactionType: "block_action",
+		actionId: params.parsed.actionId,
+		blockId: params.parsed.blockId,
+		...params.parsed.actionSummary,
+		userId: params.parsed.userId,
+		teamId: params.parsed.typedBody.team?.id,
+		triggerId: params.parsed.typedBody.trigger_id,
+		responseUrl: params.parsed.typedBody.response_url,
+		channelId: params.parsed.channelId,
+		messageTs: params.parsed.messageTs,
+		threadTs: params.parsed.threadTs
+	};
+	params.ctx.runtime.log?.(`slack:interaction action=${params.parsed.actionId} type=${params.parsed.actionSummary.actionType ?? "unknown"} user=${params.parsed.userId} channel=${params.parsed.channelId}`);
+	const sessionKey = params.ctx.resolveSlackSystemEventSessionKey({
+		channelId: params.parsed.channelId,
+		channelType: params.auth.channelType,
+		senderId: params.parsed.userId,
+		threadTs: params.parsed.threadTs
+	});
+	const contextParts = [
+		"slack:interaction",
+		params.parsed.channelId,
+		params.parsed.messageTs,
+		params.parsed.actionId
+	].filter(Boolean);
+	if (enqueueSystemEvent(params.formatSystemEvent(eventPayload), {
+		sessionKey,
+		contextKey: contextParts.join(":"),
+		deliveryContext: {
+			channel: "slack",
+			to: params.auth.channelType === "im" ? `user:${params.parsed.userId}` : params.parsed.channelId ? `channel:${params.parsed.channelId}` : void 0,
+			accountId: params.ctx.accountId,
+			threadId: params.parsed.threadTs
+		}
+	})) requestHeartbeat({
+		source: "hook",
+		intent: "immediate",
+		reason: "hook:slack-interaction",
+		sessionKey,
+		heartbeat: { target: "last" }
+	});
+}
+function buildSlackConfirmationBlocks(params) {
+	const selectedLabel = formatInteractionSelectionLabel({
+		actionId: params.parsed.actionId,
+		summary: params.parsed.actionSummary,
+		buttonText: params.parsed.typedActionWithText.text?.text
+	});
+	return params.originalBlocks.map((block) => {
+		const typedBlock = block;
+		if (typedBlock.type === "actions" && typedBlock.block_id === params.parsed.blockId) return {
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: formatInteractionConfirmationText({
+					selectedLabel,
+					userId: params.parsed.userId
+				})
+			}]
+		};
+		return block;
+	});
+}
+async function updateSlackLegacyBlockAction(params) {
+	const originalBlocks = params.parsed.typedBody.message?.blocks;
+	if (!Array.isArray(originalBlocks) || !params.parsed.channelId || !params.parsed.messageTs || !params.parsed.blockId) return;
+	try {
+		await updateSlackInteractionMessage({
+			ctx: params.ctx,
+			channelId: params.parsed.channelId,
+			messageTs: params.parsed.messageTs,
+			text: params.parsed.typedBody.message?.text ?? "",
+			blocks: buildSlackConfirmationBlocks({
+				parsed: params.parsed,
+				originalBlocks
+			})
+		});
+	} catch {
+		await respondEphemeral(params.respond, `Button "${params.parsed.actionId}" clicked!`);
+	}
+}
+async function handleSlackBlockAction(params) {
+	const { ack, body, action, respond } = params.args;
+	await ack();
+	if (params.ctx.shouldDropMismatchedSlackEvent?.(body)) {
+		params.ctx.runtime.log?.("slack:interaction drop block action payload (mismatched app/team)");
+		return;
+	}
+	const parsed = parseSlackBlockAction({
+		body,
+		action,
+		log: params.ctx.runtime.log
+	});
+	if (!parsed) return;
+	if (isSlackReplyLinkAction(parsed)) return;
+	params.trackEvent?.();
+	const pluginInteractionData = buildSlackPluginInteractionData({
+		actionId: parsed.actionId,
+		summary: parsed.actionSummary
+	});
+	if (pluginInteractionData && isSlackReplyActionId(parsed.actionId)) {
+		if (await handleSlackExecApprovalInteraction({
+			ctx: params.ctx,
+			parsed,
+			pluginInteractionData,
+			respond
+		})) return;
+	}
+	const auth = await authorizeSlackBlockAction({
+		ctx: params.ctx,
+		parsed,
+		respond
+	});
+	if (!auth.allowed) return;
+	if (pluginInteractionData && isSlackReplyActionId(parsed.actionId)) {
+		if (await handleSlackPluginBindingApproval({
+			ctx: params.ctx,
+			parsed,
+			pluginInteractionData,
+			respond
+		})) return;
+	} else if (pluginInteractionData) {
+		const isAuthorizedSender = await resolveSlackBlockActionCommandAuthorized({
+			ctx: params.ctx,
+			parsed,
+			auth
+		});
+		if (await dispatchSlackPluginInteraction({
+			ctx: params.ctx,
+			parsed,
+			pluginInteractionData,
+			auth: { isAuthorizedSender },
+			respond
+		})) return;
+	}
+	enqueueSlackBlockActionEvent({
+		ctx: params.ctx,
+		parsed,
+		auth,
+		formatSystemEvent: params.formatSystemEvent
+	});
+	await updateSlackLegacyBlockAction({
+		ctx: params.ctx,
+		parsed,
+		respond
+	});
+}
+function registerSlackBlockActionHandler(params) {
+	if (typeof params.ctx.app.action !== "function") return;
+	params.ctx.app.action(/.+/, async (args) => {
+		await handleSlackBlockAction({
+			ctx: params.ctx,
+			trackEvent: params.trackEvent,
+			args,
+			formatSystemEvent: params.formatSystemEvent
+		});
+	});
+}
+//#endregion
+//#region extensions/slack/src/modal-metadata.ts
+function parseSlackModalPrivateMetadata(raw) {
+	if (typeof raw !== "string" || raw.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return {
+			sessionKey: normalizeOptionalString(parsed.sessionKey),
+			channelId: normalizeOptionalString(parsed.channelId),
+			channelType: normalizeOptionalString(parsed.channelType),
+			userId: normalizeOptionalString(parsed.userId),
+			pluginInteractiveData: normalizeOptionalString(parsed.pluginInteractiveData)
+		};
+	} catch {
+		return {};
+	}
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/interactions.modal.ts
+const OPENCLAW_MODAL_CALLBACK_PREFIX = "openclaw:";
+function resolveSlackModalPluginInteractiveData(params) {
+	const metadataData = params.metadata.pluginInteractiveData?.trim();
+	if (metadataData) return metadataData;
+	if (!params.callbackId.startsWith(OPENCLAW_MODAL_CALLBACK_PREFIX)) return;
+	return params.callbackId.slice(9).trim() || void 0;
+}
+function shouldHandleSlackModalLifecycleBody(body) {
+	const typed = body;
+	if ((typed.view?.callback_id ?? "").startsWith(OPENCLAW_MODAL_CALLBACK_PREFIX)) return true;
+	const metadata = parseSlackModalPrivateMetadata(typed.view?.private_metadata);
+	return Boolean(metadata.pluginInteractiveData?.trim());
+}
+function resolveSlackModalPluginNamespace(data) {
+	if (!data) return;
+	const separatorIndex = data.indexOf(":");
+	return separatorIndex >= 0 ? data.slice(0, separatorIndex) : data;
+}
+function resolveSlackPluginSystemEventPayload(result) {
+	if (!result || typeof result !== "object") return;
+	const systemEvent = result.systemEvent;
+	if (!systemEvent || typeof systemEvent !== "object") return;
+	const typed = systemEvent;
+	const output = {};
+	if (typeof typed.summary === "string" && typed.summary.trim()) output.summary = typed.summary;
+	if (typeof typed.reference === "string" && typed.reference.trim()) output.reference = typed.reference;
+	if (typed.data && typeof typed.data === "object" && !Array.isArray(typed.data)) output.data = typed.data;
+	return Object.keys(output).length > 0 ? output : void 0;
+}
+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,
+			senderId: params.userId
+		}),
+		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 = params.summarizeViewState(params.body.view?.state?.values);
+	const sessionRouting = resolveModalSessionRouting({
+		ctx: params.ctx,
+		metadata,
+		userId
+	});
+	return {
+		callbackId,
+		userId,
+		expectedUserId: metadata.userId,
+		viewId,
+		sessionRouting,
+		stateValues: params.body.view?.state?.values,
+		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 dispatchSlackModalPluginInteractiveHandler(params) {
+	if (!params.data) return {
+		matched: false,
+		handled: false,
+		duplicate: false
+	};
+	const isViewClosed = params.interactionType === "view_closed";
+	const interactionId = [
+		params.interactionType,
+		params.payload.callbackId,
+		params.payload.viewId,
+		params.payload.userId
+	].filter(Boolean).join(":");
+	const result = await dispatchSlackPluginInteractiveHandler({
+		data: params.data,
+		interactionId,
+		ctx: {
+			accountId: params.ctx.accountId,
+			interactionId,
+			conversationId: params.sessionRouting.channelId ?? "",
+			parentConversationId: void 0,
+			threadId: void 0,
+			senderId: params.payload.userId,
+			senderUsername: void 0,
+			auth: params.auth,
+			interaction: {
+				kind: params.interactionType,
+				callbackId: params.payload.callbackId,
+				viewId: params.payload.viewId,
+				rootViewId: params.payload.rootViewId,
+				previousViewId: params.payload.previousViewId,
+				externalId: params.payload.externalId,
+				isStackedView: params.payload.isStackedView,
+				isCleared: isViewClosed ? params.body.is_cleared === true : void 0,
+				inputs: params.payload.inputs,
+				stateValues: params.stateValues,
+				triggerId: params.body.trigger_id
+			}
+		},
+		respond: {
+			acknowledge: async () => {},
+			reply: async () => {},
+			followUp: async () => {},
+			editMessage: async () => {}
+		}
+	});
+	return {
+		...result,
+		namespace: result.matched ? resolveSlackModalPluginNamespace(params.data) : void 0,
+		systemEvent: result.matched ? resolveSlackPluginSystemEventPayload(result.result) : void 0
+	};
+}
+async function emitSlackModalLifecycleEvent(params) {
+	const { callbackId, userId, expectedUserId, viewId, sessionRouting, stateValues, payload } = resolveSlackModalEventBase({
+		ctx: params.ctx,
+		body: params.body,
+		summarizeViewState: params.summarizeViewState
+	});
+	const pluginInteractiveData = resolveSlackModalPluginInteractiveData({
+		callbackId,
+		metadata: parseSlackModalPrivateMetadata(params.body.view?.private_metadata)
+	});
+	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) {
+		if (pluginInteractiveData) try {
+			await dispatchSlackModalPluginInteractiveHandler({
+				ctx: params.ctx,
+				body: params.body,
+				interactionType: params.interactionType,
+				data: pluginInteractiveData,
+				auth: { isAuthorizedSender: false },
+				payload,
+				stateValues,
+				sessionRouting
+			});
+		} catch (error) {
+			params.ctx.runtime.log?.(`slack:interaction modal plugin dispatch failed callback=${callbackId} error=${error instanceof Error ? error.message : String(error)}`);
+		}
+		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,
+		interactiveEvent: true
+	});
+	if (!auth.allowed) {
+		params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=${auth.reason ?? "unauthorized"}`);
+		return;
+	}
+	let pluginDispatch;
+	try {
+		pluginDispatch = await dispatchSlackModalPluginInteractiveHandler({
+			ctx: params.ctx,
+			body: params.body,
+			interactionType: params.interactionType,
+			data: pluginInteractiveData,
+			auth: { isAuthorizedSender: auth.allowed },
+			payload,
+			stateValues,
+			sessionRouting
+		});
+	} catch (error) {
+		params.ctx.runtime.log?.(`slack:interaction modal plugin dispatch failed callback=${callbackId} error=${error instanceof Error ? error.message : String(error)}`);
+	}
+	const pluginEventFields = pluginDispatch?.matched === true ? {
+		pluginHandled: pluginDispatch.handled,
+		pluginNamespace: pluginDispatch.namespace,
+		pluginDuplicate: pluginDispatch.duplicate || void 0,
+		pluginSystemEvent: pluginDispatch.systemEvent
+	} : {};
+	enqueueSystemEvent(params.formatSystemEvent({
+		...eventPayload,
+		...pluginEventFields
+	}), {
+		sessionKey: sessionRouting.sessionKey,
+		contextKey: [
+			params.contextPrefix,
+			callbackId,
+			viewId,
+			userId
+		].filter(Boolean).join(":")
+	});
+}
+function registerModalLifecycleHandler(params) {
+	params.register(params.matcher, async ({ ack, body }) => {
+		if (!shouldHandleSlackModalLifecycleBody(body)) return;
+		await ack();
+		if (params.ctx.shouldDropMismatchedSlackEvent?.(body)) {
+			params.ctx.runtime.log?.(`slack:interaction drop ${params.interactionType} payload (mismatched app/team)`);
+			return;
+		}
+		params.trackEvent?.();
+		await emitSlackModalLifecycleEvent({
+			ctx: params.ctx,
+			body,
+			interactionType: params.interactionType,
+			contextPrefix: params.contextPrefix,
+			summarizeViewState: params.summarizeViewState,
+			formatSystemEvent: params.formatSystemEvent
+		});
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/interactions.shortcuts.ts
+function resolveMessageThreadTs(body) {
+	const threadTs = body.message.thread_ts;
+	return typeof threadTs === "string" && threadTs.trim() ? threadTs.trim() : void 0;
+}
+async function handleSlackShortcut(params) {
+	const { ack, body } = params.args;
+	await ack();
+	if (params.ctx.shouldDropMismatchedSlackEvent?.(body)) {
+		params.ctx.runtime.log?.("slack:interaction drop shortcut payload (mismatched app/team)");
+		return;
+	}
+	const callbackId = body.callback_id?.trim();
+	const userId = body.user?.id?.trim();
+	if (!callbackId || !userId) {
+		params.ctx.runtime.log?.("slack:interaction drop shortcut reason=invalid-payload");
+		return;
+	}
+	params.trackEvent?.();
+	const isMessageShortcut = body.type === "message_action";
+	const messageBody = isMessageShortcut ? body : void 0;
+	const channelId = messageBody?.channel.id?.trim() || void 0;
+	if (isMessageShortcut && !channelId) {
+		params.ctx.runtime.log?.(`slack:interaction drop shortcut callback=${callbackId} user=${userId} reason=missing-channel`);
+		return;
+	}
+	const threadTs = messageBody ? resolveMessageThreadTs(messageBody) : void 0;
+	const auth = await authorizeSlackSystemEventSender({
+		ctx: params.ctx,
+		senderId: userId,
+		channelId,
+		channelType: isMessageShortcut ? void 0 : "im",
+		expectedSenderId: userId,
+		interactiveEvent: true
+	});
+	if (!auth.allowed) {
+		params.ctx.runtime.log?.(`slack:interaction drop shortcut callback=${callbackId} user=${userId} reason=${auth.reason ?? "unauthorized"}`);
+		return;
+	}
+	const interactionType = isMessageShortcut ? "message_shortcut" : "global_shortcut";
+	const messageTs = messageBody?.message.ts || messageBody?.message_ts;
+	const eventPayload = {
+		interactionType,
+		actionId: `shortcut:${callbackId}`,
+		callbackId,
+		userId,
+		teamId: body.team?.id ?? body.user.team_id,
+		triggerId: body.trigger_id,
+		actionTs: body.action_ts,
+		channelId,
+		channelName: messageBody?.channel.name,
+		messageTs,
+		threadTs,
+		messageUserId: messageBody?.message.user,
+		messageText: messageBody?.message.text,
+		responseUrl: messageBody?.response_url
+	};
+	const sessionKey = params.ctx.resolveSlackSystemEventSessionKey({
+		channelId,
+		channelType: auth.channelType,
+		senderId: userId,
+		threadTs
+	});
+	const contextKey = [
+		"slack:interaction:shortcut",
+		interactionType,
+		callbackId,
+		channelId,
+		messageTs,
+		body.action_ts
+	].filter(Boolean).join(":");
+	params.ctx.runtime.log?.(`slack:interaction ${interactionType} callback=${callbackId} user=${userId} channel=${channelId ?? "direct"}`);
+	if (enqueueSystemEvent(params.formatSystemEvent(eventPayload), {
+		sessionKey,
+		contextKey,
+		deliveryContext: {
+			channel: "slack",
+			to: auth.channelType === "im" ? `user:${userId}` : `channel:${channelId}`,
+			accountId: params.ctx.accountId,
+			threadId: threadTs
+		}
+	})) requestHeartbeat({
+		source: "hook",
+		intent: "immediate",
+		reason: "hook:slack-interaction",
+		sessionKey,
+		heartbeat: { target: "last" }
+	});
+}
+function registerSlackShortcutHandler(params) {
+	if (typeof params.ctx.app.shortcut !== "function") return;
+	params.ctx.app.shortcut(/.+/, async (args) => {
+		await handleSlackShortcut({
+			ctx: params.ctx,
+			trackEvent: params.trackEvent,
+			args,
+			formatSystemEvent: params.formatSystemEvent
+		});
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/interactions.ts
+const SLACK_INTERACTION_EVENT_PREFIX = "Slack interaction: ";
+const REDACTED_INTERACTION_VALUE = "[redacted]";
+const SLACK_INTERACTION_EVENT_MAX_CHARS = 2400;
+const SLACK_INTERACTION_STRING_MAX_CHARS = 160;
+const SLACK_INTERACTION_ARRAY_MAX_ITEMS = 64;
+const SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS = 3;
+const SLACK_INTERACTION_REDACTED_KEYS = /* @__PURE__ */ new Set([
+	"triggerId",
+	"responseUrl",
+	"workflowTriggerUrl",
+	"privateMetadata",
+	"viewHash"
+]);
+function sanitizeSlackInteractionPayloadValue(value, key) {
+	if (value === void 0) return;
+	if (key && SLACK_INTERACTION_REDACTED_KEYS.has(key)) {
+		if (typeof value !== "string" || value.trim().length === 0) return;
+		return REDACTED_INTERACTION_VALUE;
+	}
+	if (typeof value === "string") return truncateSlackText(value, SLACK_INTERACTION_STRING_MAX_CHARS);
+	if (Array.isArray(value)) {
+		const sanitized = value.slice(0, SLACK_INTERACTION_ARRAY_MAX_ITEMS).map((entry) => sanitizeSlackInteractionPayloadValue(entry)).filter((entry) => entry !== void 0);
+		if (value.length > SLACK_INTERACTION_ARRAY_MAX_ITEMS) sanitized.push(`…+${value.length - SLACK_INTERACTION_ARRAY_MAX_ITEMS} more`);
+		return sanitized;
+	}
+	if (!value || typeof value !== "object") return value;
+	const output = {};
+	for (const [entryKey, entryValue] of Object.entries(value)) {
+		const sanitized = sanitizeSlackInteractionPayloadValue(entryValue, entryKey);
+		if (sanitized === void 0) continue;
+		if (typeof sanitized === "string" && sanitized.length === 0) continue;
+		if (Array.isArray(sanitized) && sanitized.length === 0) continue;
+		output[entryKey] = sanitized;
+	}
+	return output;
+}
+function buildCompactSlackInteractionPayload(payload) {
+	const rawInputs = Array.isArray(payload.inputs) ? payload.inputs : [];
+	const compactInputs = rawInputs.slice(0, SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS).flatMap((entry) => {
+		if (!entry || typeof entry !== "object") return [];
+		const typed = entry;
+		return [{
+			actionId: typed.actionId,
+			blockId: typed.blockId,
+			actionType: typed.actionType,
+			inputKind: typed.inputKind,
+			selectedValues: typed.selectedValues,
+			selectedLabels: typed.selectedLabels,
+			inputValue: typed.inputValue,
+			inputNumber: typed.inputNumber,
+			selectedDate: typed.selectedDate,
+			selectedTime: typed.selectedTime,
+			selectedDateTime: typed.selectedDateTime,
+			richTextPreview: typed.richTextPreview
+		}];
+	});
+	return {
+		interactionType: payload.interactionType,
+		actionId: payload.actionId,
+		callbackId: payload.callbackId,
+		actionType: payload.actionType,
+		actionTs: payload.actionTs,
+		userId: payload.userId,
+		teamId: payload.teamId,
+		channelId: payload.channelId ?? payload.routedChannelId,
+		messageTs: payload.messageTs,
+		threadTs: payload.threadTs,
+		messageUserId: payload.messageUserId,
+		messageText: payload.messageText,
+		viewId: payload.viewId,
+		isCleared: payload.isCleared,
+		selectedValues: payload.selectedValues,
+		selectedLabels: payload.selectedLabels,
+		selectedDate: payload.selectedDate,
+		selectedTime: payload.selectedTime,
+		selectedDateTime: payload.selectedDateTime,
+		workflowId: payload.workflowId,
+		routedChannelType: payload.routedChannelType,
+		pluginHandled: payload.pluginHandled,
+		pluginNamespace: payload.pluginNamespace,
+		pluginDuplicate: payload.pluginDuplicate,
+		pluginSystemEvent: payload.pluginSystemEvent,
+		inputs: compactInputs.length > 0 ? compactInputs : void 0,
+		inputsOmitted: rawInputs.length > SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS ? rawInputs.length - SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS : void 0,
+		payloadTruncated: true
+	};
+}
+function formatSlackInteractionSystemEvent(payload) {
+	const toEventText = (value) => `${SLACK_INTERACTION_EVENT_PREFIX}${JSON.stringify(value)}`;
+	const sanitizedPayload = sanitizeSlackInteractionPayloadValue(payload) ?? {};
+	let eventText = toEventText(sanitizedPayload);
+	if (eventText.length <= SLACK_INTERACTION_EVENT_MAX_CHARS) return eventText;
+	eventText = toEventText(sanitizeSlackInteractionPayloadValue(buildCompactSlackInteractionPayload(sanitizedPayload)));
+	if (eventText.length <= SLACK_INTERACTION_EVENT_MAX_CHARS) return eventText;
+	return toEventText({
+		interactionType: sanitizedPayload.interactionType,
+		actionId: sanitizedPayload.actionId ?? "unknown",
+		userId: sanitizedPayload.userId,
+		channelId: sanitizedPayload.channelId ?? sanitizedPayload.routedChannelId,
+		payloadTruncated: true
+	});
+}
+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 registerSlackInteractionEvents(params) {
+	const { ctx, trackEvent } = params;
+	registerSlackBlockActionHandler({
+		ctx,
+		trackEvent,
+		formatSystemEvent: formatSlackInteractionSystemEvent
+	});
+	registerSlackShortcutHandler({
+		ctx,
+		trackEvent,
+		formatSystemEvent: formatSlackInteractionSystemEvent
+	});
+	if (typeof ctx.app.view !== "function") return;
+	const modalMatcher = /.*/;
+	registerModalLifecycleHandler({
+		register: (matcher, handler) => ctx.app.view(matcher, handler),
+		matcher: modalMatcher,
+		ctx,
+		trackEvent,
+		interactionType: "view_submission",
+		contextPrefix: "slack:interaction:view",
+		summarizeViewState,
+		formatSystemEvent: formatSlackInteractionSystemEvent
+	});
+	const viewClosed = ctx.app.viewClosed;
+	if (typeof viewClosed !== "function") return;
+	registerModalLifecycleHandler({
+		register: viewClosed,
+		matcher: modalMatcher,
+		ctx,
+		trackEvent,
+		interactionType: "view_closed",
+		contextPrefix: "slack:interaction:view-closed",
+		summarizeViewState,
+		formatSystemEvent: formatSlackInteractionSystemEvent
+	});
+}
+//#endregion
+//#region extensions/slack/src/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,
+			senderId
+		})
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/members.ts
+function registerSlackMemberEvents(params) {
+	const { ctx, trackEvent } = params;
+	const handleMemberChannelEvent = async (paramsLocal) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(paramsLocal.body)) return;
+			trackEvent?.();
+			const payload = paramsLocal.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-${paramsLocal.verb}`
+			});
+			if (!ingressContext) return;
+			const userLabel = (payload.user ? await ctx.resolveUserName(payload.user) : {})?.name ?? payload.user ?? "someone";
+			enqueueSystemEvent(`Slack: ${userLabel} ${paramsLocal.verb} ${ingressContext.channelLabel}.`, {
+				sessionKey: ingressContext.sessionKey,
+				contextKey: `slack:member:${paramsLocal.verb}:${channelId ?? "unknown"}:${payload.user ?? "unknown"}`
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack ${paramsLocal.verb} handler failed: ${formatErrorMessage(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 extensions/slack/src/monitor/events/message-subtype-handlers.ts
+const SUBTYPE_HANDLER_REGISTRY = {
+	message_changed: {
+		subtype: "message_changed",
+		eventKind: "message_changed",
+		describe: (channelLabel) => `Slack message edited in ${channelLabel}.`,
+		contextKey: (event) => {
+			const changed = event;
+			return `slack:message:changed:${changed.channel ?? "unknown"}:${changed.message?.ts ?? changed.previous_message?.ts ?? changed.event_ts ?? "unknown"}`;
+		},
+		resolveSenderId: (event) => {
+			const changed = event;
+			return changed.message?.user ?? changed.previous_message?.user ?? changed.message?.bot_id ?? changed.previous_message?.bot_id;
+		},
+		resolveChannelId: (event) => event.channel,
+		resolveChannelType: () => void 0
+	},
+	message_deleted: {
+		subtype: "message_deleted",
+		eventKind: "message_deleted",
+		describe: (channelLabel) => `Slack message deleted in ${channelLabel}.`,
+		contextKey: (event) => {
+			const deleted = event;
+			return `slack:message:deleted:${deleted.channel ?? "unknown"}:${deleted.deleted_ts ?? deleted.event_ts ?? "unknown"}`;
+		},
+		resolveSenderId: (event) => {
+			const deleted = event;
+			return deleted.previous_message?.user ?? deleted.previous_message?.bot_id;
+		},
+		resolveChannelId: (event) => event.channel,
+		resolveChannelType: () => void 0
+	}
+};
+function resolveSlackMessageSubtypeHandler(event) {
+	const subtype = event.subtype;
+	if (subtype !== "message_changed" && subtype !== "message_deleted") return;
+	return SUBTYPE_HANDLER_REGISTRY[subtype];
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/messages.ts
+const slackInboundLog = createSubsystemLogger("gateway/channels/slack").child("inbound");
+function formatSlackInboundLogLine(params) {
+	return `Inbound app_mention ${`slack:${params.workspaceId}:channel:${params.channelId}:user:${params.userId}`} -> bot:${params.botUserId} (${params.channelType}, ${params.bodyChars} chars)`;
+}
+function isSlackUserId(value) {
+	return /^[UW][A-Z0-9]+$/.test(value);
+}
+function addUserCandidate(candidates, value, botUserId) {
+	const id = normalizeOptionalString(value);
+	if (!id || id === botUserId || !isSlackUserId(id)) return;
+	candidates.add(id);
+}
+function collectMetadataUserCandidates(candidates, value, botUserId) {
+	const metadata = asOptionalRecord(value);
+	const payload = asOptionalRecord(metadata?.event_payload);
+	if (!payload) return;
+	for (const key of [
+		"user",
+		"user_id",
+		"actor_user_id",
+		"author_user_id",
+		"slack_user_id"
+	]) addUserCandidate(candidates, payload[key], botUserId);
+}
+function resolveAssistantMessageChangedSender(params) {
+	const candidates = /* @__PURE__ */ new Set();
+	collectMetadataUserCandidates(candidates, params.message?.metadata, params.botUserId);
+	return candidates.size === 1 ? [...candidates][0] : void 0;
+}
+function isSelfAttributedMessageChange(params) {
+	const topUser = normalizeOptionalString(params.event.user);
+	const messageUser = normalizeOptionalString(params.message?.user);
+	const messageBotId = normalizeOptionalString(params.message?.bot_id);
+	return Boolean(params.ctx.botUserId) && (topUser === params.ctx.botUserId || messageUser === params.ctx.botUserId) || Boolean(params.ctx.botId) && messageBotId === params.ctx.botId;
+}
+function resolveAssistantMessageChangedInbound(params) {
+	if (params.event.subtype !== "message_changed") return;
+	const changed = params.event;
+	const message = asOptionalRecord(changed.message);
+	if (!message || !isSelfAttributedMessageChange({
+		event: changed,
+		message,
+		ctx: params.ctx
+	})) return;
+	if (normalizeSlackChannelType(normalizeOptionalString(changed.channel_type), changed.channel) !== "im") return;
+	const senderId = resolveAssistantMessageChangedSender({
+		message,
+		botUserId: params.ctx.botUserId
+	});
+	if (!senderId) {
+		if (shouldLogVerbose()) logVerbose(`slack: assistant_app_thread message_changed in DM channel=${changed.channel} dropped: no sender resolved from metadata`);
+		return;
+	}
+	return {
+		type: "message",
+		channel: changed.channel ?? params.event.channel,
+		channel_type: "im",
+		user: senderId,
+		text: normalizeOptionalString(message.text),
+		ts: normalizeOptionalString(message.ts) ?? normalizeOptionalString(changed.event_ts),
+		thread_ts: normalizeOptionalString(message.thread_ts),
+		event_ts: changed.event_ts,
+		assistant_thread: asOptionalRecord(message.assistant_thread) ?? asOptionalRecord(changed.assistant_thread),
+		files: Array.isArray(message.files) ? message.files : void 0,
+		attachments: Array.isArray(message.attachments) ? message.attachments : void 0
+	};
+}
+function registerSlackMessageEvents(params) {
+	const { ctx, handleSlackMessage } = params;
+	const handleIncomingMessageEvent = async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			const message = event;
+			const assistantChangedInbound = resolveAssistantMessageChangedInbound({
+				event: message,
+				ctx
+			});
+			if (assistantChangedInbound) {
+				await handleSlackMessage(assistantChangedInbound, { source: "message" });
+				return;
+			}
+			if (message.subtype === "message_changed" && isSelfAttributedMessageChange({
+				event: message,
+				message: asOptionalRecord(message.message),
+				ctx
+			})) return;
+			const subtypeHandler = resolveSlackMessageSubtypeHandler(message);
+			if (subtypeHandler) {
+				const channelId = subtypeHandler.resolveChannelId(message);
+				const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+					ctx,
+					senderId: subtypeHandler.resolveSenderId(message),
+					channelId,
+					channelType: subtypeHandler.resolveChannelType(message),
+					eventKind: subtypeHandler.eventKind
+				});
+				if (!ingressContext) return;
+				enqueueSystemEvent(subtypeHandler.describe(ingressContext.channelLabel), {
+					sessionKey: ingressContext.sessionKey,
+					contextKey: subtypeHandler.contextKey(message)
+				});
+				return;
+			}
+			await handleSlackMessage(message, { source: "message" });
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack handler failed: ${formatErrorMessage(err)}`));
+		}
+	};
+	ctx.app.event("message", async ({ event, body }) => {
+		await handleIncomingMessageEvent({
+			event,
+			body
+		});
+	});
+	ctx.app.event("app_mention", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			const mention = event;
+			const channelType = normalizeSlackChannelType(mention.channel_type, mention.channel);
+			if (channelType === "im" || channelType === "mpim") return;
+			slackInboundLog.info(formatSlackInboundLogLine({
+				workspaceId: ctx.teamId,
+				channelId: mention.channel,
+				channelType: channelType ?? "channel",
+				userId: normalizeOptionalString(mention.user) ?? "unknown",
+				botUserId: ctx.botUserId,
+				bodyChars: normalizeOptionalString(mention.text)?.length ?? 0
+			}));
+			await handleSlackMessage(mention, {
+				source: "app_mention",
+				wasMentioned: true
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack mention handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/pins.ts
+async function handleSlackPinEvent(params) {
+	const { ctx, trackEvent, body, event, action, contextKeySuffix, errorLabel } = params;
+	try {
+		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+		trackEvent?.();
+		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: ${formatErrorMessage(err)}`));
+	}
+}
+function registerSlackPinEvents(params) {
+	const { ctx, trackEvent } = params;
+	ctx.app.event("pin_added", async ({ event, body }) => {
+		await handleSlackPinEvent({
+			ctx,
+			trackEvent,
+			body,
+			event,
+			action: "pinned",
+			contextKeySuffix: "added",
+			errorLabel: "pin added"
+		});
+	});
+	ctx.app.event("pin_removed", async ({ event, body }) => {
+		await handleSlackPinEvent({
+			ctx,
+			trackEvent,
+			body,
+			event,
+			action: "unpinned",
+			contextKeySuffix: "removed",
+			errorLabel: "pin removed"
+		});
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/reactions.ts
+function shouldEmitSlackReactionNotification(params) {
+	const { ctx, event, actorName } = params;
+	if (ctx.reactionMode === "off") return false;
+	if (ctx.reactionMode === "own") return Boolean(ctx.botUserId && event.item_user === ctx.botUserId);
+	if (ctx.reactionMode === "allowlist") {
+		const allowList = normalizeAllowListLower(ctx.reactionAllowlist);
+		if (allowList.length === 0) return false;
+		return allowListMatches({
+			allowList,
+			id: event.user,
+			name: actorName,
+			allowNameMatching: ctx.allowNameMatching
+		});
+	}
+	return ctx.reactionMode === "all";
+}
+function registerSlackReactionEvents(params) {
+	const { ctx, trackEvent } = params;
+	const handleReactionEvent = async (event, action) => {
+		try {
+			const item = event.item;
+			if (!item || item.type !== "message") return;
+			if (ctx.reactionMode === "off") return;
+			if (ctx.reactionMode === "own" && (!ctx.botUserId || event.item_user !== ctx.botUserId)) return;
+			trackEvent?.();
+			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]);
+			if (!shouldEmitSlackReactionNotification({
+				ctx,
+				event,
+				actorName: actorInfo?.name
+			})) return;
+			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}`;
+			const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
+			enqueueSystemEvent(text, {
+				sessionKey: ingressContext.sessionKey,
+				contextKey: `slack:reaction:${action}:${item.channel}:${item.ts}:${event.user}:${emojiLabel}`
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack reaction handler failed: ${formatErrorMessage(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 extensions/slack/src/monitor/events.ts
+function registerSlackMonitorEvents(params) {
+	registerSlackMessageEvents({
+		ctx: params.ctx,
+		handleSlackMessage: params.handleSlackMessage
+	});
+	registerSlackReactionEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackMemberEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackChannelEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackPinEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackHomeEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackInteractionEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackAssistantEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/inbound-delivery-state.ts
+const deliveredMessages = createPersistentDedupeCache({
+	globalKey: Symbol.for("openclaw.slackInboundDeliveries"),
+	ttlMs: 864e5,
+	maxSize: 2e4,
+	persistent: {
+		namespace: "slack.inbound-deliveries",
+		maxEntries: 2e4,
+		openStore: (options) => getOptionalSlackRuntime()?.state.openKeyedStore(options),
+		logError: (error) => {
+			try {
+				getOptionalSlackRuntime()?.logging.getChildLogger({
+					plugin: "slack",
+					feature: "inbound-delivery-state"
+				}).warn("Slack persistent inbound delivery state failed", { error: String(error) });
+			} catch {}
+		}
+	}
+});
+function makeKey(accountId, channelId, ts) {
+	return `${accountId}:${channelId}:${ts}`;
+}
+async function hasSlackInboundMessageDelivery(params) {
+	if (!params.accountId || !params.channelId || !params.ts) return false;
+	return await deliveredMessages.lookup(makeKey(params.accountId, params.channelId, params.ts));
+}
+async function recordSlackInboundMessageDeliveries(params) {
+	if (!params.accountId || params.messages.length === 0) return;
+	const deliveredAt = Date.now();
+	const keys = /* @__PURE__ */ new Set();
+	for (const message of params.messages) {
+		if (!message.channel || !message.ts) continue;
+		keys.add(makeKey(params.accountId, message.channel, message.ts));
+	}
+	await Promise.all(Array.from(keys, (key) => deliveredMessages.register(key, { deliveredAt }, { at: deliveredAt })));
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/debounce-key.ts
+function resolveSlackSenderId(message) {
+	return message.user ?? message.bot_id ?? null;
+}
+function isSlackDirectMessageChannel(channelId) {
+	return channelId.startsWith("D");
+}
+function isTopLevelSlackMessage(message) {
+	return !message.thread_ts && !message.parent_user_id;
+}
+function buildTopLevelSlackConversationKey(message, accountId) {
+	if (!isTopLevelSlackMessage(message)) return null;
+	const senderId = resolveSlackSenderId(message);
+	if (!senderId) return null;
+	return `slack:${accountId}:${message.channel}:${senderId}`;
+}
+function buildSlackDebounceKey(message, accountId) {
+	const senderId = resolveSlackSenderId(message);
+	if (!senderId) return null;
+	const messageTs = message.ts ?? message.event_ts;
+	return `slack:${accountId}:${message.thread_ts ? `${message.channel}:${message.thread_ts}` : message.parent_user_id && messageTs ? `${message.channel}:maybe-thread:${messageTs}` : messageTs && !isSlackDirectMessageChannel(message.channel) ? `${message.channel}:${messageTs}` : message.channel}:${senderId}`;
+}
+//#endregion
+//#region extensions/slack/src/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;
+};
+const markAmbiguousThreadReply = (message) => ({
+	...message,
+	_ambiguousThreadReply: true
+});
+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
+		});
+		const message = response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0];
+		return normalizeThreadTs(message?.thread_ts);
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`slack inbound: failed to resolve thread_ts via conversations.history for channel=${params.channelId} ts=${params.messageTs}: ${formatSlackError(err)}`);
+		return;
+	}
+}
+function createSlackThreadTsResolver(params) {
+	const ttlMs = Math.max(0, parseFiniteNumber(params.cacheTtlMs) ?? DEFAULT_THREAD_TS_CACHE_TTL_MS);
+	const maxSize = Math.max(0, parseFiniteNumber(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 (entry.expiresAt === 0) {
+			cache.delete(key);
+			cache.set(key, entry);
+			return entry.threadTs;
+		}
+		const normalizedNow = asDateTimestampMs(now);
+		if (normalizedNow === void 0 || asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= normalizedNow) {
+			cache.delete(key);
+			return;
+		}
+		cache.delete(key);
+		cache.set(key, entry);
+		return entry.threadTs;
+	};
+	const setCached = (key, threadTs, now) => {
+		const expiresAt = ttlMs > 0 ? resolveExpiresAtMsFromDurationMs(ttlMs, { nowMs: now }) : 0;
+		if (expiresAt === void 0) {
+			cache.delete(key);
+			return;
+		}
+		cache.delete(key);
+		cache.set(key, {
+			threadTs,
+			expiresAt
+		});
+		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
+		} : markAmbiguousThreadReply(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}; marking reply ambiguous`);
+		return markAmbiguousThreadReply(message);
+	} };
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler.ts
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-qFsXbTJf.mjs"));
+function createSlackDispatchCompletion() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((nextResolve, nextReject) => {
+			resolve = nextResolve;
+			reject = nextReject;
+		}),
+		resolve,
+		reject
+	};
+}
+const APP_MENTION_RETRY_TTL_MS = 6e4;
+const RETRYABLE_FLUSH_MAX_ATTEMPTS = 3;
+const RETRYABLE_FLUSH_RETRY_DELAY_MS = 1e3;
+const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
+var SlackRetryableInboundError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "SlackRetryableInboundError";
+	}
+};
+function isRetryableSlackInboundError(error) {
+	if (error instanceof SlackRetryableInboundError) return true;
+	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)));
+}
+function shouldDebounceSlackMessage(message, cfg) {
+	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
+	return shouldDebounceTextInbound({
+		text: textForCommandDetection,
+		cfg,
+		hasMedia: Boolean(message.files && message.files.length > 0)
+	});
+}
+function buildSeenMessageKey(channelId, ts) {
+	if (!channelId || !ts) return null;
+	return `${channelId}:${ts}`;
+}
+function createSlackMessageHandler(params) {
+	const { ctx, account, trackEvent } = params;
+	const { debounceMs, debouncer } = createChannelInboundDebouncer({
+		cfg: ctx.cfg,
+		channel: "slack",
+		buildKey: (entry) => buildSlackDebounceKey(entry.message, ctx.accountId),
+		shouldDebounce: (entry) => shouldDebounceSlackMessage(entry.message, ctx.cfg),
+		onFlush: async (entries) => {
+			const retryEntries = (sourceError) => {
+				if (!isRetryableSlackInboundError(sourceError)) return false;
+				const nextEntries = entries.map((entry) => {
+					if (entry.opts.dispatchCompletion) return null;
+					const retryAttempt = entry.opts.retryAttempt ?? 0;
+					if (retryAttempt >= RETRYABLE_FLUSH_MAX_ATTEMPTS) return null;
+					const { dispatchCompletion: _dispatchCompletion, ...retryOpts } = entry.opts;
+					return {
+						...entry,
+						opts: {
+							...retryOpts,
+							retryAttempt: retryAttempt + 1
+						}
+					};
+				}).filter((entry) => entry !== null);
+				if (nextEntries.length === 0) return false;
+				setTimeout(() => {
+					for (const entry of nextEntries) enqueueSlackMessage(entry.message, entry.opts).catch((err) => {
+						ctx.runtime.error?.(`slack inbound retry enqueue failed: ${formatErrorMessage(err)}`);
+					});
+				}, RETRYABLE_FLUSH_RETRY_DELAY_MS).unref?.();
+				return true;
+			};
+			const completions = entries.map((entry) => entry.opts.dispatchCompletion).filter((completion) => completion !== void 0);
+			try {
+				await (async () => {
+					const last = entries.at(-1);
+					if (!last) return;
+					const flushedKey = buildSlackDebounceKey(last.message, ctx.accountId);
+					const topLevelConversationKey = buildTopLevelSlackConversationKey(last.message, ctx.accountId);
+					if (flushedKey && topLevelConversationKey) {
+						const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
+						if (pendingKeys) {
+							pendingKeys.delete(flushedKey);
+							if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
+						}
+					}
+					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 syntheticMessage = {
+						...last.message,
+						text: combinedText
+					};
+					const seenMessageKey = buildSeenMessageKey(last.message.channel, last.message.ts);
+					try {
+						const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
+						const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, ...lastOpts } = last.opts;
+						const appMentionRetryKey = seenMessageKey && lastOpts.source === "app_mention" && !ctx.botUserId ? seenMessageKey : void 0;
+						if (appMentionRetryKey) appMentionPreparingKeys.add(appMentionRetryKey);
+						const prepared = await (async () => {
+							try {
+								const result = await prepareSlackMessage({
+									ctx,
+									account,
+									message: syntheticMessage,
+									opts: {
+										...lastOpts,
+										wasMentioned: combinedMentioned || last.opts.wasMentioned,
+										...seenMessageKey && lastOpts.source === "message" ? { shouldRecordDroppedHistory: () => !appMentionPreparingKeys.has(seenMessageKey) && !appMentionDispatchedKeys.has(seenMessageKey) } : {}
+									}
+								});
+								if (result && seenMessageKey) {
+									pruneAppMentionRetryKeys(Date.now());
+									if (last.opts.source === "app_mention") rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
+									else if (last.opts.source === "message" && appMentionDispatchedKeys.has(seenMessageKey)) {
+										appMentionDispatchedKeys.delete(seenMessageKey);
+										appMentionRetryKeys.delete(seenMessageKey);
+										return null;
+									}
+									appMentionRetryKeys.delete(seenMessageKey);
+								}
+								return result;
+							} finally {
+								if (appMentionRetryKey) appMentionPreparingKeys.delete(appMentionRetryKey);
+							}
+						})();
+						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];
+							}
+						}
+						try {
+							await dispatchPreparedSlackMessage(prepared);
+							await recordSlackInboundMessageDeliveries({
+								accountId: ctx.accountId,
+								messages: entries.map((entry) => entry.message)
+							});
+						} catch (error) {
+							if (!isRetryableSlackInboundError(error)) await recordSlackInboundMessageDeliveries({
+								accountId: ctx.accountId,
+								messages: entries.map((entry) => entry.message)
+							});
+							throw error;
+						}
+					} catch (error) {
+						if (isRetryableSlackInboundError(error)) for (const entry of entries) {
+							const entrySeenKey = buildSeenMessageKey(entry.message.channel, entry.message.ts);
+							if (entrySeenKey) appMentionDispatchedKeys.delete(entrySeenKey);
+							ctx.releaseSeenMessage(entry.message.channel, entry.message.ts);
+						}
+						throw error;
+					}
+				})();
+				for (const completion of completions) completion.resolve();
+			} catch (error) {
+				retryEntries(error);
+				for (const completion of completions) completion.reject(error);
+				throw error;
+			}
+		},
+		onError: (err) => {
+			ctx.runtime.error?.(`slack inbound debounce flush failed: ${formatErrorMessage(err)}`);
+		}
+	});
+	const threadTsResolver = createSlackThreadTsResolver({ client: ctx.app.client });
+	const pendingTopLevelDebounceKeys = /* @__PURE__ */ new Map();
+	const appMentionRetryKeys = /* @__PURE__ */ new Map();
+	const appMentionPreparingKeys = /* @__PURE__ */ new Set();
+	const appMentionDispatchedKeys = /* @__PURE__ */ new Map();
+	const pruneAppMentionRetryKeys = (rawNow) => {
+		const now = asDateTimestampMs(rawNow);
+		if (now === void 0) {
+			appMentionRetryKeys.clear();
+			appMentionDispatchedKeys.clear();
+			return false;
+		}
+		for (const [key, expiresAt] of appMentionRetryKeys) if (asDateTimestampMs(expiresAt) === void 0 || expiresAt <= now) appMentionRetryKeys.delete(key);
+		for (const [key, expiresAt] of appMentionDispatchedKeys) if (asDateTimestampMs(expiresAt) === void 0 || expiresAt <= now) appMentionDispatchedKeys.delete(key);
+		return true;
+	};
+	const rememberExpiringAppMentionKey = (map, key) => {
+		const now = Date.now();
+		if (!pruneAppMentionRetryKeys(now)) return;
+		const expiresAt = resolveExpiresAtMsFromDurationMs(APP_MENTION_RETRY_TTL_MS, { nowMs: now });
+		if (expiresAt !== void 0) map.set(key, expiresAt);
+	};
+	const rememberAppMentionRetryKey = (key) => {
+		rememberExpiringAppMentionKey(appMentionRetryKeys, key);
+	};
+	const consumeAppMentionRetryKey = (key) => {
+		if (!pruneAppMentionRetryKeys(Date.now())) return false;
+		if (!appMentionRetryKeys.has(key)) return false;
+		appMentionRetryKeys.delete(key);
+		return true;
+	};
+	async function enqueueSlackMessage(message, opts) {
+		if (opts.source === "message" && message.type !== "message") return;
+		if (opts.source === "message" && message.subtype && message.subtype !== "file_share" && message.subtype !== "bot_message" && message.subtype !== "thread_broadcast") return;
+		const seenMessageKey = buildSeenMessageKey(message.channel, message.ts);
+		if (seenMessageKey && await hasSlackInboundMessageDelivery({
+			accountId: ctx.accountId,
+			channelId: message.channel,
+			ts: message.ts
+		})) return;
+		const wasSeen = seenMessageKey ? ctx.markMessageSeen(message.channel, message.ts) : false;
+		if (seenMessageKey && opts.source === "message" && !wasSeen) rememberAppMentionRetryKey(seenMessageKey);
+		if (seenMessageKey && wasSeen) {
+			if (opts.source !== "app_mention" || !consumeAppMentionRetryKey(seenMessageKey)) return;
+		}
+		trackEvent?.();
+		const resolvedMessage = await threadTsResolver.resolve({
+			message,
+			source: opts.source
+		});
+		const debounceKey = buildSlackDebounceKey(resolvedMessage, ctx.accountId);
+		const conversationKey = buildTopLevelSlackConversationKey(resolvedMessage, ctx.accountId);
+		const canDebounce = debounceMs > 0 && shouldDebounceSlackMessage(resolvedMessage, ctx.cfg);
+		if (!canDebounce && conversationKey) {
+			const pendingKeys = pendingTopLevelDebounceKeys.get(conversationKey);
+			if (pendingKeys && pendingKeys.size > 0) {
+				const keysToFlush = Array.from(pendingKeys);
+				for (const pendingKey of keysToFlush) await debouncer.flushKey(pendingKey);
+			}
+		}
+		if (canDebounce && debounceKey && conversationKey) {
+			const pendingKeys = pendingTopLevelDebounceKeys.get(conversationKey) ?? /* @__PURE__ */ new Set();
+			pendingKeys.add(debounceKey);
+			pendingTopLevelDebounceKeys.set(conversationKey, pendingKeys);
+		}
+		const dispatchCompletion = opts.awaitDispatch ? createSlackDispatchCompletion() : void 0;
+		await debouncer.enqueue({
+			message: resolvedMessage,
+			opts: {
+				...opts,
+				...dispatchCompletion ? { dispatchCompletion: {
+					resolve: dispatchCompletion.resolve,
+					reject: dispatchCompletion.reject
+				} } : {}
+			}
+		});
+		return dispatchCompletion;
+	}
+	return async (message, opts) => {
+		await (await enqueueSlackMessage(message, opts))?.promise;
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/reconnect-policy.ts
+const SLACK_AUTH_ERROR_RE = /account_inactive|invalid_auth|token_revoked|token_expired|not_authed|org_login_required|team_access_not_granted|user_removed_from_team|team_disabled|missing_scope|cannot_find_service|invalid_token/i;
+const NO_ERROR_DETAIL = "no error detail";
+const SLACK_SOCKET_RECONNECT_POLICY = {
+	initialMs: 2e3,
+	maxMs: 3e4,
+	factor: 1.8,
+	jitter: .25
+};
+const SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL = "https://docs.slack.dev/apis/events-api/using-socket-mode#using-multiple-connections";
+const SLACK_SOCKET_HELLO_MARKER = Buffer.from("\"hello\"");
+function getSocketEmitter(app) {
+	const receiver = app.receiver;
+	const client = receiver && typeof receiver === "object" ? receiver.client : void 0;
+	if (!client || typeof client !== "object") return null;
+	const on = client.on;
+	const off = client.off;
+	if (typeof on !== "function" || typeof off !== "function") return null;
+	return {
+		on: (event, listener) => on.call(client, event, listener),
+		off: (event, listener) => off.call(client, event, listener)
+	};
+}
+function isBufferArray(value) {
+	return Array.isArray(value) && value.every((entry) => Buffer.isBuffer(entry));
+}
+function resolveSlackSocketModeConnectionCount(message) {
+	const buffer = Buffer.isBuffer(message) ? message : message instanceof ArrayBuffer ? Buffer.from(message) : isBufferArray(message) ? Buffer.concat(message) : void 0;
+	if (!buffer?.includes(SLACK_SOCKET_HELLO_MARKER)) return;
+	let payload;
+	try {
+		payload = JSON.parse(buffer.toString("utf8"));
+	} catch {
+		return;
+	}
+	const count = isRecord(payload) && payload.type === "hello" ? payload.num_connections : void 0;
+	return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : void 0;
+}
+function formatSlackSocketModeSharedConnectionWarning(activeConnections) {
+	return [
+		`slack socket mode reports ${activeConnections} active connections for this Slack app`,
+		"Slack may deliver each event to any one connection",
+		"ensure every OpenClaw gateway sharing this app has equivalent routing and authorization, or use a separate Slack app per gateway, one relay ingress, or HTTP Request URLs behind a load balancer",
+		`See ${SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL}`
+	].join("; ");
+}
+function registerSlackSocketModeConnectionDiagnostics(params) {
+	const emitter = getSocketEmitter(params.app);
+	if (!emitter) return () => {};
+	let hasWarned = false;
+	const listener = (message, isBinary) => {
+		if (isBinary === true || hasWarned) return;
+		const activeConnections = resolveSlackSocketModeConnectionCount(message);
+		if (activeConnections === void 0 || activeConnections <= 1) return;
+		hasWarned = true;
+		params.onSharedConnection(activeConnections);
+	};
+	emitter.on("ws_message", listener);
+	return () => {
+		emitter.off("ws_message", listener);
+	};
+}
+function waitForSlackSocketDisconnect(app, abortSignal) {
+	return new Promise((resolve) => {
+		const emitter = getSocketEmitter(app);
+		if (!emitter) {
+			abortSignal?.addEventListener("abort", () => resolve({ event: "disconnect" }), { once: true });
+			return;
+		}
+		const disconnectListener = () => resolveOnce({ event: "disconnect" });
+		const startFailListener = (error) => resolveOnce({
+			event: "unable_to_socket_mode_start",
+			error
+		});
+		const errorListener = (error) => resolveOnce({
+			event: "error",
+			error
+		});
+		const abortListener = () => resolveOnce({ event: "disconnect" });
+		const cleanup = () => {
+			emitter.off("disconnected", disconnectListener);
+			emitter.off("unable_to_socket_mode_start", startFailListener);
+			emitter.off("error", errorListener);
+			abortSignal?.removeEventListener("abort", abortListener);
+		};
+		const resolveOnce = (value) => {
+			cleanup();
+			resolve(value);
+		};
+		emitter.on("disconnected", disconnectListener);
+		emitter.on("unable_to_socket_mode_start", startFailListener);
+		emitter.on("error", errorListener);
+		abortSignal?.addEventListener("abort", abortListener, { once: true });
+	});
+}
+/**
+* Detect permanent Slack account and credential failures.
+* Transient request and HTTP failures stay in OpenClaw's reconnect loop.
+*/
+function isNonRecoverableSlackAuthError(error) {
+	return SLACK_AUTH_ERROR_RE.test(formatUnknownError(error, ""));
+}
+function formatUnknownError(error, fallback = NO_ERROR_DETAIL) {
+	return formatSlackError(error, fallback);
+}
+//#endregion
+//#region extensions/slack/src/monitor/provider-support.ts
+const OPENCLAW_SLACK_CLIENT_PING_TIMEOUT_MS = 15e3;
+const OPENCLAW_SLACK_SOCKET_START_FAILED_EVENT = "unable_to_socket_mode_start";
+const OPENCLAW_SLACK_NATIVE_RECONNECT_OBSERVER_KEY = "__openclawNativeReconnectFailureObserver";
+const SLACK_SOCKET_PONG_TIMEOUT_WARNING_PREFIX = "A pong wasn't received from the server";
+const SLACK_SOCKET_PING_TIMEOUT_WARNING_PREFIX = "A ping wasn't received from the server";
+const SLACK_SOCKET_LOG_LEVEL_IGNORED_WARNING_RE = /^The logLevel given to .+ was ignored as you also gave logger$/;
+function isConstructorFunction(value) {
+	return typeof value === "function";
+}
+function installSlackNativeReconnectFailureObserver(receiver) {
+	if (!receiver || typeof receiver !== "object") return;
+	const client = Reflect.get(receiver, "client");
+	if (!client || typeof client !== "object") return;
+	if (Reflect.get(client, OPENCLAW_SLACK_NATIVE_RECONNECT_OBSERVER_KEY)) return;
+	const delayReconnectAttempt = Reflect.get(client, "delayReconnectAttempt");
+	const emit = Reflect.get(client, "emit");
+	if (typeof delayReconnectAttempt !== "function" || typeof emit !== "function") return;
+	Reflect.set(client, OPENCLAW_SLACK_NATIVE_RECONNECT_OBSERVER_KEY, true);
+	Reflect.set(client, "delayReconnectAttempt", function patchedDelayReconnectAttempt(callback) {
+		if (typeof callback !== "function") return delayReconnectAttempt.call(this, callback);
+		const nextFailureCount = Number(Reflect.get(this, "numOfConsecutiveReconnectionFailures") ?? 0) + 1;
+		Reflect.set(this, "numOfConsecutiveReconnectionFailures", nextFailureCount);
+		const pingTimeoutMs = Number(Reflect.get(this, "clientPingTimeoutMS"));
+		const delayMs = (Number.isFinite(pingTimeoutMs) && pingTimeoutMs >= 0 ? pingTimeoutMs : OPENCLAW_SLACK_CLIENT_PING_TIMEOUT_MS) * nextFailureCount;
+		const logger = Reflect.get(this, "logger");
+		logger?.debug?.(`Before trying to reconnect, this client will wait for ${delayMs} milliseconds`);
+		return new Promise((resolve, reject) => {
+			setTimeout(() => {
+				if (Reflect.get(this, "shuttingDown")) {
+					logger?.debug?.("Client shutting down, will not attempt reconnect.");
+					resolve(void 0);
+					return;
+				}
+				logger?.debug?.("Continuing with reconnect...");
+				emit.call(this, "reconnecting");
+				Promise.resolve(callback.call(this)).then(resolve, (error) => {
+					if (callback === Reflect.get(this, "start")) {
+						emit.call(this, OPENCLAW_SLACK_SOCKET_START_FAILED_EVENT, error);
+						resolve(void 0);
+						return;
+					}
+					reject(toLintErrorObject(error, "Non-Error rejection"));
+				});
+			}, delayMs);
+		});
+	});
+}
+function createSlackRelayReceiver() {
+	return {
+		init() {},
+		start: () => Promise.resolve(void 0),
+		stop: () => Promise.resolve(void 0)
+	};
+}
+function resolveSlackBoltModule(value) {
+	if (!value || typeof value !== "object") return null;
+	const app = Reflect.get(value, "App");
+	const httpReceiver = Reflect.get(value, "HTTPReceiver");
+	const socketModeReceiver = Reflect.get(value, "SocketModeReceiver");
+	if (!isConstructorFunction(app) || !isConstructorFunction(httpReceiver) || !isConstructorFunction(socketModeReceiver)) return null;
+	return {
+		App: app,
+		HTTPReceiver: httpReceiver,
+		SocketModeReceiver: socketModeReceiver
+	};
+}
+function resolveSlackBoltInterop(params) {
+	const { defaultImport, namespaceImport } = params;
+	const nestedDefault = defaultImport && typeof defaultImport === "object" ? Reflect.get(defaultImport, "default") : void 0;
+	const namespaceDefault = namespaceImport && typeof namespaceImport === "object" ? Reflect.get(namespaceImport, "default") : void 0;
+	const namespaceReceiver = namespaceImport && typeof namespaceImport === "object" ? Reflect.get(namespaceImport, "HTTPReceiver") : void 0;
+	const namespaceSocketModeReceiver = namespaceImport && typeof namespaceImport === "object" ? Reflect.get(namespaceImport, "SocketModeReceiver") : void 0;
+	const directModule = resolveSlackBoltModule(defaultImport) ?? resolveSlackBoltModule(nestedDefault) ?? resolveSlackBoltModule(namespaceDefault) ?? resolveSlackBoltModule(namespaceImport);
+	if (directModule) return directModule;
+	if (isConstructorFunction(defaultImport) && isConstructorFunction(namespaceReceiver) && isConstructorFunction(namespaceSocketModeReceiver)) return {
+		App: defaultImport,
+		HTTPReceiver: namespaceReceiver,
+		SocketModeReceiver: namespaceSocketModeReceiver
+	};
+	throw new TypeError("Unable to resolve @slack/bolt App/HTTPReceiver exports");
+}
+function publishSlackConnectedStatus(setStatus) {
+	if (!setStatus) return;
+	setStatus({
+		connected: true,
+		lastConnectedAt: Date.now(),
+		healthState: "healthy",
+		lastError: null
+	});
+}
+function publishSlackDisconnectedStatus(setStatus, error) {
+	if (!setStatus) return;
+	const at = Date.now();
+	const message = error ? formatUnknownError(error) : void 0;
+	setStatus({
+		connected: false,
+		healthState: "disconnected",
+		lastDisconnect: message ? {
+			at,
+			error: message
+		} : { at },
+		lastError: message ?? null
+	});
+}
+function isSlackSocketHeartbeatTimeoutWarning(args) {
+	return typeof args[0] === "string" && (args[0].startsWith(SLACK_SOCKET_PONG_TIMEOUT_WARNING_PREFIX) || args[0].startsWith(SLACK_SOCKET_PING_TIMEOUT_WARNING_PREFIX));
+}
+function isSlackSocketSelfInflictedLoggerWarning(args) {
+	return typeof args[0] === "string" && SLACK_SOCKET_LOG_LEVEL_IGNORED_WARNING_RE.test(args[0]);
+}
+function formatSlackSdkLogArgs(args) {
+	return args.map((arg) => formatUnknownError(arg, "")).filter(Boolean).join(" ");
+}
+function createSlackSocketModeLogger(sink = console) {
+	let level = "info";
+	let name = "socket-mode";
+	const prefix = () => `socket-mode:${name}`;
+	let lastMessage;
+	const remember = (args) => {
+		const message = formatSlackSdkLogArgs([prefix(), ...args]);
+		if (message) lastMessage = message;
+	};
+	return {
+		debug: () => {},
+		info: () => {},
+		warn: (...args) => {
+			if (isSlackSocketHeartbeatTimeoutWarning(args) || isSlackSocketSelfInflictedLoggerWarning(args)) return;
+			remember(args);
+			sink.warn(prefix(), ...args);
+		},
+		error: (...args) => {
+			remember(args);
+			sink.error(prefix(), ...args);
+		},
+		setLevel: (nextLevel) => {
+			level = nextLevel;
+		},
+		getLevel: () => level,
+		setName: (nextName) => {
+			name = nextName;
+		},
+		getLastMessage: () => lastMessage
+	};
+}
+function shouldSkipOpenClawSlackSelfEvent(args) {
+	const botId = args.context?.botId;
+	const botUserId = args.context?.botUserId;
+	const message = asOptionalRecord(args.message);
+	if (message?.subtype === "bot_message" && botId && message.bot_id === botId) return true;
+	const event = asOptionalRecord(args.event);
+	if (event?.type === "message" && event.subtype === "message_changed" && event.user === botUserId) return false;
+	const eventsWhichShouldBeKept = /* @__PURE__ */ new Set(["member_joined_channel", "member_left_channel"]);
+	return Boolean(botUserId && event && event.user === botUserId && typeof event.type === "string" && !eventsWhichShouldBeKept.has(event.type));
+}
+function createSlackBoltApp(params) {
+	const socketModeLogger = createSlackSocketModeLogger();
+	const socketModeReceiverOptions = {
+		appToken: params.appToken ?? "",
+		autoReconnectEnabled: true,
+		clientPingTimeout: params.socketMode?.clientPingTimeout ?? OPENCLAW_SLACK_CLIENT_PING_TIMEOUT_MS,
+		logger: socketModeLogger,
+		installerOptions: { clientOptions: params.clientOptions }
+	};
+	if (params.socketMode?.serverPingTimeout !== void 0) socketModeReceiverOptions.serverPingTimeout = params.socketMode.serverPingTimeout;
+	if (params.socketMode?.pingPongLoggingEnabled !== void 0) socketModeReceiverOptions.pingPongLoggingEnabled = params.socketMode.pingPongLoggingEnabled;
+	let receiver;
+	if (params.slackMode === "socket") {
+		receiver = new params.interop.SocketModeReceiver(socketModeReceiverOptions);
+		installSlackNativeReconnectFailureObserver(receiver);
+	} else if (params.slackMode === "http") receiver = new params.interop.HTTPReceiver({
+		signingSecret: params.signingSecret ?? "",
+		endpoints: params.slackWebhookPath
+	});
+	else receiver = createSlackRelayReceiver();
+	const app = new params.interop.App({
+		token: params.botToken,
+		clientOptions: params.clientOptions,
+		ignoreSelf: false,
+		tokenVerificationEnabled: false,
+		...receiver ? { receiver } : {}
+	});
+	app.use(async (args) => {
+		if (shouldSkipOpenClawSlackSelfEvent(args)) return;
+		await args.next();
+	});
+	return {
+		app,
+		receiver,
+		socketModeLogger
+	};
+}
+function createSlackSocketDisconnectWaiter(app, abortSignal) {
+	const waiterAbortController = new AbortController();
+	const relayAbort = () => waiterAbortController.abort();
+	let latest;
+	abortSignal?.addEventListener("abort", relayAbort, { once: true });
+	return {
+		promise: waitForSlackSocketDisconnect(app, waiterAbortController.signal).then((value) => {
+			latest = value;
+			return value;
+		}),
+		getLatest: () => latest,
+		cancel: () => {
+			waiterAbortController.abort();
+			abortSignal?.removeEventListener("abort", relayAbort);
+		},
+		complete: () => {
+			abortSignal?.removeEventListener("abort", relayAbort);
+		}
+	};
+}
+async function startSlackSocketAndWaitForDisconnect(params) {
+	const disconnectWaiter = createSlackSocketDisconnectWaiter(params.app, params.abortSignal);
+	try {
+		await Promise.resolve(params.app.start());
+		if (params.abortSignal?.aborted) {
+			disconnectWaiter.cancel();
+			return null;
+		}
+		params.onStarted?.();
+		const disconnect = await disconnectWaiter.promise;
+		disconnectWaiter.complete();
+		return disconnect;
+	} catch (err) {
+		await Promise.resolve();
+		const disconnect = disconnectWaiter.getLatest();
+		disconnectWaiter.cancel();
+		if (isMissingSocketStartErrorDetail(err) && disconnect?.error !== void 0) throw toLintErrorObject(disconnect.error, "Non-Error thrown");
+		if (isMissingSocketStartErrorDetail(err)) {
+			const suffix = disconnect ? ` after ${disconnect.event}` : "";
+			throw new Error(`Slack Socket Mode start failed${suffix} without error detail`, { cause: err });
+		}
+		throw err;
+	}
+}
+function isMissingSocketStartErrorDetail(err) {
+	return err === void 0 || err === null || err === "" || err instanceof Error && err.message === "";
+}
+function resolveSlackSocketShutdownClient(app) {
+	if (!app || typeof app !== "object") return;
+	const receiver = Reflect.get(app, "receiver");
+	if (!receiver || typeof receiver !== "object") return;
+	const client = Reflect.get(receiver, "client");
+	if (!client || typeof client !== "object") return;
+	return client;
+}
+async function gracefulStopSlackApp(app) {
+	const socketClient = resolveSlackSocketShutdownClient(app);
+	if (socketClient) socketClient.shuttingDown = true;
+	await Promise.resolve(app.stop()).catch(() => void 0);
+}
+function formatSlackResolvedLabel(params) {
+	const extras = params.extra?.filter(Boolean) ?? [];
+	const suffix = extras.length > 0 ? ` (id:${params.id}, ${extras.join(", ")})` : ` (id:${params.id})`;
+	return `${params.input}→${params.name ?? params.id}${suffix}`;
+}
+function formatSlackChannelResolved(entry) {
+	const id = entry.id ?? entry.input;
+	return formatSlackResolvedLabel({
+		input: entry.input,
+		id,
+		name: entry.name,
+		extra: entry.archived ? ["archived"] : []
+	});
+}
+function formatSlackUserResolved(entry) {
+	const id = entry.id ?? entry.input;
+	return formatSlackResolvedLabel({
+		input: entry.input,
+		id,
+		name: entry.name,
+		extra: entry.note ? [entry.note] : []
+	});
+}
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
+//#endregion
+//#region extensions/slack/src/monitor/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" && params.allowFromLower.includes("*")) 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 createChannelPairingChallengeIssuer({
+			channel: "slack",
+			accountId: params.accountId,
+			upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+				channel: "slack",
+				id,
+				accountId: params.accountId,
+				meta
+			})
+		})({
+			senderId: params.senderId,
+			senderIdLine: `Your Slack user id: ${params.senderId}`,
+			meta: { name: senderName },
+			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}: ${formatErrorMessage(err)}`);
+			}
+		});
+		return false;
+	}
+	await params.onUnauthorized({
+		allowMatchMeta,
+		senderName
+	});
+	return false;
+}
+//#endregion
+//#region extensions/slack/src/monitor/external-arg-menu-store.ts
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES = 18;
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN = new RegExp(`^[A-Za-z0-9_-]{${Math.ceil(24)}}$`);
+const SLACK_EXTERNAL_ARG_MENU_TTL_MS = 6e5;
+const SLACK_EXTERNAL_ARG_MENU_PREFIX = "openclaw_cmdarg_ext:";
+function pruneSlackExternalArgMenuStore(store, rawNow) {
+	const now = asDateTimestampMs(rawNow);
+	if (now === void 0) {
+		store.clear();
+		return;
+	}
+	for (const [token, entry] of store.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || 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);
+			const expiresAt = resolveExpiresAtMsFromDurationMs(SLACK_EXTERNAL_ARG_MENU_TTL_MS, { nowMs: now });
+			if (expiresAt !== void 0) store.set(token, {
+				choices: params.choices,
+				userId: params.userId,
+				expiresAt
+			});
+			return token;
+		},
+		readToken(raw) {
+			if (typeof raw !== "string" || !raw.startsWith("openclaw_cmdarg_ext:")) return;
+			const token = raw.slice(20).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 extensions/slack/src/monitor/room-context.ts
+function resolveSlackRoomContextHints(params) {
+	const untrustedChannelMetadata = params.isRoomish ? buildUntrustedChannelMetadata({
+		source: "slack",
+		label: "Slack channel description",
+		entries: [params.channelInfo?.topic, params.channelInfo?.purpose]
+	}) : void 0;
+	const systemPromptParts = [params.isRoomish ? normalizeOptionalString(params.channelConfig?.systemPrompt) ?? null : null].filter((entry) => Boolean(entry));
+	return {
+		untrustedChannelMetadata,
+		groupSystemPrompt: systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : void 0
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/slash.ts
+const SLACK_COMMAND_ARG_ACTION_ID = "openclaw_cmdarg";
+const SLACK_COMMAND_ARG_ACTION_LISTENER = /^openclaw_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_TEXT_MAX = 75;
+const SLACK_COMMAND_ARG_SELECT_OPTION_VALUE_MAX = 150;
+const SLACK_COMMAND_ARG_BUTTON_TEXT_MAX = 75;
+const SLACK_COMMAND_ARG_BUTTON_VALUE_MAX = 2e3;
+const SLACK_COMMAND_ARG_CONFIRM_TEXT_MAX = 300;
+const SLACK_HEADER_TEXT_MAX = 150;
+const SLACK_COMMAND_ARG_ACTION_BLOCKS_MAX = 47;
+const loadSlashCommandsRuntime = createLazyRuntimeModule(() => import("./slash-commands.runtime-BTTMlmwy.mjs"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-eyQo6mTA.mjs"));
+const loadSlackPluginCommandsRuntime = createLazyRuntimeModule(() => import("./slash-plugin-commands.runtime-Dosfcx3X.mjs"));
+const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.mjs"));
+function resolveSlackCommandMenuModelContext(params) {
+	if (!params.sessionKey.trim()) return {};
+	try {
+		const defaultModel = resolveDefaultModelForAgent({
+			cfg: params.cfg,
+			agentId: params.agentId
+		});
+		const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.agentId });
+		const entry = getSessionEntry({
+			storePath,
+			sessionKey: params.sessionKey
+		});
+		let provider;
+		let model;
+		if (entry?.modelOverrideSource === "auto" && normalizeOptionalString(entry.modelOverride)) {
+			provider = defaultModel.provider;
+			model = defaultModel.model;
+		} else {
+			const override = resolveStoredModelOverride({
+				sessionEntry: entry,
+				loadSessionEntry: (sessionKey) => getSessionEntry({
+					storePath,
+					sessionKey
+				}),
+				sessionKey: params.sessionKey,
+				defaultProvider: defaultModel.provider
+			});
+			provider = override?.model ? override.provider || defaultModel.provider : normalizeOptionalString(entry?.providerOverride) ?? normalizeOptionalString(entry?.modelProvider);
+			model = override?.model ? override.model : normalizeOptionalString(entry?.modelOverride) ?? normalizeOptionalString(entry?.model);
+		}
+		return {
+			...provider ? { provider } : {},
+			...model ? { model } : {},
+			agentRuntime: resolveEffectiveAgentRuntime({
+				cfg: params.cfg,
+				provider: provider ?? defaultModel.provider,
+				modelId: model ?? defaultModel.model,
+				agentId: params.agentId,
+				sessionKey: params.sessionKey,
+				sessionEntry: entry
+			})
+		};
+	} catch {
+		return {};
+	}
+}
+const slackExternalArgMenuStore = createSlackExternalArgMenuStore();
+function buildSlackArgMenuConfirm(params) {
+	const command = escapeSlackMrkdwn(params.command);
+	const arg = escapeSlackMrkdwn(params.arg);
+	return {
+		title: {
+			type: "plain_text",
+			text: "Confirm selection"
+		},
+		text: {
+			type: "mrkdwn",
+			text: truncateSlackText(`Run */${command}* with *${arg}* set to this value?`, SLACK_COMMAND_ARG_CONFIRM_TEXT_MAX)
+		},
+		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);
+}
+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: truncateSlackText(choice.label, SLACK_COMMAND_ARG_SELECT_OPTION_TEXT_MAX)
+		},
+		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.filter((choice) => choice.value.length <= SLACK_COMMAND_ARG_BUTTON_VALUE_MAX), SLACK_COMMAND_ARG_BUTTON_ROW_SIZE).map((choices, rowIndex) => ({
+		type: "actions",
+		elements: choices.map((choice, colIndex) => ({
+			type: "button",
+			action_id: `${SLACK_COMMAND_ARG_ACTION_ID}_${rowIndex}_${colIndex}`,
+			text: {
+				type: "plain_text",
+				text: truncateSlackText(choice.label, SLACK_COMMAND_ARG_BUTTON_TEXT_MAX)
+			},
+			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 = truncateSlackText(`/${params.command}: choose ${params.arg}`, SLACK_HEADER_TEXT_MAX);
+	const sectionText = truncateSlackText(params.title, 3e3);
+	const contextText = truncateSlackText(`Select one option to continue /${params.command} (${params.arg})`, 3e3);
+	const visibleRows = rows.slice(0, SLACK_COMMAND_ARG_ACTION_BLOCKS_MAX);
+	return [
+		{
+			type: "header",
+			text: {
+				type: "plain_text",
+				text: headerText
+			}
+		},
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: sectionText
+			}
+		},
+		{
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: contextText
+			}]
+		},
+		...visibleRows
+	];
+}
+async function registerSlackMonitorSlashCommands(params) {
+	const { ctx, account, trackEvent } = params;
+	const startupCfg = ctx.cfg;
+	const runtime = ctx.runtime;
+	const supportsInteractiveArgMenus = typeof ctx.app.action === "function";
+	let supportsExternalArgMenus = typeof ctx.app.options === "function";
+	const slashCommand = resolveSlackSlashCommandConfig(ctx.slashCommand ?? account.config.slashCommand);
+	const handleSlashCommand = async (p) => {
+		const { command, ack, respond, body, prompt, commandArgs, commandDefinition } = p;
+		const cfg = getRuntimeConfigSnapshot() ?? ctx.cfg;
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent?.(body)) {
+				await ack();
+				runtime.log?.(`slack: drop slash command from user=${command.user_id ?? "unknown"} channel=${command.channel_id ?? "unknown"} (mismatched app/team)`);
+				return;
+			}
+			trackEvent?.();
+			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 chatType = resolveSlackChatType(channelType);
+			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 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,
+					channelKeys: ctx.channelsConfigKeys,
+					defaultRequireMention: ctx.defaultRequireMention,
+					allowNameMatching: ctx.allowNameMatching
+				});
+				if (ctx.useAccessGroups) {
+					const channelAllowlistConfigured = (ctx.channelsConfigKeys?.length ?? 0) > 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 slashIngress = await resolveSlackCommandIngress({
+				ctx,
+				senderId: command.user_id,
+				senderName,
+				channelType: channelType ?? "channel",
+				channelId: command.channel_id,
+				ownerAllowFromLower: effectiveAllowFromLower,
+				channelUsers: isRoom ? channelConfig?.users : void 0,
+				allowTextCommands: false,
+				hasControlCommand: false,
+				eventKind: "slash-command",
+				modeWhenAccessGroupsOff: "configured"
+			});
+			const senderGate = slashIngress.senderAccess.gate;
+			if (isRoom && senderGate?.allowed === false) {
+				await respond({
+					text: "You are not authorized to use this command here.",
+					response_type: "ephemeral"
+				});
+				return;
+			}
+			commandAuthorized = slashIngress.commandAccess.authorized;
+			if (isRoomish) {
+				if (ctx.useAccessGroups && !commandAuthorized) {
+					await respond({
+						text: "You are not authorized to use this command.",
+						response_type: "ephemeral"
+					});
+					return;
+				}
+			}
+			let resolvedSlashRoute;
+			const resolveSlashRoute = async () => {
+				if (resolvedSlashRoute) return resolvedSlashRoute;
+				const { resolveAgentRoute } = await loadSlashDispatchRuntime();
+				resolvedSlashRoute = 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
+					}
+				});
+				return resolvedSlashRoute;
+			};
+			if (commandDefinition && supportsInteractiveArgMenus) {
+				const { resolveCommandArgMenu } = await loadSlashCommandsRuntime();
+				const menuNeedsModelContext = !(commandArgs?.raw && !commandArgs.values) && commandDefinition.args?.some((arg) => typeof arg.choices === "function" && commandArgs?.values?.[arg.name] == null);
+				const menuRoute = menuNeedsModelContext ? await resolveSlashRoute() : void 0;
+				const menuModelContext = menuRoute ? resolveSlackCommandMenuModelContext({
+					cfg,
+					agentId: menuRoute.agentId,
+					sessionKey: menuRoute.sessionKey
+				}) : {};
+				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadModelCatalog({
+					config: cfg,
+					readOnly: true
+				}) : void 0;
+				const menu = resolveCommandArgMenu({
+					command: commandDefinition,
+					args: commandArgs,
+					cfg,
+					...menuModelContext,
+					...menuModelCatalog?.length ? { catalog: menuModelCatalog } : {}
+				});
+				if (menu) {
+					const commandLabel = commandDefinition.nativeName ?? commandDefinition.key;
+					const title = formatCommandArgMenuTitle({
+						command: commandDefinition,
+						menu
+					});
+					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 { deliverSlackSlashReplies, dispatchReplyWithDispatcher, finalizeInboundContext, recordInboundSessionMetaSafe, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode } = await loadSlashDispatchRuntime();
+			const route = resolvedSlashRoute ?? 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 { sessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
+				agentId: route.agentId,
+				sessionPrefix: slashCommand.sessionPrefix,
+				userId: command.user_id,
+				targetSessionKey: route.sessionKey,
+				lowercaseSessionKey: true
+			});
+			const slashReplyTarget = !slashCommand.ephemeral && isRoomish ? `channel:${command.channel_id}` : `user:${command.user_id}`;
+			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: chatType,
+				ConversationLabel: resolveConversationLabel({
+					ChatType: chatType,
+					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,
+				GroupSpace: ctx.teamId || void 0,
+				GroupSystemPrompt: groupSystemPrompt,
+				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: sessionKey,
+				CommandTargetSessionKey: commandTargetSessionKey,
+				AccountId: route.accountId,
+				CommandSource: "native",
+				CommandAuthorized: commandAuthorized,
+				OriginatingChannel: "slack",
+				OriginatingTo: slashReplyTarget
+			});
+			await recordInboundSessionMetaSafe({
+				cfg,
+				agentId: route.agentId,
+				sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+				ctx: ctxPayload,
+				onError: (err) => runtime.error?.(danger(`slack slash: failed updating session meta: ${formatErrorMessage(err)}`))
+			});
+			const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
+				cfg,
+				agentId: route.agentId,
+				channel: "slack",
+				accountId: route.accountId,
+				transformReplyPayload: (payload) => {
+					if (payload.isReasoning === true) return null;
+					return isSlackInteractiveRepliesEnabled({
+						cfg,
+						accountId: route.accountId
+					}) ? compileSlackInteractiveReplies(payload) : payload;
+				}
+			});
+			const messageSentHookTarget = ctxPayload.OriginatingTo ?? ctxPayload.To ?? slashReplyTarget;
+			const deliverSlashPayloads = async (replies) => {
+				await deliverSlackSlashReplies({
+					replies,
+					respond,
+					ephemeral: slashCommand.ephemeral,
+					textLimit: ctx.textLimit,
+					messageSentHookTarget,
+					accountId: route.accountId,
+					sessionKeyForInternalHooks: ctxPayload.SessionKey ?? route.sessionKey,
+					isGroup: isRoomish,
+					groupId: isRoomish ? command.channel_id : void 0,
+					chunkMode: resolveChunkMode(cfg, "slack", route.accountId),
+					tableMode: resolveMarkdownTableMode({
+						cfg,
+						channel: "slack",
+						accountId: route.accountId
+					})
+				});
+			};
+			const { counts } = await dispatchReplyWithDispatcher({
+				ctx: ctxPayload,
+				cfg,
+				dispatcherOptions: {
+					...replyPipeline,
+					deliver: async (payload) => deliverSlashPayloads([payload]),
+					onError: (err, info) => {
+						runtime.error?.(danger(`slack slash ${info.kind} reply failed: ${formatSlackError(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: ${formatErrorMessage(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: startupCfg.commands?.native
+	});
+	const nativeSkillsEnabled = resolveNativeSkillsEnabled({
+		providerId: "slack",
+		providerSetting: account.config.commands?.nativeSkills,
+		globalSetting: startupCfg.commands?.nativeSkills
+	});
+	let nativeCommands = [];
+	let slashCommandsRuntime = null;
+	if (nativeEnabled) {
+		slashCommandsRuntime = await loadSlashCommandsRuntime();
+		const skillCommands = nativeSkillsEnabled ? (await loadSlashSkillCommandsRuntime()).listSkillCommandsForAgents({ cfg: startupCfg }) : [];
+		nativeCommands = slashCommandsRuntime.listNativeCommandSpecsForConfig(startupCfg, {
+			skillCommands,
+			provider: "slack"
+		});
+		const existingNativeNames = new Set(normalizeStringEntriesLower(nativeCommands.map((command) => command.name)));
+		const { listProviderPluginCommandSpecs } = await loadSlackPluginCommandsRuntime();
+		for (const pluginCommand of listProviderPluginCommandSpecs("slack")) {
+			const normalizedName = normalizeLowercaseStringOrEmpty(pluginCommand.name);
+			if (!normalizedName || existingNativeNames.has(normalizedName)) continue;
+			existingNativeNames.add(normalizedName);
+			nativeCommands.push(pluginCommand);
+		}
+	}
+	if (nativeCommands.length > 0) {
+		if (!slashCommandsRuntime) throw new Error("Missing commands runtime for native Slack commands.");
+		for (const command of nativeCommands) ctx.app.command(`/${command.name}`, async ({ command: cmd, ack, respond, body }) => {
+			const commandDefinition = slashCommandsRuntime.findCommandByNativeName(command.name, "slack");
+			const rawText = cmd.text?.trim() ?? "";
+			const commandArgs = commandDefinition ? slashCommandsRuntime.parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
+			const prompt = commandDefinition ? slashCommandsRuntime.buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`;
+			await handleSlashCommand({
+				command: cmd,
+				ack,
+				respond,
+				body,
+				prompt,
+				commandArgs,
+				commandDefinition: commandDefinition ?? void 0
+			});
+		});
+	} else if (slashCommand.enabled) ctx.app.command(buildSlackSlashCommandMatcher(slashCommand.name), async ({ command, ack, respond, body }) => {
+		await handleSlashCommand({
+			command,
+			ack,
+			respond,
+			body,
+			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 }) => {
+			if (ctx.shouldDropMismatchedSlackEvent?.(body)) {
+				await ack({ options: [] });
+				runtime.log?.("slack: drop slash arg options payload (mismatched app/team)");
+				return;
+			}
+			trackEvent?.();
+			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 = normalizeLowercaseStringOrEmpty(typedBody.value);
+			await ack({ options: entry.choices.filter((choice) => !query || normalizeLowercaseStringOrEmpty(choice.label).includes(query)).slice(0, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX).map((choice) => ({
+				text: {
+					type: "plain_text",
+					text: truncateSlackText(choice.label, SLACK_COMMAND_ARG_SELECT_OPTION_TEXT_MAX)
+				},
+				value: choice.value
+			})) });
+		});
+	};
+	try {
+		registerArgOptions();
+	} catch (err) {
+		supportsExternalArgMenus = false;
+		runtime.log?.(warn("slack: external arg-menu registration failed; falling back to static slash command menus. Enable verbose logs for details."));
+		logVerbose(`slack: external arg-menu registration failed, falling back to static menus: ${formatErrorMessage(err)}`);
+	}
+	const registerArgAction = (actionId) => {
+		ctx.app.action(actionId, async (args) => {
+			const { ack, body, respond } = args;
+			const action = args.action;
+			await ack();
+			if (ctx.shouldDropMismatchedSlackEvent?.(body)) {
+				runtime.log?.("slack: drop slash arg action payload (mismatched app/team)");
+				return;
+			}
+			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 { buildCommandTextFromArgs, findCommandByNativeName } = await loadSlashCommandsRuntime();
+			const commandDefinition = findCommandByNativeName(parsed.command, "slack");
+			const commandArgs = { values: { [parsed.arg]: parsed.value } };
+			const prompt = commandDefinition ? 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;
+			const commandPayload = {
+				user_id: user?.id ?? "",
+				user_name: userName,
+				channel_id: body.channel?.id ?? "",
+				channel_name: body.channel?.name ?? body.channel?.id ?? "",
+				trigger_id: triggerId
+			};
+			await handleSlashCommand({
+				command: commandPayload,
+				ack: async () => {},
+				respond: respondFn,
+				body,
+				prompt,
+				commandArgs,
+				commandDefinition: commandDefinition ?? void 0
+			});
+		});
+	};
+	registerArgAction(SLACK_COMMAND_ARG_ACTION_LISTENER);
+}
+//#endregion
+//#region extensions/slack/src/monitor/provider.ts
+let slackBoltInterop;
+async function getSlackBoltInterop() {
+	if (!slackBoltInterop) {
+		const slackBoltModule = await import("@slack/bolt");
+		slackBoltInterop = resolveSlackBoltInterop({
+			defaultImport: slackBoltModule.default,
+			namespaceImport: slackBoltModule
+		});
+	}
+	return slackBoltInterop;
+}
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-DR--lDW8.mjs"));
+const SLACK_WEBHOOK_MAX_BODY_BYTES = 1048576;
+const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
+function resolveStableSlackUserIdEntry(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const mention = /^<@([A-Z][A-Z0-9]+)>$/i.exec(trimmed);
+	if (mention) return mention[1]?.toUpperCase();
+	const prefixed = /^(?:slack:|user:)([A-Z][A-Z0-9]+)$/i.exec(trimmed);
+	if (prefixed) return prefixed[1]?.toUpperCase();
+	return /^[UW][A-Z0-9]+$/i.test(trimmed) ? trimmed.toUpperCase() : void 0;
+}
+function resolveStableSlackUserAllowlistEntries(entries) {
+	const resolved = [];
+	for (const input of entries) {
+		const id = resolveStableSlackUserIdEntry(input);
+		if (id) resolved.push({
+			input,
+			resolved: true,
+			id
+		});
+	}
+	return resolved;
+}
+function formatSlackSocketReconnectMessage(params) {
+	const suffix = params.error ? ` (${formatUnknownError(params.error)})` : "";
+	return `slack socket disconnected (${params.event}); reconnecting in ${Math.round(params.delayMs / 1e3)}s (attempt ${params.attempt}/∞)${suffix}`;
+}
+function formatSlackSocketStartRetryMessage(params) {
+	const reason = formatUnknownError(params.error, "Slack Socket Mode start failed without error detail");
+	const sdkContext = params.sdkContext?.trim() ? `; last SDK log: ${params.sdkContext.trim()}` : "";
+	return `slack socket mode failed to start; retry ${params.attempt}/∞ in ${Math.round(params.delayMs / 1e3)}s reason="${reason}${sdkContext}"`;
+}
+function parseApiAppIdFromAppToken(raw) {
+	const token = raw?.trim();
+	if (!token) return;
+	return /^xapp-\d-([a-z0-9]+)-/i.exec(token)?.[1]?.toUpperCase();
+}
+function resolveSlackRelayConfig(params) {
+	const relay = params.relay && typeof params.relay === "object" && !Array.isArray(params.relay) ? params.relay : {};
+	const url = normalizeOptionalString(relay.url);
+	const authToken = normalizeResolvedSecretInputString({
+		value: relay.authToken,
+		path: `channels.slack.accounts.${params.accountId}.relay.authToken`
+	});
+	const gatewayId = normalizeOptionalString(relay.gatewayId);
+	if (!url || !authToken || !gatewayId) throw new Error(`Slack relay mode requires relay.url, relay.authToken, and relay.gatewayId for account "${params.accountId}".`);
+	return {
+		url,
+		authToken,
+		gatewayId
+	};
+}
+async function monitorSlackProvider(opts = {}) {
+	const cfg = opts.config ?? getRuntimeConfig$1();
+	const runtime = opts.runtime ?? createNonExitingRuntime();
+	const account = resolveSlackAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	if (!account.enabled) {
+		runtime.log?.(`[${account.accountId}] slack account disabled; monitor startup skipped`);
+		if (opts.abortSignal?.aborted) return;
+		await new Promise((resolve) => {
+			opts.abortSignal?.addEventListener("abort", () => resolve(), { once: true });
+		});
+		return;
+	}
+	const historyLimit = Math.max(0, account.config.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+	const dmHistoryLimit = Math.max(0, account.config.dmHistoryLimit ?? 0);
+	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 = normalizeResolvedSecretInputString({
+		value: account.config.signingSecret,
+		path: `channels.slack.accounts.${account.accountId}.signingSecret`
+	});
+	const botToken = resolveSlackBotToken(opts.botToken ?? account.botToken);
+	const appToken = resolveSlackAppToken(opts.appToken ?? account.appToken);
+	const relayConfig = slackMode === "relay" ? resolveSlackRelayConfig({
+		relay: account.config.relay,
+		accountId: account.accountId
+	}) : void 0;
+	if (!botToken || slackMode === "socket" && !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).` : slackMode === "relay" ? `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 slackCfg = account.config;
+	const dmConfig = slackCfg.dm;
+	const dmEnabled = dmConfig?.enabled ?? true;
+	const dmPolicy = resolveSlackAccountDmPolicy({
+		cfg,
+		accountId: account.accountId
+	}) ?? "pairing";
+	let allowFrom = resolveSlackAccountAllowFrom({
+		cfg,
+		accountId: account.accountId
+	});
+	const groupDmEnabled = dmConfig?.groupEnabled ?? false;
+	const groupDmChannels = dmConfig?.groupChannels;
+	let channelsConfig = slackCfg.channels;
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+	const providerConfigPresent = cfg.channels?.slack !== void 0;
+	const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy$1({
+		providerConfigPresent,
+		groupPolicy: slackCfg.groupPolicy,
+		defaultGroupPolicy
+	});
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied,
+		providerKey: "slack",
+		accountId: account.accountId,
+		log: (message) => runtime.log?.(warn(message))
+	});
+	const resolveToken = account.userToken || 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 threadRequireExplicitMention = slackCfg.thread?.requireExplicitMention ?? false;
+	const slashCommand = resolveSlackSlashCommandConfig(opts.slashCommand ?? slackCfg.slashCommand);
+	const allowNameMatching = isDangerousNameMatchingEnabled(slackCfg);
+	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: SLACK_TEXT_LIMIT });
+	const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
+	const typingReaction = slackCfg.typingReaction?.trim() ?? "";
+	const mediaMaxBytes = (opts.mediaMaxMb ?? slackCfg.mediaMaxMb ?? 20) * 1024 * 1024;
+	const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
+	const clientOptions = resolveSlackWebClientOptions();
+	const { app, receiver, socketModeLogger } = createSlackBoltApp({
+		interop: await getSlackBoltInterop(),
+		slackMode,
+		botToken,
+		appToken: slackMode === "socket" ? appToken ?? void 0 : void 0,
+		signingSecret: slackMode === "http" ? signingSecret ?? void 0 : void 0,
+		slackWebhookPath,
+		clientOptions,
+		...slackCfg.socketMode ? { socketMode: slackCfg.socketMode } : {}
+	});
+	const gracefulStop = async () => {
+		await gracefulStopSlackApp(app);
+	};
+	const slackHttpHandler = slackMode === "http" && receiver ? async (req, res) => {
+		const httpReceiver = receiver;
+		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(httpReceiver.requestListener(req, res));
+		} catch (err) {
+			if (!guard.isTripped()) throw err;
+		} finally {
+			guard.dispose();
+		}
+	} : null;
+	let unregisterHttpHandler = null;
+	const unregisterSocketModeConnectionDiagnostics = slackMode === "socket" ? registerSlackSocketModeConnectionDiagnostics({
+		app,
+		onSharedConnection: (activeConnections) => {
+			runtime.log?.(warn(formatSlackSocketModeSharedConnectionWarning(activeConnections)));
+		}
+	}) : () => {};
+	let botUserId = "";
+	let botId = "";
+	let teamId = "";
+	let apiAppId = "";
+	const expectedApiAppIdFromAppToken = slackMode === "socket" ? parseApiAppIdFromAppToken(appToken) : void 0;
+	let authTestFailed = false;
+	let authTestError;
+	let authIdentityWarning;
+	try {
+		const auth = await app.client.auth.test();
+		const authUserId = normalizeOptionalString(auth.user_id) ?? "";
+		botId = normalizeOptionalString(auth.bot_id) ?? "";
+		botUserId = botId ? authUserId : "";
+		teamId = auth.team_id ?? "";
+		apiAppId = auth.api_app_id ?? "";
+		authIdentityWarning = formatSlackBotTokenIdentityWarning({
+			auth,
+			accountId: account.accountId
+		});
+		if (!authUserId) {
+			authTestFailed = true;
+			authTestError = "auth.test returned no user_id";
+		}
+	} catch (err) {
+		authTestFailed = true;
+		authTestError = err instanceof Error ? err.message : String(err);
+	}
+	if (authTestFailed) runtime.log?.(warn(`[${account.accountId}] slack auth.test failed at boot (${authTestError ?? "unknown error"}); explicit bot-mention detection will be disabled until restart with a valid bot token; required-mention channels will fail closed without another trusted activation signal`));
+	if (authIdentityWarning) runtime.log?.(warn(authIdentityWarning));
+	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,
+		channelRuntime: opts.channelRuntime,
+		botUserId,
+		botId,
+		teamId,
+		apiAppId,
+		historyLimit,
+		dmHistoryLimit,
+		sessionScope,
+		mainKey,
+		dmEnabled,
+		dmPolicy,
+		allowFrom,
+		allowNameMatching,
+		groupDmEnabled,
+		groupDmChannels,
+		defaultRequireMention: slackCfg.requireMention,
+		channelsConfig,
+		groupPolicy,
+		useAccessGroups,
+		reactionMode,
+		reactionAllowlist,
+		replyToMode,
+		threadHistoryScope,
+		threadInheritParent,
+		threadRequireExplicitMention,
+		slashCommand,
+		textLimit,
+		ackReactionScope,
+		typingReaction,
+		mediaMaxBytes,
+		removeAckAfterReply
+	});
+	const trackEvent = opts.setStatus ? () => {
+		opts.setStatus({
+			lastEventAt: Date.now(),
+			lastInboundAt: Date.now()
+		});
+	} : void 0;
+	const handleSlackMessage = createSlackMessageHandler({
+		ctx,
+		account,
+		trackEvent
+	});
+	if (isSlackAnyNativeApprovalClientEnabled({
+		cfg,
+		accountId: account.accountId
+	})) registerChannelRuntimeContext({
+		channelRuntime: opts.channelRuntime,
+		channelId: "slack",
+		accountId: account.accountId,
+		capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
+		context: {
+			app,
+			config: slackCfg.execApprovals ?? {}
+		},
+		abortSignal: opts.abortSignal
+	});
+	registerSlackMonitorEvents({
+		ctx,
+		account,
+		handleSlackMessage,
+		trackEvent
+	});
+	await registerSlackMonitorSlashCommands({
+		ctx,
+		account,
+		trackEvent
+	});
+	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(formatSlackChannelResolved(entry));
+					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. ${formatUnknownError(err)}`);
+		}
+		const allowEntries = normalizeStringEntries(allowFrom).filter((entry) => entry !== "*");
+		if (allowEntries.length > 0) {
+			const stableResolvedUsers = resolveStableSlackUserAllowlistEntries(allowEntries);
+			if (stableResolvedUsers.length > 0) {
+				const { mapping, additions } = buildAllowlistResolutionSummary(stableResolvedUsers, { formatResolved: formatSlackUserResolved });
+				allowFrom = mergeAllowlist({
+					existing: allowFrom,
+					additions
+				});
+				ctx.allowFrom = normalizeAllowList(allowFrom);
+				summarizeMapping("slack users", mapping, [], runtime);
+			}
+			if (allowNameMatching) try {
+				const resolvedUsers = await resolveSlackUserAllowlist({
+					token: resolveToken,
+					entries: allowEntries
+				});
+				const { mapping, unresolved, additions } = buildAllowlistResolutionSummary(resolvedUsers, { formatResolved: formatSlackUserResolved });
+				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. ${formatUnknownError(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) {
+				const stableResolvedUsers = resolveStableSlackUserAllowlistEntries(Array.from(userEntries));
+				if (stableResolvedUsers.length > 0) {
+					const { resolvedMap, mapping } = buildAllowlistResolutionSummary(stableResolvedUsers, { formatResolved: formatSlackUserResolved });
+					const nextChannels = patchAllowlistUsersInConfigEntries({
+						entries: channelsConfig,
+						resolvedMap
+					});
+					channelsConfig = nextChannels;
+					ctx.channelsConfig = nextChannels;
+					summarizeMapping("slack channel users", mapping, [], runtime);
+				}
+				if (allowNameMatching) try {
+					const resolvedUsers = await resolveSlackUserAllowlist({
+						token: resolveToken,
+						entries: Array.from(userEntries)
+					});
+					const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers, { formatResolved: formatSlackUserResolved });
+					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. ${formatUnknownError(err)}`);
+				}
+			}
+		}
+	})();
+	const stopOnAbort = () => {
+		if (opts.abortSignal?.aborted && slackMode === "socket") gracefulStop();
+	};
+	opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+	try {
+		if (slackMode === "socket") {
+			let reconnectAttempts = 0;
+			let hasLoggedSocketConnected = false;
+			while (!opts.abortSignal?.aborted) try {
+				const disconnect = await startSlackSocketAndWaitForDisconnect({
+					app,
+					abortSignal: opts.abortSignal,
+					onStarted: () => {
+						reconnectAttempts = 0;
+						publishSlackConnectedStatus(opts.setStatus);
+						if (!hasLoggedSocketConnected) {
+							hasLoggedSocketConnected = true;
+							runtime.log?.("slack socket mode connected");
+						}
+					}
+				});
+				if (!disconnect) break;
+				if (opts.abortSignal?.aborted) break;
+				publishSlackDisconnectedStatus(opts.setStatus, disconnect.error);
+				if (disconnect.error && isNonRecoverableSlackAuthError(disconnect.error)) {
+					runtime.error?.(`slack socket mode disconnected due to non-recoverable auth error — skipping channel (${formatUnknownError(disconnect.error)})`);
+					throw disconnect.error instanceof Error ? disconnect.error : new Error(formatUnknownError(disconnect.error));
+				}
+				reconnectAttempts += 1;
+				const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+				runtime.log?.(warn(formatSlackSocketReconnectMessage({
+					event: disconnect.event,
+					attempt: reconnectAttempts,
+					delayMs,
+					error: disconnect.error
+				})));
+				await gracefulStop();
+				try {
+					await sleepWithAbort(delayMs, opts.abortSignal);
+				} catch {
+					break;
+				}
+			} catch (err) {
+				if (isNonRecoverableSlackAuthError(err)) {
+					runtime.error?.(`slack socket mode failed to start due to non-recoverable auth error — skipping channel (${formatUnknownError(err)})`);
+					throw err;
+				}
+				reconnectAttempts += 1;
+				const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+				runtime.error?.(formatSlackSocketStartRetryMessage({
+					attempt: reconnectAttempts,
+					delayMs,
+					error: err,
+					sdkContext: socketModeLogger.getLastMessage()
+				}));
+				try {
+					await sleepWithAbort(delayMs, opts.abortSignal);
+				} catch {
+					break;
+				}
+				continue;
+			}
+		} else if (slackMode === "relay" && relayConfig) {
+			runtime.log?.(`slack relay mode connecting to ${relayConfig.url} gateway_id:${relayConfig.gatewayId}`);
+			await (await loadSlackRelaySource()).monitorSlackRelaySource({
+				config: relayConfig,
+				handleSlackMessage,
+				runtime,
+				abortSignal: opts.abortSignal,
+				setStatus: opts.setStatus,
+				setIdentity: (identity) => setSlackDefaultSendIdentity(account.accountId, identity)
+			});
+		} else {
+			runtime.log?.(`slack http mode listening at ${slackWebhookPath}`);
+			if (!opts.abortSignal?.aborted) await new Promise((resolve) => {
+				opts.abortSignal?.addEventListener("abort", () => resolve(), { once: true });
+			});
+		}
+	} finally {
+		if (slackMode === "relay") setSlackDefaultSendIdentity(account.accountId, void 0);
+		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+		unregisterSocketModeConnectionDiagnostics();
+		unregisterHttpHandler?.();
+		await gracefulStop();
+	}
+}
+const resolveSlackRuntimeGroupPolicy = resolveOpenProviderRuntimeGroupPolicy$1;
+//#endregion
+export { stripSlackMentionsForCommandDetection as C, buildSlackSlashCommandMatcher as S, readSessionUpdatedAt as _, SLACK_SOCKET_RECONNECT_POLICY as a, resolveStorePath$1 as b, recordInboundSession as c, resolveSlackCommandIngress as d, resolveSlackEffectiveAllowFrom as f, resolveSlackChatType as g, normalizeSlackChannelType as h, authorizeSlackDirectMessage as i, resolveConversationLabel$1 as l, parseSlackAssistantThreadMetadata as m, resolveSlackRuntimeGroupPolicy as n, formatUnknownError as o, buildSlackAssistantThreadMetadata as p, resolveSlackRoomContextHints as r, escapeSlackMrkdwn as s, monitorSlackProvider as t, authorizeSlackBotRoomMessage as u, resolveChannelContextVisibilityMode as v, updateLastRoute as x, resolveChannelResetConfig as y };