@openclaw/slack 2026.7.1-beta.2 → 2026.7.1-beta.4

package/dist/{plugin-routes-B9PvcDQJ.js → plugin-routes-CLp4obpN.js}

@@ -5,7 +5,7 @@ function resolveSlackWebhookPaths(config) {
 	const slack = config.channels?.slack;
 	const accountConfigs = slack?.accounts ?? {};
 	const paths = /* @__PURE__ */ new Set();
-	for (const accountId of new Set([DEFAULT_ACCOUNT_ID, ...Object.keys(accountConfigs)])) {
+	for (const accountId of /* @__PURE__ */ new Set([DEFAULT_ACCOUNT_ID, ...Object.keys(accountConfigs)])) {
 		const path = accountConfigs[accountId]?.webhookPath ?? slack?.webhookPath;
 		paths.add(normalizeSlackWebhookPath(typeof path === "string" ? path : void 0));
 	}

package/dist/{policy-DAE6BTN3.js → policy-Dj-puVPb.js}

@@ -1,4 +1,4 @@
-import { f as normalizeSlackSlug } from "./reply-blocks-CfJqf7eq.js";
+import { p as normalizeSlackSlug } from "./reply-blocks-BGQ6zSqM.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { applyChannelMatchMeta, buildChannelKeyCandidates, resolveChannelEntryMatchWithFallback } from "openclaw/plugin-sdk/channel-targets";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
@@ -39,10 +39,16 @@ function resolveSlackChannelConfig(params) {
 		requireMention: requireMentionDefault
 	};
 	const resolved = matched ?? fallback ?? {};
+	const allowed = firstDefined(resolved.enabled, fallback?.enabled, true) ?? true;
+	const requireMention = firstDefined(resolved.requireMention, fallback?.requireMention, requireMentionDefault) ?? requireMentionDefault;
+	const ignoreOtherMentions = firstDefined(resolved.ignoreOtherMentions, fallback?.ignoreOtherMentions);
+	const allowBots = firstDefined(resolved.allowBots, fallback?.allowBots);
 	return applyChannelMatchMeta({
-		allowed: firstDefined(resolved.enabled, fallback?.enabled, true) ?? true,
-		requireMention: firstDefined(resolved.requireMention, fallback?.requireMention, requireMentionDefault) ?? requireMentionDefault,
-		allowBots: firstDefined(resolved.allowBots, fallback?.allowBots),
+		allowed,
+		requireMention,
+		ignoreOtherMentions,
+		replyToMode: firstDefined(resolved.replyToMode, fallback?.replyToMode),
+		allowBots,
 		botLoopProtection: mergePairLoopGuardConfig(fallback?.botLoopProtection, matched?.botLoopProtection),
 		users: firstDefined(resolved.users, fallback?.users),
 		skills: firstDefined(resolved.skills, fallback?.skills),

package/dist/{probe-DFKt9Ute.js → probe-CuwRDE5j.js}

@@ -1,10 +1,11 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { r as createSlackWebClient } from "./client-DG9cyk55.js";
-import { t as formatSlackError } from "./errors-CZtmv-h0.js";
+import { d as formatSlackBotTokenIdentityWarning } from "./accounts-BOJJiHSr.js";
+import { c as formatSlackError } from "./reply-blocks-BGQ6zSqM.js";
+import { r as createSlackWebClient } from "./client-DGxwSL7f.js";
 import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/slack/src/probe.ts
 var probe_exports = /* @__PURE__ */ __exportAll({ probeSlack: () => probeSlack });
-async function probeSlack(token, timeoutMs = 2500) {
+async function probeSlack(token, timeoutMs = 2500, opts) {
 	const client = createSlackWebClient(token);
 	const start = Date.now();
 	try {
@@ -15,6 +16,10 @@ async function probeSlack(token, timeoutMs = 2500) {
 			error: result.error ?? "unknown",
 			elapsedMs: Date.now() - start
 		};
+		const warning = formatSlackBotTokenIdentityWarning({
+			auth: result,
+			accountId: opts?.accountId
+		});
 		return {
 			ok: true,
 			status: 200,
@@ -26,7 +31,8 @@ async function probeSlack(token, timeoutMs = 2500) {
 			team: {
 				id: result.team_id,
 				name: result.team
-			}
+			},
+			...warning ? { warning } : {}
 		};
 	} catch (err) {
 		const message = formatSlackError(err);

package/dist/{provider-BdoeWKr8.js → provider-Cot8h818.js}

@@ -1,30 +1,29 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, d as resolveSlackBotToken, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as resolveSlackAppToken } from "./accounts-BPCiCe8y.js";
-import { F as isSlackExecApprovalAuthorizedSender, N as isSlackApprovalAuthorizedSender, S as isSlackAnyNativeApprovalClientEnabled, a as SLACK_TEXT_LIMIT, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, l as normalizeAllowList, p as resolveSlackAllowListMatch, u as normalizeAllowListLower, v as truncateSlackText } from "./reply-blocks-CfJqf7eq.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-D-22gTp3.js";
-import { c as resolveSlackWebClientOptions } from "./client-DG9cyk55.js";
+import { a as resolveSlackAccount, d as formatSlackBotTokenIdentityWarning, f as resolveSlackAppToken, o as resolveSlackAccountAllowFrom, p as resolveSlackBotToken, s as resolveSlackAccountDmPolicy } from "./accounts-BOJJiHSr.js";
+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-BGQ6zSqM.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-CXpT-vA_.js";
+import { c as resolveSlackWebClientOptions } from "./client-DGxwSL7f.js";
 import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.js";
-import { n as setSlackDefaultSendIdentity } from "./send-Dg6U9K7_.js";
-import { t as formatSlackError } from "./errors-CZtmv-h0.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-eniB45fy.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-DDKzl37a.js";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-DAE6BTN3.js";
+import { i as setSlackDefaultSendIdentity } from "./send-DKDXoeoV.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CstkChBE.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-C3NP2c-Q.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-Dj-puVPb.js";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
-import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeStringEntriesLower, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+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 { computeBackoff, createNonExitingRuntime, createSubsystemLogger, danger, getChildLogger, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { createDedupeCache, resolveGlobalDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
+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";
@@ -110,7 +109,7 @@ function buildSlackAssistantThreadMetadata(context) {
 function parseSlackAssistantThreadMetadata(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	const metadata = value;
-	if (metadata.event_type !== "assistant_thread_context") return;
+	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;
@@ -283,7 +282,8 @@ function createSlackMonitorContext(params) {
 				token: params.botToken,
 				channel_id: p.channelId,
 				thread_ts: p.threadTs,
-				status: p.status
+				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)}`);
@@ -637,10 +637,11 @@ function registerSlackChannelEvents(params) {
 			trackEvent?.();
 			const payload = event;
 			const channelId = payload.channel?.id;
+			const channelName = payload.channel?.name_normalized ?? payload.channel?.name;
 			enqueueChannelSystemEvent({
 				kind: "renamed",
 				channelId,
-				channelName: payload.channel?.name_normalized ?? payload.channel?.name
+				channelName
 			});
 		} catch (err) {
 			ctx.runtime.error?.(danger(`slack channel rename handler failed: ${formatErrorMessage(err)}`));
@@ -1272,6 +1273,11 @@ function buildSlackPluginInteractionData(params) {
 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 [
@@ -1300,7 +1306,7 @@ function parseSlackBlockAction(params) {
 		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,
+		threadTs: typedBody.container?.thread_ts ?? typedBody.message?.thread_ts,
 		actionSummary: summarizeAction(typedAction)
 	};
 }
@@ -1623,6 +1629,7 @@ async function handleSlackBlockAction(params) {
 		log: params.ctx.runtime.log
 	});
 	if (!parsed) return;
+	if (isSlackReplyLinkAction(parsed)) return;
 	params.trackEvent?.();
 	const pluginInteractionData = buildSlackPluginInteractionData({
 		actionId: parsed.actionId,
@@ -2066,7 +2073,7 @@ 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 = new Set([
+const SLACK_INTERACTION_REDACTED_KEYS = /* @__PURE__ */ new Set([
 	"triggerId",
 	"responseUrl",
 	"workflowTriggerUrl",
@@ -2615,75 +2622,30 @@ function registerSlackMonitorEvents(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/inbound-delivery-state.ts
-const TTL_MS = 1440 * 60 * 1e3;
-const MAX_ENTRIES = 2e4;
-const PERSISTENT_MAX_ENTRIES = 2e4;
-const PERSISTENT_NAMESPACE = "slack.inbound-deliveries";
-const deliveredMessages = resolveGlobalDedupeCache(Symbol.for("openclaw.slackInboundDeliveries"), {
-	ttlMs: TTL_MS,
-	maxSize: MAX_ENTRIES
+const deliveredMessages = createPersistentDedupeCache({
+	globalKey: Symbol.for("openclaw.slackInboundDeliveries"),
+	ttlMs: 1440 * 60 * 1e3,
+	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 {}
+		}
+	}
 });
-let persistentStore;
-let persistentStoreDisabled = false;
 function makeKey(accountId, channelId, ts) {
 	return `${accountId}:${channelId}:${ts}`;
 }
-function reportPersistentInboundDeliveryError(error) {
-	try {
-		getOptionalSlackRuntime()?.logging.getChildLogger({
-			plugin: "slack",
-			feature: "inbound-delivery-state"
-		}).warn("Slack persistent inbound delivery state failed", { error: String(error) });
-	} catch {}
-}
-function disablePersistentInboundDelivery(error) {
-	persistentStoreDisabled = true;
-	persistentStore = void 0;
-	reportPersistentInboundDeliveryError(error);
-}
-function getPersistentInboundDeliveryStore() {
-	if (persistentStoreDisabled) return;
-	if (persistentStore) return persistentStore;
-	const runtime = getOptionalSlackRuntime();
-	if (!runtime) return;
-	try {
-		persistentStore = runtime.state.openKeyedStore({
-			namespace: PERSISTENT_NAMESPACE,
-			maxEntries: PERSISTENT_MAX_ENTRIES,
-			defaultTtlMs: TTL_MS
-		});
-		return persistentStore;
-	} catch (error) {
-		disablePersistentInboundDelivery(error);
-		return;
-	}
-}
-async function lookupPersistentInboundDelivery(key) {
-	const store = getPersistentInboundDeliveryStore();
-	if (!store) return false;
-	try {
-		return Boolean(await store.lookup(key));
-	} catch (error) {
-		disablePersistentInboundDelivery(error);
-		return false;
-	}
-}
-async function rememberPersistentInboundDelivery(key, deliveredAt) {
-	const store = getPersistentInboundDeliveryStore();
-	if (!store) return;
-	try {
-		await store.register(key, { deliveredAt });
-	} catch (error) {
-		disablePersistentInboundDelivery(error);
-	}
-}
 async function hasSlackInboundMessageDelivery(params) {
 	if (!params.accountId || !params.channelId || !params.ts) return false;
-	const key = makeKey(params.accountId, params.channelId, params.ts);
-	if (deliveredMessages.peek(key)) return true;
-	const found = await lookupPersistentInboundDelivery(key);
-	if (found) deliveredMessages.check(key);
-	return found;
+	return await deliveredMessages.lookup(makeKey(params.accountId, params.channelId, params.ts));
 }
 async function recordSlackInboundMessageDeliveries(params) {
 	if (!params.accountId || params.messages.length === 0) return;
@@ -2693,9 +2655,7 @@ async function recordSlackInboundMessageDeliveries(params) {
 		if (!message.channel || !message.ts) continue;
 		keys.add(makeKey(params.accountId, message.channel, message.ts));
 	}
-	if (keys.size === 0) return;
-	for (const key of keys) deliveredMessages.check(key, deliveredAt);
-	await Promise.all(Array.from(keys, (key) => rememberPersistentInboundDelivery(key, deliveredAt)));
+	await Promise.all(Array.from(keys, (key) => deliveredMessages.register(key, { deliveredAt }, { at: deliveredAt })));
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/debounce-key.ts
@@ -2741,7 +2701,8 @@ async function resolveThreadTsFromHistory(params) {
 			inclusive: true,
 			limit: 1
 		});
-		return normalizeThreadTs((response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0])?.thread_ts);
+		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;
@@ -2821,7 +2782,7 @@ function createSlackThreadTsResolver(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-cxw6Zihc.js"));
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-0wEFX2CS.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -2914,26 +2875,36 @@ function createSlackMessageHandler(params) {
 					try {
 						const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
 						const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, ...lastOpts } = last.opts;
-						const prepared = await prepareSlackMessage({
-							ctx,
-							account,
-							message: syntheticMessage,
-							opts: {
-								...lastOpts,
-								wasMentioned: combinedMentioned || last.opts.wasMentioned
+						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 (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;
-							}
-							appMentionRetryKeys.delete(seenMessageKey);
-						}
 						if (entries.length > 1) {
 							const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
 							if (ids.length > 0) {
@@ -2978,6 +2949,7 @@ function createSlackMessageHandler(params) {
 	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);
@@ -3066,6 +3038,8 @@ const SLACK_SOCKET_RECONNECT_POLICY = {
 	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;
@@ -3078,6 +3052,45 @@ function getSocketEmitter(app) {
 		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);
@@ -3274,7 +3287,7 @@ function shouldSkipOpenClawSlackSelfEvent(args) {
 	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 = new Set(["member_joined_channel", "member_left_channel"]);
+	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) {
@@ -3424,6 +3437,7 @@ async function authorizeSlackDirectMessage(params) {
 	if (params.ctx.dmPolicy === "pairing") {
 		await createChannelPairingChallengeIssuer({
 			channel: "slack",
+			accountId: params.accountId,
 			upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
 				channel: "slack",
 				id,
@@ -3527,7 +3541,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-DVhs_fpQ.js"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-Ccm3quU1.js"));
 const loadSlackPluginCommandsRuntime = createLazyRuntimeModule(() => import("./slash-plugin-commands.runtime-Dosfcx3X.js"));
 const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 function resolveSlackCommandMenuModelContext(params) {
@@ -3908,7 +3922,10 @@ async function registerSlackMonitorSlashCommands(params) {
 					agentId: menuRoute.agentId,
 					sessionKey: menuRoute.sessionKey
 				}) : {};
-				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadModelCatalog({ config: cfg }) : void 0;
+				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadModelCatalog({
+					config: cfg,
+					readOnly: true
+				}) : void 0;
 				const menu = resolveCommandArgMenu({
 					command: commandDefinition,
 					args: commandArgs,
@@ -4099,12 +4116,13 @@ async function registerSlackMonitorSlashCommands(params) {
 			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: commandDefinition ? slashCommandsRuntime.buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`,
+				prompt,
 				commandArgs,
 				commandDefinition: commandDefinition ?? void 0
 			});
@@ -4204,14 +4222,15 @@ async function registerSlackMonitorSlashCommands(params) {
 			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: {
-					user_id: user?.id ?? "",
-					user_name: userName,
-					channel_id: body.channel?.id ?? "",
-					channel_name: body.channel?.name ?? body.channel?.id ?? "",
-					trigger_id: triggerId
-				},
+				command: commandPayload,
 				ack: async () => {},
 				respond: respondFn,
 				body,
@@ -4236,7 +4255,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-OcqQzKfX.js"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-CU1LhyBj.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveStableSlackUserIdEntry(raw) {
@@ -4398,6 +4417,12 @@ async function monitorSlackProvider(opts = {}) {
 		}
 	} : null;
 	let unregisterHttpHandler = null;
+	const unregisterSocketModeConnectionDiagnostics = slackMode === "socket" ? registerSlackSocketModeConnectionDiagnostics({
+		app,
+		onSharedConnection: (activeConnections) => {
+			runtime.log?.(warn(formatSlackSocketModeSharedConnectionWarning(activeConnections)));
+		}
+	}) : () => {};
 	let botUserId = "";
 	let botId = "";
 	let teamId = "";
@@ -4405,13 +4430,19 @@ async function monitorSlackProvider(opts = {}) {
 	const expectedApiAppIdFromAppToken = slackMode === "socket" ? parseApiAppIdFromAppToken(appToken) : void 0;
 	let authTestFailed = false;
 	let authTestError;
+	let authIdentityWarning;
 	try {
 		const auth = await app.client.auth.test();
-		botUserId = auth.user_id ?? "";
-		botId = auth.bot_id ?? "";
+		const authUserId = normalizeOptionalString(auth.user_id) ?? "";
+		botId = normalizeOptionalString(auth.bot_id) ?? "";
+		botUserId = botId ? authUserId : "";
 		teamId = auth.team_id ?? "";
 		apiAppId = auth.api_app_id ?? "";
-		if (!botUserId) {
+		authIdentityWarning = formatSlackBotTokenIdentityWarning({
+			auth,
+			accountId: account.accountId
+		});
+		if (!authUserId) {
 			authTestFailed = true;
 			authTestError = "auth.test returned no user_id";
 		}
@@ -4419,7 +4450,8 @@ async function monitorSlackProvider(opts = {}) {
 		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`));
+	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,
@@ -4675,6 +4707,7 @@ async function monitorSlackProvider(opts = {}) {
 	} finally {
 		if (slackMode === "relay") setSlackDefaultSendIdentity(account.accountId, void 0);
 		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+		unregisterSocketModeConnectionDiagnostics();
 		unregisterHttpHandler?.();
 		await gracefulStop();
 	}

package/dist/{relay-source-OcqQzKfX.js → relay-source-CU1LhyBj.js}

@@ -1,11 +1,11 @@
-import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-BdoeWKr8.js";
+import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-Cot8h818.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { Buffer } from "node:buffer";
 import { isIP } from "node:net";
 import WebSocket from "ws";
 //#region extensions/slack/src/monitor/relay-source.ts
-const SLACK_RELAY_ROUTE_KINDS = new Set([
+const SLACK_RELAY_ROUTE_KINDS = /* @__PURE__ */ new Set([
 	"user_group",
 	"thread_affinity",
 	"channel_default"

package/dist/{replies-D_G-EPr8.js → replies-Bbx6pG_B.js}

@@ -1,6 +1,7 @@
-import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-CfJqf7eq.js";
-import { s as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-Dg6U9K7_.js";
-import "./provider-BdoeWKr8.js";
+import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-BGQ6zSqM.js";
+import { r as sendMessageSlack } from "./send-DKDXoeoV.js";
+import { t as markdownToSlackMrkdwnChunks } from "./format-YCNoNkM2.js";
+import "./provider-Cot8h818.js";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";