@openclaw/slack 2026.7.2-beta.1 → 2026.7.2-beta.2

package/dist/{provider-Ds-y-imP.js → provider-CmeoUiIM.js}

@@ -1,13 +1,13 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.js";
 import { a as resolveSlackAccount, d as formatSlackBotTokenIdentityWarning, f as resolveSlackAppToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, p as resolveSlackBotToken, s as resolveSlackAccountDmPolicy } from "./accounts-BOJJiHSr.js";
-import { $ as isSlackAnyNativeApprovalClientEnabled, F as SLACK_TEXT_LIMIT, K as escapeSlackMrkdwn, U as isSlackApprovalActionId, W as isSlackCallbackActionId, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, dt as isSlackExecApprovalAuthorizedSender, l as normalizeSlackSlug, lt as isSlackApprovalAuthorizedSender, o as normalizeAllowList, q as decodeSlackApprovalAction, r as formatSlackError, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as truncateSlackText } from "./group-policy-C-b2ZnSl.js";
+import { B as truncateSlackText, G as isSlackCallbackActionId, I as SLACK_TEXT_LIMIT, J as decodeSlackApprovalAction, W as isSlackApprovalActionId, c as normalizeAllowListLower, d as resolveSlackAllowListMatch, et as isSlackAnyNativeApprovalClientEnabled, ft as isSlackExecApprovalAuthorizedSender, i as formatSlackError, l as normalizeSlackAllowOwnerEntry, o as allowListMatches, q as escapeSlackMrkdwn, s as normalizeAllowList, u as normalizeSlackSlug, ut as isSlackApprovalAuthorizedSender } from "./group-policy-85UWiriS.js";
 import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-BilWUdcI.js";
-import { o as getSlackListenerUploadCompletionClient, u as resolveSlackWebClientOptions } from "./client-D2F6m8CP.js";
-import { t as getOptionalSlackRuntime } from "./runtime-CauEvswP.js";
-import { i as setSlackDefaultSendIdentity } from "./send-NEfJ0GvM.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DOMgNCWb.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-aL6-Ssee.js";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-f8b0edSi.js";
+import { d as resolveSlackWebClientOptions, r as createSlackStartupAuthClient, s as getSlackListenerUploadCompletionClient } from "./client-WIPAS3Yr.js";
+import { n as getSlackRuntime, t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
+import { i as setSlackDefaultSendIdentity } from "./send-DYp8ca-l.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Rfts6POK.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-y6wAxR8E.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-BVs4LiSa.js";
 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";
@@ -94,9 +94,26 @@ function resolveSlackChatType(channelType) {
 	return "channel";
 }
 //#endregion
+//#region extensions/slack/src/monitor/lru-map-cache.ts
+/** LRU-touch read: move hit to newest so pruneMapToMaxSize keeps active keys. */
+function readLruMapEntry(cache, cacheKey) {
+	const cached = cache.get(cacheKey);
+	if (cached) {
+		cache.delete(cacheKey);
+		cache.set(cacheKey, cached);
+	}
+	return cached;
+}
+function writeLruMapEntry(cache, cacheKey, entry, maxEntries) {
+	cache.delete(cacheKey);
+	cache.set(cacheKey, entry);
+	pruneMapToMaxSize(cache, maxEntries);
+}
+//#endregion
 //#region extensions/slack/src/monitor/context.ts
 const SLACK_ASSISTANT_THREAD_CONTEXT_METADATA_EVENT = "assistant_thread_context";
 const SLACK_CHANNEL_CACHE_MAX_ENTRIES = 1024;
+const SLACK_USER_CACHE_MAX_ENTRIES = 2048;
 const SLACK_CHANNEL_DENIAL_WARNING_TTL_MS = 5 * 6e4;
 const SLACK_CHANNEL_DENIAL_WARNING_MAX_ENTRIES = 1024;
 function buildSlackAssistantThreadMetadata(context) {
@@ -150,38 +167,25 @@ function createSlackMonitorContext(params) {
 	const hasChannelAllowlistConfig = Object.keys(params.channelsConfig ?? {}).length > 0;
 	const channelsConfigKeys = Object.keys(params.channelsConfig ?? {});
 	const scopedKey = (key, eventScope) => eventScope ? `${params.accountId}:${eventScope.teamId}:${key}` : key;
-	const readCachedChannel = (cacheKey) => {
-		const cached = channelCache.get(cacheKey);
-		if (cached) {
-			channelCache.delete(cacheKey);
-			channelCache.set(cacheKey, cached);
-		}
-		return cached;
-	};
-	const writeCachedChannel = (cacheKey, entry) => {
-		channelCache.delete(cacheKey);
-		channelCache.set(cacheKey, entry);
-		pruneMapToMaxSize(channelCache, SLACK_CHANNEL_CACHE_MAX_ENTRIES);
-	};
 	const rememberSlackChannelType = (channelId, channelType, eventScope) => {
 		const id = normalizeOptionalString(channelId);
 		const normalizedType = normalizeOptionalString(channelType)?.toLowerCase();
 		if (!id || normalizedType !== "im" && normalizedType !== "mpim" && normalizedType !== "channel" && normalizedType !== "group") return;
 		const cacheKey = scopedKey(id, eventScope);
-		const cached = readCachedChannel(cacheKey);
+		const cached = readLruMapEntry(channelCache, cacheKey);
 		const type = normalizeSlackChannelType(normalizedType, id);
 		if (cached?.info.type === type) return;
-		writeCachedChannel(cacheKey, {
+		writeLruMapEntry(channelCache, cacheKey, {
 			info: {
 				...cached?.info,
 				type
 			},
 			metadataLoaded: cached?.metadataLoaded ?? false
-		});
+		}, SLACK_CHANNEL_CACHE_MAX_ENTRIES);
 	};
 	const recallSlackChannelType = (channelId, eventScope) => {
 		const id = normalizeOptionalString(channelId);
-		return id ? readCachedChannel(scopedKey(id, eventScope))?.info.type : void 0;
+		return id ? readLruMapEntry(channelCache, scopedKey(id, eventScope))?.info.type : void 0;
 	};
 	const markMessageSeen = (channelId, ts, eventScope) => {
 		if (!channelId || !ts) return false;
@@ -280,7 +284,7 @@ function createSlackMonitorContext(params) {
 	};
 	const resolveChannelName = async (channelId, eventScope) => {
 		const cacheKey = scopedKey(channelId, eventScope);
-		const cached = readCachedChannel(cacheKey);
+		const cached = readLruMapEntry(channelCache, cacheKey);
 		if (cached?.metadataLoaded) return cached.info;
 		try {
 			const info = await (eventScope?.client ?? params.app.client).conversations.info({
@@ -301,7 +305,7 @@ function createSlackMonitorContext(params) {
 				},
 				metadataLoaded: true
 			};
-			writeCachedChannel(cacheKey, entry);
+			writeLruMapEntry(channelCache, cacheKey, entry, SLACK_CHANNEL_CACHE_MAX_ENTRIES);
 			return entry.info;
 		} catch {
 			return cached?.info ?? {};
@@ -309,7 +313,7 @@ function createSlackMonitorContext(params) {
 	};
 	const resolveUserName = async (userId, eventScope) => {
 		const cacheKey = scopedKey(userId, eventScope);
-		const cached = userCache.get(cacheKey);
+		const cached = readLruMapEntry(userCache, cacheKey);
 		if (cached) return cached;
 		try {
 			const info = await (eventScope?.client ?? params.app.client).users.info({
@@ -318,7 +322,7 @@ function createSlackMonitorContext(params) {
 			});
 			const profile = info.user?.profile;
 			const entry = { name: profile?.display_name || profile?.real_name || info.user?.name || void 0 };
-			userCache.set(cacheKey, entry);
+			writeLruMapEntry(userCache, cacheKey, entry, SLACK_USER_CACHE_MAX_ENTRIES);
 			return entry;
 		} catch {
 			return {};
@@ -606,6 +610,20 @@ function resolveSlackInstallationIdentity(params) {
 		...enterpriseId ? { enterpriseId } : {}
 	};
 }
+function resolveSlackIdentityHealth(params) {
+	if (params.installationIdentity.kind === "enterprise") return {
+		healthState: "healthy",
+		lastError: null
+	};
+	const lastError = normalizeOptionalString(params.authTestError) ?? normalizeOptionalString(params.authIdentityWarning) ?? (params.installationIdentity.kind === "degraded" || !params.botUserId.trim() ? "slack bot identity unavailable" : void 0);
+	return lastError ? {
+		healthState: "degraded",
+		lastError
+	} : {
+		healthState: "healthy",
+		lastError: null
+	};
+}
 //#endregion
 //#region extensions/slack/src/monitor/events/assistant.ts
 const DEFAULT_ASSISTANT_PROMPTS = [
@@ -3180,7 +3198,7 @@ function createSlackThreadTsResolver(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-f0eJJoJL.js"));
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-DofAvTtb.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -3212,7 +3230,7 @@ function buildSeenMessageKey(channelId, ts, teamId) {
 	return `${teamId ? `${teamId}:` : ""}${channelId}:${ts}`;
 }
 function createSlackMessageHandler(params) {
-	const { ctx, account, trackEvent } = params;
+	const { ctx, account, trackEvent, onPrepared } = params;
 	const { debounceMs, debouncer } = createChannelInboundDebouncer({
 		cfg: ctx.cfg,
 		channel: "slack",
@@ -3297,6 +3315,7 @@ function createSlackMessageHandler(params) {
 							}
 						})();
 						if (!prepared) return;
+						onPrepared?.(prepared);
 						if (entries.length > 1) {
 							const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
 							if (ids.length > 0) {
@@ -3426,6 +3445,203 @@ function createSlackMessageHandler(params) {
 	};
 }
 //#endregion
+//#region extensions/slack/src/monitor/presence-monitor.ts
+const SLACK_PRESENCE_GREETING_COOLDOWN_MS = 480 * 60 * 1e3;
+const SLACK_PRESENCE_POLL_INTERVAL_MS = 6e4;
+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;
+function resolveMode(channelConfig, accountConfig) {
+	return channelConfig?.mode ?? accountConfig?.mode ?? "off";
+}
+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");
+}
+function isTargetEligible(target) {
+	if (target.mode === "on") return true;
+	if (target.autoEligibleKind === "channel") return false;
+	return target.participants.size <= SLACK_PRESENCE_AUTO_MAX_PARTICIPANTS;
+}
+function formatSlackPresenceEvent(target, userId) {
+	return [
+		"Slack presence event:",
+		`A human participant became active on Slack after being observed away: user_id=${JSON.stringify(userId)} channel_id=${JSON.stringify(target.channelId)}${target.threadId ? ` thread_ts=${JSON.stringify(target.threadId)}` : ""}.`,
+		"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."
+	].join("\n");
+}
+function resolveObservedTarget(params) {
+	const { prepared } = params;
+	const userId = prepared.message.user?.trim();
+	if (!userId || prepared.message.bot_id || prepared.message.subtype === "bot_message") return null;
+	const mode = resolveMode(prepared.channelConfig?.presenceEvents, params.accountConfig);
+	if (mode === "off") return null;
+	const channelId = prepared.message.channel;
+	const rawThreadId = prepared.ctxPayload.MessageThreadId ?? prepared.ctxPayload.TransportThreadId ?? void 0;
+	const threadId = rawThreadId === void 0 ? void 0 : String(rawThreadId);
+	const channelType = prepared.message.channel_type;
+	const autoEligibleKind = prepared.isDirectMessage ? "direct" : channelType === "mpim" ? "group" : threadId ? "thread" : "channel";
+	if (mode === "auto" && autoEligibleKind === "channel") return null;
+	return {
+		key: `${channelId}${threadId ? `:thread:${threadId}` : ":top"}`,
+		mode,
+		channelId,
+		threadId,
+		to: prepared.isDirectMessage ? `user:${userId}` : `channel:${channelId}`,
+		sessionKey: prepared.route.sessionKey,
+		agentId: prepared.route.agentId,
+		participants: /* @__PURE__ */ new Map([[userId, params.nowMs]]),
+		lastActivityAtMs: params.nowMs,
+		autoEligibleKind
+	};
+}
+function createSlackPresenceMonitor(params) {
+	const targets = /* @__PURE__ */ new Map();
+	const presenceByUser = /* @__PURE__ */ new Map();
+	const nowMs = params.nowMs ?? Date.now;
+	const enqueue = params.enqueue ?? enqueueSystemEvent;
+	const wake = params.wake ?? requestHeartbeat;
+	let pollOffset = 0;
+	let timer;
+	let activePoll;
+	let stopped = false;
+	const pruneTargets = (now) => {
+		for (const [key, target] of targets) if (now - target.lastActivityAtMs >= SLACK_PRESENCE_TARGET_TTL_MS) targets.delete(key);
+		while (targets.size > SLACK_PRESENCE_MAX_TARGETS) {
+			const oldestKey = targets.keys().next().value;
+			if (typeof oldestKey !== "string") break;
+			targets.delete(oldestKey);
+		}
+		const eligibleUsers = new Set(Array.from(targets.values()).filter(isTargetEligible).flatMap((target) => Array.from(target.participants.keys())));
+		for (const userId of presenceByUser.keys()) if (!eligibleUsers.has(userId)) presenceByUser.delete(userId);
+	};
+	const observe = (prepared) => {
+		const now = nowMs();
+		pruneTargets(now);
+		const observed = resolveObservedTarget({
+			prepared,
+			accountConfig: params.accountConfig,
+			nowMs: now
+		});
+		if (!observed) return;
+		const current = targets.get(observed.key);
+		if (current) {
+			current.mode = observed.mode;
+			current.sessionKey = observed.sessionKey;
+			current.agentId = observed.agentId;
+			current.to = observed.to;
+			current.lastActivityAtMs = now;
+			for (const [participant, observedAt] of observed.participants) current.participants.set(participant, observedAt);
+			targets.delete(observed.key);
+			targets.set(observed.key, current);
+		} else targets.set(observed.key, observed);
+		pruneTargets(now);
+	};
+	const emitTransition = (userId, now) => {
+		const target = Array.from(targets.values()).filter((candidate) => candidate.participants.has(userId) && isTargetEligible(candidate)).toSorted((a, b) => (b.participants.get(userId) ?? 0) - (a.participants.get(userId) ?? 0))[0];
+		if (!target) return;
+		const cooldownKey = `${params.accountId}:${userId}`;
+		let reserved;
+		try {
+			reserved = params.cooldownStore.registerIfAbsent(cooldownKey, now, { ttlMs: SLACK_PRESENCE_GREETING_COOLDOWN_MS });
+		} catch (err) {
+			params.error?.(`slack presence cooldown persistence failed: ${String(err)}`);
+			return;
+		}
+		if (!reserved) return;
+		if (!enqueue(formatSlackPresenceEvent(target, userId), {
+			sessionKey: target.sessionKey,
+			contextKey: `slack:presence-active:${params.accountId}:${userId}`,
+			deliveryContext: {
+				channel: "slack",
+				to: target.to,
+				accountId: params.accountId,
+				threadId: target.threadId
+			}
+		})) {
+			params.cooldownStore.delete(cooldownKey);
+			return;
+		}
+		wake({
+			source: "notifications-event",
+			intent: "immediate",
+			reason: "wake",
+			agentId: target.agentId,
+			sessionKey: target.sessionKey,
+			heartbeat: {
+				target: "slack",
+				to: target.to,
+				accountId: params.accountId
+			}
+		});
+	};
+	const performPoll = async () => {
+		const now = nowMs();
+		pruneTargets(now);
+		const candidates = Array.from(new Set(Array.from(targets.values()).filter(isTargetEligible).flatMap((target) => Array.from(target.participants.keys())))).toSorted();
+		if (candidates.length === 0) return;
+		const count = Math.min(candidates.length, SLACK_PRESENCE_MAX_POLLS_PER_INTERVAL);
+		const selected = Array.from({ length: count }, (_, index) => candidates[(pollOffset + index) % candidates.length]).filter((userId) => Boolean(userId));
+		pollOffset = (pollOffset + count) % candidates.length;
+		for (const userId of selected) {
+			if (stopped) return;
+			try {
+				const response = await params.client.getPresence({ user: userId });
+				if (stopped) return;
+				const next = response.presence === "active" || response.presence === "away" ? response.presence : void 0;
+				if (!next) continue;
+				const previous = presenceByUser.get(userId);
+				presenceByUser.set(userId, next);
+				if (previous === "away" && next === "active") emitTransition(userId, now);
+			} catch (err) {
+				if (stopped) return;
+				params.error?.(`slack presence poll failed for user ${userId}: ${String(err)}`);
+			}
+		}
+	};
+	const pollOnce = () => {
+		if (stopped) return Promise.resolve();
+		if (activePoll) return activePoll;
+		const run = performPoll().finally(() => {
+			if (activePoll === run) activePoll = void 0;
+		});
+		activePoll = run;
+		return run;
+	};
+	return {
+		observe,
+		pollOnce,
+		start: () => {
+			if (timer) return;
+			stopped = false;
+			params.log?.(`slack presence polling enabled for account ${params.accountId}`);
+			timer = setInterval(() => void pollOnce(), SLACK_PRESENCE_POLL_INTERVAL_MS);
+			timer.unref?.();
+		},
+		stop: async () => {
+			stopped = true;
+			if (timer) {
+				clearInterval(timer);
+				timer = void 0;
+			}
+			await activePoll;
+		}
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/presence-cooldown-store.ts
+const SLACK_PRESENCE_COOLDOWN_MAX_ENTRIES = 25e3;
+function openSlackPresenceCooldownStore() {
+	return getSlackRuntime().state.openSyncKeyedStore({
+		namespace: "presence-greeting-cooldowns",
+		maxEntries: SLACK_PRESENCE_COOLDOWN_MAX_ENTRIES,
+		overflowPolicy: "reject-new",
+		defaultTtlMs: SLACK_PRESENCE_GREETING_COOLDOWN_MS
+	});
+}
+//#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";
@@ -3614,13 +3830,15 @@ function resolveSlackBoltInterop(params) {
 	};
 	throw new TypeError("Unable to resolve @slack/bolt App/HTTPReceiver exports");
 }
-function publishSlackConnectedStatus(setStatus) {
+function publishSlackConnectedStatus(setStatus, identityHealth = {
+	healthState: "healthy",
+	lastError: null
+}) {
 	if (!setStatus) return;
 	setStatus({
 		connected: true,
 		lastConnectedAt: Date.now(),
-		healthState: "healthy",
-		lastError: null
+		...identityHealth
 	});
 }
 function publishSlackDisconnectedStatus(setStatus, error) {
@@ -3960,7 +4178,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-C0Otuf_T.js"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-CSja9VuD.js"));
 const loadSlackPluginCommandsRuntime = createLazyRuntimeModule(() => import("./slash-plugin-commands.runtime-Dosfcx3X.js"));
 const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 function resolveSlackCommandMenuModelContext(params) {
@@ -4700,7 +4918,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-B-6LFUdz.js"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-DMmgtvg4.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveStableSlackUserIdEntry(raw) {
@@ -4890,12 +5108,11 @@ async function monitorSlackProvider(opts = {}) {
 	let botUserId = "";
 	let botId = "";
 	const expectedApiAppIdFromAppToken = slackMode === "socket" ? parseApiAppIdFromAppToken(appToken) : void 0;
-	let authTestFailed = false;
 	let authTestError;
 	let authIdentityWarning;
 	let authTestIdentity;
 	try {
-		const auth = await app.client.auth.test();
+		const auth = await createSlackStartupAuthClient(botToken, clientOptions).auth.test();
 		const authUserId = normalizeOptionalString(auth.user_id) ?? "";
 		botId = normalizeOptionalString(auth.bot_id) ?? "";
 		botUserId = botId ? authUserId : "";
@@ -4904,24 +5121,26 @@ async function monitorSlackProvider(opts = {}) {
 			auth,
 			accountId: account.accountId
 		});
-		if (!authUserId && !enterpriseOrgInstall) {
-			authTestFailed = true;
-			authTestError = "auth.test returned no user_id";
-		}
+		if (!authUserId && !enterpriseOrgInstall) authTestError = "auth.test returned no user_id";
 	} catch (err) {
-		authTestFailed = true;
 		authTestError = err instanceof Error ? err.message : String(err);
 	}
 	const installationIdentity = resolveSlackInstallationIdentity({
 		enterpriseOrgInstall,
-		auth: authTestFailed ? void 0 : authTestIdentity,
+		auth: authTestError === void 0 ? authTestIdentity : void 0,
 		authError: authTestError,
 		transportApiAppId: expectedApiAppIdFromAppToken
 	});
 	const teamId = installationIdentity.kind === "workspace" ? installationIdentity.teamId : "";
 	const apiAppId = installationIdentity.kind === "degraded" ? "" : installationIdentity.apiAppId ?? "";
-	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 (authTestError !== void 0) runtime.log?.(warn(`[${account.accountId}] slack auth.test failed at boot (${authTestError}); 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));
+	const identityHealth = resolveSlackIdentityHealth({
+		installationIdentity,
+		botUserId,
+		authTestError,
+		authIdentityWarning
+	});
 	if (apiAppId && expectedApiAppIdFromAppToken && apiAppId !== expectedApiAppIdFromAppToken) runtime.error?.(`slack token mismatch: bot token app_id=${apiAppId} but app token looks like app_id=${expectedApiAppIdFromAppToken}`);
 	const ctx = createSlackMonitorContext({
 		cfg,
@@ -4968,10 +5187,24 @@ async function monitorSlackProvider(opts = {}) {
 			lastInboundAt: Date.now()
 		});
 	} : void 0;
+	const presenceEventsEnabled = hasSlackPresenceEventsEnabled({
+		account: slackCfg.presenceEvents,
+		channels: slackCfg.channels
+	});
+	const presenceMonitor = installationIdentity.kind !== "enterprise" && presenceEventsEnabled ? createSlackPresenceMonitor({
+		accountId: account.accountId,
+		accountConfig: slackCfg.presenceEvents,
+		client: app.client.users,
+		cooldownStore: openSlackPresenceCooldownStore(),
+		log: runtime.log,
+		error: runtime.error
+	}) : void 0;
+	if (installationIdentity.kind === "enterprise" && presenceEventsEnabled) runtime.log?.(warn("slack presence events are unavailable for Enterprise Grid org installs"));
 	const handleSlackMessage = createSlackMessageHandler({
 		ctx,
 		account,
-		trackEvent
+		trackEvent,
+		onPrepared: presenceMonitor?.observe
 	});
 	if (installationIdentity.kind !== "enterprise" && isSlackAnyNativeApprovalClientEnabled({
 		cfg,
@@ -4999,6 +5232,7 @@ async function monitorSlackProvider(opts = {}) {
 		appHomeSlashCommandName: commandRegistration.mode === "single" ? commandRegistration.name : void 0,
 		trackEvent
 	});
+	presenceMonitor?.start();
 	if (slackMode === "http" && slackHttpHandler) unregisterHttpHandler = registerSlackHttpHandler({
 		path: slackWebhookPath,
 		handler: slackHttpHandler,
@@ -5113,10 +5347,10 @@ async function monitorSlackProvider(opts = {}) {
 					abortSignal: opts.abortSignal,
 					onStarted: () => {
 						reconnectAttempts = 0;
-						publishSlackConnectedStatus(opts.setStatus);
+						publishSlackConnectedStatus(opts.setStatus, identityHealth);
 						if (!hasLoggedSocketConnected) {
 							hasLoggedSocketConnected = true;
-							runtime.log?.("slack socket mode connected");
+							runtime.log?.(identityHealth.healthState === "degraded" ? "slack socket mode connected (degraded identity)" : "slack socket mode connected");
 						}
 					}
 				});
@@ -5178,6 +5412,7 @@ async function monitorSlackProvider(opts = {}) {
 			});
 		}
 	} finally {
+		await presenceMonitor?.stop();
 		if (slackMode === "relay") setSlackDefaultSendIdentity(account.accountId, void 0);
 		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
 		unregisterSocketModeConnectionDiagnostics();

package/dist/{relay-source-B-6LFUdz.js → relay-source-DMmgtvg4.js}

@@ -1,4 +1,4 @@
-import { c as formatUnknownError, s as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-Ds-y-imP.js";
+import { c as formatUnknownError, s as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-CmeoUiIM.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";

package/dist/{replies-BMvf3ihj.js → replies-CJJCp6qz.js}

@@ -1,6 +1,6 @@
-import { C as hasSlackNativeDataBlock, D as markdownToSlackMrkdwnChunks, F as SLACK_TEXT_LIMIT, f as hasSlackReplyStructuredContent, h as resolveSlackReplyBlocks, k as buildSlackBlocksFallbackText, m as resolveSlackReplyBlockResolution, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText } from "./group-policy-C-b2ZnSl.js";
-import { l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, u as chunkSlackTextAtHardLimit } from "./send-NEfJ0GvM.js";
-import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-Ds-y-imP.js";
+import { A as buildSlackBlocksFallbackText, I as SLACK_TEXT_LIMIT, O as markdownToSlackMrkdwnChunks, S as buildSlackNativeDataAccessibilityText, T as isSlackInvalidBlocksError, g as resolveSlackReplyBlocks, h as resolveSlackReplyBlockResolution, p as hasSlackReplyStructuredContent, w as hasSlackNativeDataBlock } from "./group-policy-85UWiriS.js";
+import { l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, u as chunkSlackTextAtHardLimit } from "./send-DYp8ca-l.js";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CmeoUiIM.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";

package/dist/{resolve-channels-DOMgNCWb.js → resolve-channels-Rfts6POK.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as createSlackLookupClient } from "./client-D2F6m8CP.js";
+import { n as createSlackLookupClient } from "./client-WIPAS3Yr.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-DSmTg0su.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";

package/dist/{resolve-users-aL6-Ssee.js → resolve-users-y6wAxR8E.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as createSlackLookupClient } from "./client-D2F6m8CP.js";
+import { n as createSlackLookupClient } from "./client-WIPAS3Yr.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-DSmTg0su.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";

package/dist/{runtime-CauEvswP.js → runtime-JSVZSWAj.js}

@@ -1,8 +1,8 @@
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/slack/src/runtime.ts
-const { setRuntime: setSlackRuntime, tryGetRuntime: getOptionalSlackRuntime } = createPluginRuntimeStore({
+const { setRuntime: setSlackRuntime, tryGetRuntime: getOptionalSlackRuntime, getRuntime: getSlackRuntime } = createPluginRuntimeStore({
 	pluginId: "slack",
 	errorMessage: "Slack runtime not initialized"
 });
 //#endregion
-export { setSlackRuntime as n, getOptionalSlackRuntime as t };
+export { getSlackRuntime as n, setSlackRuntime as r, getOptionalSlackRuntime as t };

package/dist/{runtime-api-CVb6CQjX.js → runtime-api-BGDyOt1D.js}

@@ -1,5 +1,5 @@
 import "./target-parsing-N6lHogYZ.js";
-import "./client-D2F6m8CP.js";
+import "./client-WIPAS3Yr.js";
 import "./config-api-Df9a1B8C.js";
 import "openclaw/plugin-sdk/account-id";
 import { createActionGate as createActionGate$1, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
 import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
 import { a as resolveSlackAccount, f as resolveSlackAppToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, p as resolveSlackBotToken, t as listEnabledSlackAccounts } from "./accounts-BOJJiHSr.js";
-import { n as resolveSlackGroupToolPolicy, t as resolveSlackGroupRequireMention } from "./group-policy-C-b2ZnSl.js";
-import { n as setSlackRuntime } from "./runtime-CauEvswP.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-DkTcWmpT.js";
-import { r as sendMessageSlack } from "./send-NEfJ0GvM.js";
-import { t as probeSlack } from "./probe-CfALk0l4.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DOMgNCWb.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-aL6-Ssee.js";
-import { t as monitorSlackProvider } from "./provider-Ds-y-imP.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-p6M2ULpv.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-DX7yFsM-.js";
-import "./monitor-BN_uuvrQ.js";
+import { n as resolveSlackGroupRequireMention, r as resolveSlackGroupToolPolicy } from "./group-policy-85UWiriS.js";
+import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-BZiuSTIq.js";
+import { r as sendMessageSlack } from "./send-DYp8ca-l.js";
+import { t as probeSlack } from "./probe-CN0ssfLN.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Rfts6POK.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-y6wAxR8E.js";
+import { t as monitorSlackProvider } from "./provider-CmeoUiIM.js";
+import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-Cee2ih0s.js";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-D_yZhjgp.js";
+import "./monitor-CalGciTs.js";
 export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, handleSlackAction, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsLive, listSlackDirectoryPeersLive, listSlackEmojis, listSlackPins, listSlackReactions, monitorSlackProvider, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, registerSlackPluginHttpRoutes, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAppToken, resolveSlackBotToken, resolveSlackChannelAllowlist, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackUserAllowlist, sendMessageSlack, sendSlackMessage, setSlackRuntime, slackActionRuntime, unpinSlackMessage };

package/dist/runtime-setter-api.js

@@ -1,2 +1,2 @@
-import { n as setSlackRuntime } from "./runtime-CauEvswP.js";
+import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
 export { setSlackRuntime };

package/dist/{scopes-Dw8wbU0j.js → scopes-CuxNQZ6v.js}

@@ -1,5 +1,5 @@
-import { r as formatSlackError } from "./group-policy-C-b2ZnSl.js";
-import { i as createSlackWebClient } from "./client-D2F6m8CP.js";
+import { i as formatSlackError } from "./group-policy-85UWiriS.js";
+import { a as createSlackWebClient } from "./client-WIPAS3Yr.js";
 import { isRecord, normalizeOptionalString, normalizeStringEntries, sortUniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/scopes.ts
 function collectScopes(value, into) {

package/dist/{send-NEfJ0GvM.js → send-DYp8ca-l.js}

@@ -1,10 +1,10 @@
 import { a as resolveSlackAccount, l as resolveSlackOperationToken, p as resolveSlackBotToken } from "./accounts-BOJJiHSr.js";
 import { i as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-N6lHogYZ.js";
-import { A as buildSlackCompleteBlocksFallbackText, C as hasSlackNativeDataBlock, D as markdownToSlackMrkdwnChunks, E as chunkSlackMrkdwnText, F as SLACK_TEXT_LIMIT, P as SLACK_MESSAGE_TEXT_HARD_LIMIT, S as createSlackNativeDataBaseTextConsumer, T as stripSlackNativeDataBlocks, Z as validateSlackBlocksArray, b as appendSlackNativeDataPlainTextFallback, i as assertSlackDirectSendAllowed, j as renderSlackBlockFallbackText, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText, z as truncateSlackText } from "./group-policy-C-b2ZnSl.js";
+import { B as truncateSlackText, C as createSlackNativeDataBaseTextConsumer, D as chunkSlackMrkdwnText, E as stripSlackNativeDataBlocks, F as SLACK_MESSAGE_TEXT_HARD_LIMIT, I as SLACK_TEXT_LIMIT, M as renderSlackBlockFallbackText, O as markdownToSlackMrkdwnChunks, Q as validateSlackBlocksArray, S as buildSlackNativeDataAccessibilityText, T as isSlackInvalidBlocksError, a as assertSlackDirectSendAllowed, j as buildSlackCompleteBlocksFallbackText, w as hasSlackNativeDataBlock, x as appendSlackNativeDataPlainTextFallback } from "./group-policy-85UWiriS.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { i as createSlackWebClient, r as createSlackTokenCacheKey, s as getSlackWriteClient } from "./client-D2F6m8CP.js";
-import { t as getOptionalSlackRuntime } from "./runtime-CauEvswP.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-CVb6CQjX.js";
+import { a as createSlackWebClient, c as getSlackWriteClient, i as createSlackTokenCacheKey } from "./client-WIPAS3Yr.js";
+import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-BGDyOt1D.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";

package/dist/{send.runtime-BkKpitPu.js → send.runtime-CJLxAt26.js}

@@ -1,2 +1,2 @@
-import { n as resolveSlackDmChannelId, r as sendMessageSlack, t as reconcileSlackUnknownSend } from "./send-NEfJ0GvM.js";
+import { n as resolveSlackDmChannelId, r as sendMessageSlack, t as reconcileSlackUnknownSend } from "./send-DYp8ca-l.js";
 export { reconcileSlackUnknownSend, resolveSlackDmChannelId, sendMessageSlack };