@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/dist/{provider-CDNvBXUi.js → provider-CN_8hFv2.js}

@@ -1,15 +1,15 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as formatSlackBotTokenIdentityWarning } from "./accounts-CK4AVI2_.js";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as formatSlackBotTokenIdentityWarning } from "./accounts-Dm_H77gH.js";
 import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { $ as isSlackCallbackActionId, B as SLACK_TEXT_LIMIT, Et as isSlackApprovalAuthorizedSender, G as truncateSlackText, Ot as isSlackExecApprovalAuthorizedSender, Q as isSlackApprovalActionId, a as allowListMatches, at as escapeSlackMrkdwn, c as normalizeSlackAllowOwnerEntry, d as resolveSlackUserAllowListForTeam, et as isSlackQuestionActionId, ft as isSlackAnyNativeApprovalClientEnabled, l as normalizeSlackSlug, nt as decodeSlackQuestionAction, o as normalizeAllowList, ot as decodeSlackApprovalAction, rt as resolveSlackQuestionAction, s as normalizeAllowListLower, t as buildSlackChannelIdCandidates, u as resolveSlackAllowListMatch, wt as registerSlackInstallationState } from "./group-policy-c4RP9bjc.js";
-import { c as createSlackWebClient, g as resolveSlackWebClientOptions, h as resolveSlackProxyDispatcher, m as resolveSlackLookupClientOptions, o as createSlackStartupAuthClient, r as formatSlackError, u as getSlackListenerUploadCompletionClient } from "./probe-HoEg_WxB.js";
+import { Ct as isSlackApprovalAuthorizedSender, G as isSlackCallbackActionId, J as decodeSlackQuestionAction, K as isSlackQuestionActionId, L as truncateSlackText, M as SLACK_TEXT_LIMIT, Tt as isSlackExecApprovalAuthorizedSender, W as isSlackApprovalActionId, Y as resolveSlackQuestionAction, a as qualifySlackConversationId, et as escapeSlackMrkdwn, lt as isSlackAnyNativeApprovalClientEnabled, nt as decodeSlackApprovalAction, o as qualifySlackRoutePeerId, s as resolveSlackEnterpriseMainDmSessionKey, t as buildSlackChannelIdCandidates, xt as registerSlackInstallationState } from "./group-policy-BdwszjYn.js";
+import { D as resolveSlackWebClientOptions, E as resolveSlackProxyDispatcher, T as resolveSlackLookupClientOptions, _ as createSlackStartupAuthClient, a as slackIngressIdentity, c as normalizeAllowList, d as normalizeSlackSlug, f as resolveSlackAllowListMatch, i as createSlackIngressSubject, l as normalizeAllowListLower, o as formatSlackError, p as resolveSlackUserAllowListForTeam, s as allowListMatches, u as normalizeSlackAllowOwnerEntry, x as getSlackListenerUploadCompletionClient, y as createSlackWebClient } from "./probe-0usmAb0i.js";
 import { n as getSlackRuntime, t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { t as hasSlackMessageTableBlock } from "./block-text-YtiNkqmx.js";
-import { i as setSlackDefaultSendIdentity } from "./send-Nor0iBwY.js";
+import { C as hasSlackMessageTableBlock, b as saveRemoteMedia, f as readSlackMessages, y as isGovSlackClient } from "./actions-BI7JkfVm.js";
+import { i as setSlackDefaultSendIdentity, p as requireSlackPostMessageTimestamp } from "./send-DS9ICrBI.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CNPrxaXY.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-Dzomuwnr.js";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-TapwbeaT.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Czheznc8.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-BAOlNimr.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-CtQVbde1.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asNonArrayRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -25,13 +25,14 @@ import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { WebAPIHTTPError, WebAPIPlatformError, WebAPIRateLimitedError, WebAPIRequestError, WebClient } from "@slack/web-api";
 import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, resolveConversationLabel as resolveConversationLabel$1, resolvePluginConversationBindingApproval, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
+import { createChannelIngressResolver, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, isApprovalNotFoundError, readErrorName, toErrorObject } 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 { buildChannelMetadata } from "openclaw/plugin-sdk/security-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { classifyTransientNetworkErrorCode } from "openclaw/plugin-sdk/retry-runtime";
 import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
-import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, 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";
@@ -44,12 +45,12 @@ import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy as res
 import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
 import { mutateConfigFile, readConfigFileSnapshotForWrite } from "openclaw/plugin-sdk/config-mutation";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { classifyTransientNetworkErrorCode } from "openclaw/plugin-sdk/retry-runtime";
+import { asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-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 { createChannelInteractiveDispatcher } from "openclaw/plugin-sdk/plugin-runtime";
+import { reportChannelRoomJoin } from "openclaw/plugin-sdk/channel-join-intro-runtime";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { createChannelReplayGuard, runClaimableDedupeClaimLoop } from "openclaw/plugin-sdk/persistent-dedupe";
 import { channelBlockedPatch, channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
@@ -376,20 +377,6 @@ async function updateSlackSuggestedPrompts(params) {
 	}
 }
 //#endregion
-//#region extensions/slack/src/monitor/workspace-routing.ts
-function resolveSlackEnterpriseMainDmSessionKey(params) {
-	const accountId = encodeURIComponent(params.accountId).toLowerCase();
-	const teamId = encodeURIComponent(params.eventScope.teamId).toLowerCase();
-	return `${params.baseSessionKey}:account:${accountId}:team:${teamId}`;
-}
-function qualifySlackRoutePeerId(params) {
-	if (!params.eventScope) return params.id;
-	return `team:${encodeURIComponent(params.eventScope.teamId)}:${params.kind}:${encodeURIComponent(params.id)}`;
-}
-function qualifySlackConversationId(conversationId, eventScope) {
-	return eventScope ? `team:${encodeURIComponent(eventScope.teamId)}:${conversationId}` : conversationId;
-}
-//#endregion
 //#region extensions/slack/src/monitor/system-event-session.ts
 function createSlackSystemEventRouteResolver(params) {
 	return (event) => {
@@ -489,6 +476,12 @@ function resolveSlackSystemEventRoute(params) {
 //#region extensions/slack/src/monitor/context.ts
 const SLACK_CHANNEL_CACHE_MAX_ENTRIES = 1024;
 const SLACK_USER_CACHE_MAX_ENTRIES = 2048;
+const SLACK_AVATAR_CACHE_MAX_ENTRIES = 128;
+const SLACK_AVATAR_MAX_BYTES = 256 * 1024;
+const SLACK_AVATAR_SSRF_POLICY = {
+	allowedHostnames: ["avatars.slack-edge.com", "*.slack-edge.com"],
+	hostnameAllowlist: ["avatars.slack-edge.com", "*.slack-edge.com"]
+};
 const SLACK_CHANNEL_DENIAL_WARNING_TTL_MS = 5 * 6e4;
 const SLACK_CHANNEL_DENIAL_WARNING_MAX_ENTRIES = 1024;
 function createSlackMonitorContext(params) {
@@ -496,6 +489,8 @@ function createSlackMonitorContext(params) {
 	const logger = getChildLogger({ module: "slack-auto-reply" });
 	const channelCache = /* @__PURE__ */ new Map();
 	const userCache = /* @__PURE__ */ new Map();
+	const avatarCache = /* @__PURE__ */ new Map();
+	const pendingAvatars = /* @__PURE__ */ new Set();
 	const channelDenialWarnings = createDedupeCache({
 		ttlMs: SLACK_CHANNEL_DENIAL_WARNING_TTL_MS,
 		maxSize: SLACK_CHANNEL_DENIAL_WARNING_MAX_ENTRIES
@@ -581,13 +576,41 @@ function createSlackMonitorContext(params) {
 				user: userId
 			});
 			const profile = info.user?.profile;
-			const entry = { name: profile?.display_name || profile?.real_name || info.user?.name || void 0 };
+			const entry = {
+				name: profile?.display_name || profile?.real_name || info.user?.name || void 0,
+				imageUrl: normalizeOptionalString(profile?.image_192) ?? normalizeOptionalString(profile?.image_512) ?? normalizeOptionalString(profile?.image_72)
+			};
 			writeLruMapEntry(userCache, cacheKey, entry, SLACK_USER_CACHE_MAX_ENTRIES);
 			return entry;
 		} catch (error) {
 			return { error };
 		}
 	};
+	const resolveUserAvatar = (userId, eventScope) => {
+		if (isGovSlackClient(eventScope?.client ?? params.app.client)) return;
+		const imageUrl = readLruMapEntry(userCache, scopedKey(userId, eventScope))?.imageUrl;
+		if (!imageUrl) return;
+		const cacheKey = scopedKey(`${userId}\0${imageUrl}`, eventScope);
+		const cached = readLruMapEntry(avatarCache, cacheKey);
+		if (cached) return cached;
+		if (pendingAvatars.has(cacheKey) || pendingAvatars.size >= SLACK_AVATAR_CACHE_MAX_ENTRIES) return;
+		pendingAvatars.add(cacheKey);
+		saveRemoteMedia({
+			url: imageUrl,
+			filePathHint: "conversation-avatar.png",
+			maxBytes: SLACK_AVATAR_MAX_BYTES,
+			ssrfPolicy: SLACK_AVATAR_SSRF_POLICY
+		}).then((media) => {
+			writeLruMapEntry(avatarCache, cacheKey, media.path, SLACK_AVATAR_CACHE_MAX_ENTRIES);
+		}).catch((error) => {
+			logger.debug({
+				error: formatSlackError(error),
+				userId
+			}, "Slack conversation avatar download failed");
+		}).finally(() => {
+			pendingAvatars.delete(cacheKey);
+		});
+	};
 	const setSlackThreadStatus = async (p) => {
 		if (!p.threadTs) return;
 		try {
@@ -683,6 +706,7 @@ function createSlackMonitorContext(params) {
 		}
 		return false;
 	};
+	const channelRuntime = params.channelRuntime;
 	const ctx = {
 		cfg: params.cfg,
 		accountId: params.accountId,
@@ -690,7 +714,8 @@ function createSlackMonitorContext(params) {
 		app: params.app,
 		runtime: params.runtime,
 		channelRuntime: params.channelRuntime,
-		buildContext: params.channelRuntime?.inbound.buildContext,
+		buildContext: channelRuntime?.inbound.buildContext,
+		dispatchReplyFromConfig: channelRuntime?.reply?.dispatchReplyFromConfig,
 		botUserId: params.botUserId,
 		botId: params.botId,
 		identityHealth: params.identityHealth,
@@ -734,6 +759,7 @@ function createSlackMonitorContext(params) {
 		rememberSlackChannelType,
 		recallSlackChannelType,
 		resolveUserName,
+		resolveUserAvatar,
 		setSlackThreadStatus,
 		getSlackAssistantThreadContext: assistantThreadContextStore.get,
 		saveSlackAssistantThreadContext: assistantThreadContextStore.save,
@@ -1255,6 +1281,8 @@ function resolveSlackIngressTurnLifecycle(context) {
 function createSlackDurableIngress(options) {
 	let app;
 	let relayDispatch;
+	const activeSessionTurns = /* @__PURE__ */ new Map();
+	const activeChannelTurns = /* @__PURE__ */ new Map();
 	const monitor = createChannelIngressMonitor({
 		queue: options.queue ?? (() => getSlackRuntime().state.openChannelIngressQueue({ accountId: options.accountId })),
 		inspect: inspectSlackIngress,
@@ -1291,26 +1319,110 @@ function createSlackDurableIngress(options) {
 		onDurableAdmission: async (raw) => {
 			if (raw.kind === "events-api") await raw.afterDurableAdmission?.();
 		},
-		deliver: async (raw, lifecycle) => {
-			if (raw.kind === "relay") {
-				if (!relayDispatch) throw new Error("Slack relay ingress dispatcher is not attached.");
-				await relayDispatch(raw.message, lifecycle);
-				return;
+		deliver: async (raw, lifecycle, claim) => {
+			const laneKey = claim.laneKey ?? inspectSlackIngress(raw).laneKey;
+			let releaseSession;
+			let releaseChannel;
+			let routedSession;
+			let adoptOnCompletion = false;
+			const settleSession = () => {
+				adoptOnCompletion = false;
+				releaseSession?.();
+			};
+			const settleTurn = () => {
+				settleSession();
+				releaseChannel?.();
+				lifecycle.abortSignal.removeEventListener("abort", settleTurn);
+			};
+			const routedLifecycle = {
+				...lifecycle,
+				onSessionRouted: async (sessionKey) => {
+					if (routedSession !== void 0) {
+						if (routedSession !== sessionKey) throw new Error("Slack ingress session ownership changed after routing.");
+						return;
+					}
+					lifecycle.abortSignal.throwIfAborted();
+					routedSession = sessionKey;
+					adoptOnCompletion = true;
+					const previousTurn = activeSessionTurns.get(sessionKey);
+					const releasedCurrentTurn = createDeferred();
+					const currentTurn = previousTurn ? previousTurn.then(() => releasedCurrentTurn.promise) : releasedCurrentTurn.promise;
+					activeSessionTurns.set(sessionKey, currentTurn);
+					const channelTurn = createDeferred();
+					const channelTurns = activeChannelTurns.get(laneKey) ?? /* @__PURE__ */ new Set();
+					channelTurns.add(channelTurn.promise);
+					activeChannelTurns.set(laneKey, channelTurns);
+					currentTurn.then(() => {
+						if (activeSessionTurns.get(sessionKey) === currentTurn) activeSessionTurns.delete(sessionKey);
+					});
+					channelTurn.promise.then(() => {
+						channelTurns.delete(channelTurn.promise);
+						if (channelTurns.size === 0 && activeChannelTurns.get(laneKey) === channelTurns) activeChannelTurns.delete(laneKey);
+					});
+					releaseSession = () => releasedCurrentTurn.resolve();
+					releaseChannel = () => channelTurn.resolve();
+					lifecycle.abortSignal.addEventListener("abort", settleTurn, { once: true });
+					lifecycle.onDeferred();
+					if (previousTurn) lifecycle.onAdoptionFinalizing();
+					monitor.requestDrain();
+					await previousTurn;
+					lifecycle.abortSignal.throwIfAborted();
+				},
+				onAdopted: async () => {
+					try {
+						await lifecycle.onAdopted();
+					} finally {
+						settleTurn();
+					}
+				},
+				onDeferred: () => {
+					lifecycle.onDeferred();
+					settleSession();
+					monitor.requestDrain();
+				},
+				onAbandoned: async () => {
+					try {
+						await lifecycle.onAbandoned();
+					} finally {
+						settleTurn();
+					}
+				}
+			};
+			try {
+				if (asOptionalRecord(raw.kind === "events-api" ? asOptionalRecord(raw.body)?.event : void 0)?.type === "channel_id_changed") {
+					const channelTurns = activeChannelTurns.get(laneKey);
+					if (channelTurns && channelTurns.size > 0) {
+						adoptOnCompletion = true;
+						lifecycle.onAdoptionFinalizing();
+						await Promise.all(channelTurns);
+						lifecycle.abortSignal.throwIfAborted();
+					}
+				}
+				if (raw.kind === "relay") {
+					if (!relayDispatch) throw new Error("Slack relay ingress dispatcher is not attached.");
+					await relayDispatch(raw.message, routedLifecycle);
+				} else {
+					if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
+					await app.processEvent({
+						body: raw.body,
+						ack: async () => {},
+						...raw.retryNum === void 0 ? {} : { retryNum: raw.retryNum },
+						...raw.retryReason === void 0 ? {} : { retryReason: raw.retryReason },
+						customProperties: { [SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY]: routedLifecycle }
+					});
+				}
+				if (adoptOnCompletion) await routedLifecycle.onAdopted();
+			} catch (error) {
+				settleTurn();
+				throw error;
 			}
-			if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
-			await app.processEvent({
-				body: raw.body,
-				ack: async () => {},
-				...raw.retryNum === void 0 ? {} : { retryNum: raw.retryNum },
-				...raw.retryReason === void 0 ? {} : { retryReason: raw.retryReason },
-				customProperties: { [SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY]: lifecycle }
-			});
 		},
 		pollIntervalMs: options.pollIntervalMs ?? SLACK_INGRESS_POLL_INTERVAL_MS,
 		retention: "standard",
 		appendRetryDelaysMs: [0],
 		drain: {
 			resolveNonRetryableFailure: resolveSlackIngressNonRetryableFailure,
+			deferredLaneOccupancy: "release",
 			deriveLaneKey: (record) => record.payload.kind === "relay" ? resolveSlackIngressLane({ event: record.payload.message }, record.id) : resolveSlackIngressLane(record.payload.body, record.id),
 			...options.adoptionStallTimeoutMs === void 0 ? {} : { adoptionStallTimeoutMs: options.adoptionStallTimeoutMs },
 			...options.onLog ? { onLog: options.onLog } : {}
@@ -1475,88 +1587,7 @@ const 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";
-const SLACK_WORKSPACE_USER_ID_KIND = "plugin:slack-workspace-user-id";
 var SlackSystemEventAuthRetryError = class extends Error {};
-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 normalizeSlackWorkspaceUserEntry(entry) {
-	const normalized = entry.trim().toLowerCase();
-	if (!normalized) return null;
-	try {
-		const target = parseSlackTarget(normalized);
-		if (target?.kind === "user" && target.teamId) return target.normalized;
-	} catch {
-		return null;
-	}
-	return null;
-}
-function normalizeSlackBareUserEntry(entry) {
-	const normalized = entry.trim().toLowerCase();
-	if (!normalized || normalizeSlackWorkspaceUserEntry(normalized)) return null;
-	const userId = normalizeSlackUserId(normalized);
-	return isSlackStableUserId(userId) ? userId : null;
-}
-function normalizeSlackStableEntry(entry) {
-	return normalizeSlackBareUserEntry(entry) ?? normalizeSlackWorkspaceUserEntry(entry);
-}
-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: normalizeSlackBareUserEntry,
-	normalizeSubject: normalizeSlackUserId,
-	sensitivity: "pii",
-	aliases: [{
-		key: "workspaceSenderId",
-		kind: SLACK_WORKSPACE_USER_ID_KIND,
-		normalizeEntry: normalizeSlackWorkspaceUserEntry,
-		normalizeSubject: normalizeSlackWorkspaceUserEntry,
-		sensitivity: "pii"
-	}, ...[["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 teamId = normalizeOptionalLowercaseString(params.teamId);
-	const senderName = params.senderName?.trim().toLowerCase();
-	const senderNameSlug = senderName ? normalizeSlackSlug(senderName) : void 0;
-	return {
-		stableId: senderId,
-		aliases: {
-			workspaceSenderId: teamId && senderId ? `team:${teamId}:user:${senderId}` : void 0,
-			senderName,
-			senderNameSlug
-		}
-	};
-}
 function createSlackIngressResolver(ctx) {
 	return createChannelIngressResolver({
 		channelId: SLACK_CHANNEL_ID,
@@ -1798,7 +1829,7 @@ async function decideSlackSystemIngress(params) {
 		} : void 0
 	};
 	const result = await resolver.message(input);
-	if (result.ingress.decision !== "allow" && params.retryNameLookup && result.state.allowlists[isDirectMessage ? "dm" : "group"].normalizedEntries.some((entry) => entry.kind === SLACK_USER_NAME_KIND)) {
+	if (result.ingress.decision !== "allow" && params.retryNameLookup && result.state.allowlists[isDirectMessage ? "dm" : "group"].normalizedEntries.some((entry) => entry.kind === "plugin:slack-user-name")) {
 		const lookup = await params.ctx.resolveUserName(params.senderId, params.eventScope);
 		if (lookup.error && isTransientSlackThreadLookupError(lookup.error)) throw new SlackSystemEventAuthRetryError(formatErrorMessage(lookup.error));
 		if (lookup.name) return (await resolver.message({
@@ -1992,6 +2023,7 @@ async function authorizeAndResolveSlackSystemEventContext(params) {
 			channelId,
 			channelType: auth.channelType,
 			senderId,
+			threadTs: auth.channelType === "im" ? void 0 : params.threadTs,
 			eventScope: params.eventScope
 		})
 	};
@@ -2421,8 +2453,8 @@ function removeSlackApprovalControls(blocks) {
 }
 function buildSlackApprovalTerminalBlocks(params) {
 	const blocks = removeSlackApprovalControls(params.blocks ?? []).filter((block) => {
-		const text = block.text?.text;
-		return !(block.type === "section" && typeof text === "string" && /^\*(?:Exec|Plugin) approval required\*/u.test(text));
+		const blockId = block.block_id;
+		return !(block.type === "section" && blockId === "openclaw_approval_header");
 	});
 	return [{
 		type: "section",
@@ -3539,6 +3571,55 @@ function registerSlackMemberEvents(params) {
 			const channelId = payload.channel;
 			const channelInfo = channelId ? await ctx.resolveChannelName(channelId, eventScope) : {};
 			const channelType = payload.channel_type ?? channelInfo?.type;
+			if (paramsLocal.verb === "joined" && payload.user === ctx.botUserId && channelId) {
+				const roomType = normalizeSlackChannelType(channelType, channelId);
+				if (roomType === "channel" || roomType === "group") {
+					const roomAllowed = ctx.isChannelAllowed({
+						teamId: eventScope?.teamId ?? ctx.teamId,
+						channelId,
+						channelName: channelInfo.name,
+						channelType: roomType
+					});
+					const inviterLabel = roomAllowed && payload.inviter ? (await ctx.resolveUserName(payload.inviter, eventScope)).name ?? payload.inviter : void 0;
+					await reportChannelRoomJoin({
+						cfg: ctx.cfg,
+						channel: "slack",
+						accountId: ctx.accountId,
+						conversationId: channelId,
+						deliverTo: `channel:${channelId}`,
+						route: ctx.resolveSlackSystemEventRoute({
+							channelId,
+							channelType: roomType,
+							eventScope
+						}),
+						inviterLabel,
+						roomAllowed,
+						resolveRoomContext: async ({ messageLimit }) => {
+							const purpose = [channelInfo.purpose, channelInfo.topic].filter((value) => Boolean(value?.trim())).join("\n");
+							const roomContext = {
+								title: channelInfo.name ? `#${channelInfo.name}` : void 0,
+								purpose: purpose || void 0
+							};
+							try {
+								const { messages } = await readSlackMessages(channelId, {
+									limit: messageLimit,
+									client: eventScope?.client ?? ctx.app.client
+								});
+								return {
+									...roomContext,
+									recentMessages: messages.toReversed().flatMap(({ user, text }) => text?.trim() ? [{
+										sender: user,
+										text
+									}] : [])
+								};
+							} catch {
+								return roomContext;
+							}
+						}
+					});
+					return;
+				}
+			}
 			const ingressContext = await authorizeAndResolveSlackSystemEventContext({
 				ctx,
 				senderId: payload.user,
@@ -3630,10 +3711,57 @@ function noteSlackDraftConversationMessage(conversation) {
 	}
 }
 //#endregion
+//#region extensions/slack/src/threading.ts
+function resolveSlackThreadContext(params) {
+	const incomingThreadTs = params.message.thread_ts;
+	const eventTs = params.message.event_ts;
+	const messageTs = params.message.ts ?? eventTs;
+	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
+	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
+	const replyToId = isThreadReply ? incomingThreadTs : void 0;
+	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
+	return {
+		incomingThreadTs,
+		messageTs,
+		isThreadReply,
+		replyToId,
+		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
+	};
+}
+/**
+* Resolves Slack thread targeting for replies and status indicators.
+*
+* @returns replyThreadTs - Thread timestamp for reply messages
+* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
+* @returns isThreadReply - true if this is a genuine user reply in a thread,
+*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
+*/
+function resolveSlackThreadTargets(params) {
+	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
+	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
+	return {
+		replyThreadTs,
+		statusThreadTs: replyThreadTs,
+		isThreadReply
+	};
+}
+//#endregion
 //#region extensions/slack/src/monitor/events/message-subtype-handlers.ts
+function resolveNestedThreadTs(event) {
+	const changed = event;
+	const message = changed.message?.thread_ts ? changed.message : changed.previous_message;
+	if (!message) return;
+	return resolveSlackThreadContext({
+		message: {
+			type: "message",
+			channel: event.channel,
+			...message
+		},
+		replyToMode: "off"
+	}).replyToId;
+}
 const SUBTYPE_HANDLER_REGISTRY = {
 	message_changed: {
-		subtype: "message_changed",
 		eventKind: "message_changed",
 		describe: (channelLabel) => `Slack message edited in ${channelLabel}.`,
 		contextKey: (event) => {
@@ -3644,11 +3772,9 @@ const SUBTYPE_HANDLER_REGISTRY = {
 			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
+		resolveThreadTs: resolveNestedThreadTs
 	},
 	message_deleted: {
-		subtype: "message_deleted",
 		eventKind: "message_deleted",
 		describe: (channelLabel) => `Slack message deleted in ${channelLabel}.`,
 		contextKey: (event) => {
@@ -3659,8 +3785,7 @@ const SUBTYPE_HANDLER_REGISTRY = {
 			const deleted = event;
 			return deleted.previous_message?.user ?? deleted.previous_message?.bot_id;
 		},
-		resolveChannelId: (event) => event.channel,
-		resolveChannelType: () => void 0
+		resolveThreadTs: resolveNestedThreadTs
 	}
 };
 function resolveSlackMessageSubtypeHandler(event) {
@@ -3783,14 +3908,6 @@ function registerSlackMessageEvents(params) {
 			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
 			const message = event;
 			ctx.rememberSlackChannelType(message.channel, message.channel_type, eventScope);
-			if (eventScope && isBotAuthoredEnterpriseEvent(message)) {
-				logVerbose("slack: drop enterprise bot-authored message");
-				return;
-			}
-			if (eventScope && message.subtype && message.subtype !== "file_share") {
-				logVerbose(`slack: drop enterprise message subtype=${message.subtype}`);
-				return;
-			}
 			const assistantChangedInbound = resolveAssistantMessageChangedInbound({
 				event: message,
 				ctx
@@ -3812,12 +3929,11 @@ function registerSlackMessageEvents(params) {
 			})) 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),
+					channelId: message.channel,
+					threadTs: subtypeHandler.resolveThreadTs(message),
 					eventKind: subtypeHandler.eventKind,
 					eventScope
 				});
@@ -4149,19 +4265,7 @@ function buildSlackDebounceKey(message, accountId, teamId) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-BvYsM5JO.js"));
-function createSlackDispatchCompletion() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((nextResolve, nextReject) => {
-			resolve = nextResolve;
-			reject = nextReject;
-		}),
-		resolve,
-		reject
-	};
-}
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-Bd22U0ga.js"));
 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;
@@ -4228,6 +4332,19 @@ function createSlackMessageHandler(params) {
 			const completions = entries.map((entry) => entry.opts.dispatchCompletion).filter((completion) => completion !== void 0);
 			try {
 				await (async () => {
+					const flushedEntry = entries.at(-1);
+					if (flushedEntry) {
+						const teamId = flushedEntry.opts.eventScope?.teamId;
+						const flushedKey = buildSlackDebounceKey(flushedEntry.message, ctx.accountId, teamId);
+						const topLevelConversationKey = buildTopLevelSlackConversationKey(flushedEntry.message, ctx.accountId, teamId);
+						if (flushedKey && topLevelConversationKey) {
+							const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
+							if (pendingKeys) {
+								pendingKeys.delete(flushedKey);
+								if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
+							}
+						}
+					}
 					const claims = [];
 					const claimedKeys = /* @__PURE__ */ new Map();
 					const surviving = [];
@@ -4281,16 +4398,6 @@ function createSlackMessageHandler(params) {
 						releaseClaims();
 						return;
 					}
-					const teamId = last.opts.eventScope?.teamId;
-					const flushedKey = buildSlackDebounceKey(last.message, ctx.accountId, teamId);
-					const topLevelConversationKey = buildTopLevelSlackConversationKey(last.message, ctx.accountId, teamId);
-					if (flushedKey && topLevelConversationKey) {
-						const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
-						if (pendingKeys) {
-							pendingKeys.delete(flushedKey);
-							if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
-						}
-					}
 					const combinedText = surviving.length === 1 ? last.message.text ?? "" : surviving.map((entry) => entry.message.text ?? "").filter(Boolean).join("\n");
 					const combinedMentioned = surviving.some((entry) => Boolean(entry.opts.wasMentioned));
 					const syntheticMessage = {
@@ -4323,6 +4430,7 @@ function createSlackMessageHandler(params) {
 							releaseClaims();
 							return;
 						}
+						await turnAdoptionLifecycle?.onSessionRouted?.(prepared.route.sessionKey);
 						prepared.turnAdoptionLifecycle = {
 							...turnAdoptionLifecycle,
 							admission: turnAdoptionLifecycle?.admission ?? "exclusive",
@@ -4338,6 +4446,10 @@ function createSlackMessageHandler(params) {
 								if (admissionLifecycle.onDeferred() === false) return false;
 								settlementHandedOff = true;
 							},
+							onDeferredHeartbeat: () => {
+								turnAdoptionLifecycle?.onDeferredHeartbeat?.();
+								admissionLifecycle.onDeferredHeartbeat?.();
+							},
 							onAbandoned: () => {
 								settlementHandedOff = true;
 								releaseClaims();
@@ -4401,7 +4513,7 @@ function createSlackMessageHandler(params) {
 			pendingKeys.add(debounceKey);
 			pendingTopLevelDebounceKeys.set(conversationKey, pendingKeys);
 		}
-		const dispatchCompletion = opts.awaitDispatch ? createSlackDispatchCompletion() : void 0;
+		const dispatchCompletion = opts.awaitDispatch ? createDeferred() : void 0;
 		await debouncer.enqueue({
 			message: resolvedMessage,
 			opts: {
@@ -4427,9 +4539,13 @@ const SLACK_PRESENCE_AUTO_MAX_PARTICIPANTS = 8;
 const SLACK_PRESENCE_TARGET_TTL_MS = 1440 * 60 * 1e3;
 const SLACK_PRESENCE_MAX_POLLS_PER_INTERVAL = 45;
 const SLACK_PRESENCE_MAX_TARGETS = 2e3;
+const DEFAULT_SLACK_PRESENCE_EVENT_PROMPT = ["Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time; if their timezone is unknown, do not guess.", "Send at most one short, natural greeting in this Slack conversation. Do not reveal private memory. If no greeting is appropriate, stay silent."];
 function resolveMode(channelConfig, accountConfig) {
 	return channelConfig?.mode ?? accountConfig?.mode ?? "off";
 }
+function resolvePrompt(channelConfig, accountConfig) {
+	return channelConfig?.prompt ?? accountConfig?.prompt;
+}
 function hasSlackPresenceEventsEnabled(params) {
 	if (resolveMode(void 0, params.account) !== "off") return true;
 	return Object.values(params.channels ?? {}).some((entry) => resolveMode(entry?.presenceEvents, void 0) !== "off");
@@ -4442,12 +4558,12 @@ function isTargetEligible(target) {
 function formatSlackPresenceEvent(target, userId, awayObservation) {
 	const { observedAwayAtMs, observedActiveAtMs } = awayObservation;
 	const observedAwayDurationMs = Math.max(0, observedActiveAtMs - observedAwayAtMs);
+	const promptLines = target.prompt === void 0 ? DEFAULT_SLACK_PRESENCE_EVENT_PROMPT : target.prompt.length > 0 ? [target.prompt] : [];
 	return [
 		"Slack presence event:",
 		`A human participant became active on Slack after being observed away: user_id=${JSON.stringify(userId)}${target.teamId ? ` team_id=${JSON.stringify(target.teamId)}` : ""} channel_id=${JSON.stringify(target.channelId)}${target.threadId ? ` thread_ts=${JSON.stringify(target.threadId)}` : ""}.`,
 		`observed_away_at_ms=${observedAwayAtMs} observed_active_at_ms=${observedActiveAtMs} observed_away_duration_ms=${observedAwayDurationMs}`,
-		"Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time; if their timezone is unknown, do not guess.",
-		"Send at most one short, natural greeting in this Slack conversation. Do not reveal private memory. If no greeting is appropriate, stay silent."
+		...promptLines
 	].join("\n");
 }
 function resolveObservedTarget(params) {
@@ -4470,6 +4586,7 @@ function resolveObservedTarget(params) {
 		key: `${teamId ? `team:${teamId}:` : ""}${channelId}${targetSuffix}`,
 		...teamId ? { teamId } : {},
 		mode,
+		prompt: resolvePrompt(prepared.channelConfig?.presenceEvents, params.accountConfig),
 		channelId,
 		threadId,
 		to: formatSlackTarget({
@@ -4523,6 +4640,7 @@ function createSlackPresenceMonitor(params) {
 		const current = targets.get(observed.key);
 		if (current) {
 			current.mode = observed.mode;
+			current.prompt = observed.prompt;
 			current.sessionKey = observed.sessionKey;
 			current.agentId = observed.agentId;
 			current.to = observed.to;
@@ -5119,7 +5237,7 @@ 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.js"));
-const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-Bnr9GR1S.js"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-CilDmI0c.js"));
 const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
 function resolveSlackCommandMenuModelContext(params) {
@@ -5581,7 +5699,7 @@ async function registerSlackMonitorSlashCommands(params) {
 			}
 			const channelName = channelInfo?.name;
 			const roomLabel = channelName ? `#${channelName}` : `#${command.channel_id}`;
-			const { deliverSlackSlashReplies, dispatchChannelInboundTurn, finalizeInboundContext, isChannelPartialDeliveryError, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode } = await loadSlashDispatchRuntime();
+			const { deliverSlackSlashReplies, dispatchChannelInboundTurn, finalizeInboundContext, isChannelPartialDeliveryError, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode, sanitizeSlackMonitorReplyPayload } = await loadSlashDispatchRuntime();
 			const route = resolvedSlashRoute ?? resolveAgentRoute({
 				cfg,
 				channel: "slack",
@@ -5681,10 +5799,8 @@ async function registerSlackMonitorSlashCommands(params) {
 					sessionKey: ctxPayload.SessionKey ?? route.sessionKey
 				},
 				ctxPayload,
-				replyPipeline: { transformReplyPayload: (payload) => {
-					if (payload.isReasoning === true) return null;
-					return payload;
-				} },
+				dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
+				replyPipeline: { transformReplyPayload: sanitizeSlackMonitorReplyPayload },
 				dispatcherOptions: { onSettled: async () => {
 					if (pendingSlashReplies.length === 0) return;
 					const pending = pendingSlashReplies.splice(0);
@@ -5899,11 +6015,13 @@ async function registerSlackMonitorSlashCommands(params) {
 			const respondFn = respond ?? (async (message) => {
 				if (!body.channel?.id || !body.user?.id) return new Response(null, { status: 204 });
 				const payload = typeof message === "string" ? { text: message } : message;
+				const threadTs = body.container?.thread_ts ?? body.message?.thread_ts;
 				await args.client.chat.postEphemeral({
 					token: ctx.botToken,
 					channel: body.channel.id,
 					user: body.user.id,
 					text: payload.text ?? "",
+					...threadTs ? { thread_ts: threadTs } : {},
 					...payload.blocks ? { blocks: payload.blocks } : {},
 					...typeof payload.mrkdwn === "boolean" ? { mrkdwn: payload.mrkdwn } : {}
 				});
@@ -5978,12 +6096,12 @@ async function deliverSlackSlashResponseWithWebApi(params) {
 	const mrkdwn = "mrkdwn" in payload && typeof payload.mrkdwn === "boolean" ? payload.mrkdwn : void 0;
 	if (payload.response_type === "in_channel") {
 		const postSlackMessage = params.client.chat.postMessage;
-		await postSlackMessage({
+		requireSlackPostMessageTimestamp(await postSlackMessage({
 			channel: params.command.channel_id,
 			text,
 			...blocks ? { blocks } : {},
 			...mrkdwn !== void 0 ? { mrkdwn } : {}
-		});
+		}));
 	} else await params.client.chat.postEphemeral({
 		channel: params.command.channel_id,
 		user: params.command.user_id,
@@ -6015,7 +6133,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-C9leF11u.js"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-BNGpsdwV.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveSlackRuntimeIdentity(params) {
@@ -6729,4 +6847,4 @@ function createSlackWorkspaceClientResolver(params) {
 }
 const resolveSlackRuntimeGroupPolicy = resolveOpenProviderRuntimeGroupPolicy$1;
 //#endregion
-export { resolveChannelResetConfig as C, stripSlackMentionsForCommandDetection as D, buildSlackSlashCommandMatcher as E, resolveChannelContextVisibilityMode as S, updateLastRoute as T, normalizeSlackChannelType as _, createSlackResponseUrlBudget as a, parseSlackAssistantThreadMetadata as b, resolveConversationLabel$1 as c, resolveSlackEffectiveAllowFrom as d, SLACK_SOCKET_RECONNECT_POLICY as f, resolveSlackEnterpriseMainDmSessionKey as g, qualifySlackRoutePeerId as h, SlackResponseAlreadyReportedError as i, authorizeSlackBotRoomMessage as l, qualifySlackConversationId as m, resolveSlackRuntimeGroupPolicy as n, authorizeSlackDirectMessage as o, formatUnknownError as p, resolveSlackRoomContextHints as r, trackSlackDraftMessage as s, monitorSlackProvider as t, resolveSlackCommandIngress as u, resolveSlackChatType as v, resolveStorePath$1 as w, readSessionUpdatedAt as x, buildSlackAssistantThreadMetadata as y };
+export { resolveStorePath$1 as C, stripSlackMentionsForCommandDetection as E, resolveChannelResetConfig as S, buildSlackSlashCommandMatcher as T, resolveSlackChatType as _, createSlackResponseUrlBudget as a, readSessionUpdatedAt as b, resolveSlackThreadTargets as c, authorizeSlackBotRoomMessage as d, resolveSlackCommandIngress as f, normalizeSlackChannelType as g, formatUnknownError as h, SlackResponseAlreadyReportedError as i, trackSlackDraftMessage as l, SLACK_SOCKET_RECONNECT_POLICY as m, resolveSlackRuntimeGroupPolicy as n, authorizeSlackDirectMessage as o, resolveSlackEffectiveAllowFrom as p, resolveSlackRoomContextHints as r, resolveSlackThreadContext as s, monitorSlackProvider as t, resolveConversationLabel$1 as u, buildSlackAssistantThreadMetadata as v, updateLastRoute as w, resolveChannelContextVisibilityMode as x, parseSlackAssistantThreadMetadata as y };