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

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

@@ -1,17 +1,17 @@
 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 { 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 { a as resolveSlackAccount, d as formatSlackBotTokenIdentityWarning, f as resolveSlackAppToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, p as resolveSlackBotToken, s as resolveSlackAccountDmPolicy } from "./accounts-DQEbYKh9.js";
+import { F as SLACK_TEXT_LIMIT, G as isSlackQuestionActionId, K as decodeSlackQuestionAction, U as isSlackApprovalActionId, W as isSlackCallbackActionId, X as decodeSlackApprovalAction, Y as escapeSlackMrkdwn, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, ft as isSlackApprovalAuthorizedSender, l as normalizeSlackSlug, mt as isSlackExecApprovalAuthorizedSender, nt as isSlackAnyNativeApprovalClientEnabled, o as normalizeAllowList, q as resolveSlackQuestionAction, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as truncateSlackText } from "./group-policy-Bw-65m3V.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-Dm_t2R9S.js";
+import { m as resolveSlackWebClientOptions, o as createSlackStartupAuthClient, r as formatSlackError, u as getSlackListenerUploadCompletionClient } from "./probe-Borhn9PQ.js";
+import { n as getSlackRuntime } from "./runtime-JSVZSWAj.js";
+import { i as setSlackDefaultSendIdentity } from "./send-KuTDky7i.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-KTc568SU.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-DeGJf1yp.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-b_dOPDCq.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";
-import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
+import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressDrain, 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";
@@ -20,12 +20,12 @@ import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plu
 import { parseExecApprovalCommandText } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
-import { collectErrorGraphCandidates, formatErrorMessage, isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
+import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, isApprovalNotFoundError } 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 { buildUntrustedChannelMetadata } from "openclaw/plugin-sdk/security-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 { 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";
@@ -45,6 +45,7 @@ import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
 import { createInteractiveConversationBindingHelpers, dispatchPluginInteractiveHandler } from "openclaw/plugin-sdk/plugin-runtime";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
+import { createChannelReplayGuard } from "openclaw/plugin-sdk/persistent-dedupe";
 import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
 //#region extensions/slack/src/monitor/commands.ts
 /**
@@ -94,9 +95,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) {
@@ -133,10 +151,6 @@ function createSlackMonitorContext(params) {
 	const logger = getChildLogger({ module: "slack-auto-reply" });
 	const channelCache = /* @__PURE__ */ new Map();
 	const userCache = /* @__PURE__ */ new Map();
-	const seenMessages = createDedupeCache({
-		ttlMs: 6e4,
-		maxSize: 500
-	});
 	const channelDenialWarnings = createDedupeCache({
 		ttlMs: SLACK_CHANNEL_DENIAL_WARNING_TTL_MS,
 		maxSize: SLACK_CHANNEL_DENIAL_WARNING_MAX_ENTRIES
@@ -150,46 +164,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;
-	};
-	const markMessageSeen = (channelId, ts, eventScope) => {
-		if (!channelId || !ts) return false;
-		return seenMessages.check(scopedKey(`${channelId}:${ts}`, eventScope));
-	};
-	const releaseSeenMessage = (channelId, ts, eventScope) => {
-		if (!channelId || !ts) return;
-		seenMessages.delete(scopedKey(`${channelId}:${ts}`, eventScope));
+		return id ? readLruMapEntry(channelCache, scopedKey(id, eventScope))?.info.type : void 0;
 	};
 	const assistantContextKey = (channelId, threadTs, eventScope) => scopedKey(`${channelId}:${threadTs}`, eventScope);
 	const cleanupAssistantThreadContexts = () => {
@@ -280,7 +273,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 +294,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 +302,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 +311,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 {};
@@ -468,7 +461,6 @@ function createSlackMonitorContext(params) {
 		replyToMode: params.replyToMode,
 		threadHistoryScope: params.threadHistoryScope,
 		threadInheritParent: params.threadInheritParent,
-		threadRequireExplicitMention: params.threadRequireExplicitMention,
 		slashCommand: params.slashCommand,
 		textLimit: params.textLimit,
 		ackReactionScope: params.ackReactionScope,
@@ -476,8 +468,6 @@ function createSlackMonitorContext(params) {
 		mediaMaxBytes: params.mediaMaxBytes,
 		removeAckAfterReply: params.removeAckAfterReply,
 		logger,
-		markMessageSeen,
-		releaseSeenMessage,
 		shouldDropMismatchedSlackEvent,
 		resolveSlackSystemEventSessionKey,
 		isChannelAllowed,
@@ -606,6 +596,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 = [
@@ -1909,6 +1913,26 @@ async function handleSlackBlockAction(params) {
 		});
 		return;
 	}
+	if (isSlackQuestionActionId(parsed.actionId)) {
+		const question = decodeSlackQuestionAction(parsed.actionSummary.value);
+		if (!question) {
+			await respondEphemeral(respond, "This question action is invalid or expired.");
+			return;
+		}
+		if (!(await authorizeSlackBlockAction({
+			ctx: params.ctx,
+			parsed,
+			respond
+		})).allowed) return;
+		await resolveSlackQuestionAction({
+			action: question,
+			cfg: params.ctx.cfg,
+			accountId: params.ctx.accountId,
+			userId: parsed.userId,
+			respond: async (text) => await respondEphemeral(respond, text)
+		});
+		return;
+	}
 	const pluginInteractionData = buildSlackPluginInteractionData({
 		actionId: parsed.actionId,
 		summary: parsed.actionSummary
@@ -2631,6 +2655,350 @@ function resolveSlackEventScope(params) {
 	};
 }
 //#endregion
+//#region extensions/slack/src/monitor/reconnect-policy.ts
+const SLACK_AUTH_ERROR_RE = /account_inactive|invalid_auth|token_revoked|token_expired|not_authed|org_login_required|team_access_not_granted|user_removed_from_team|team_disabled|missing_scope|cannot_find_service|invalid_token/i;
+const NO_ERROR_DETAIL = "no error detail";
+const SLACK_SOCKET_RECONNECT_POLICY = {
+	initialMs: 2e3,
+	maxMs: 3e4,
+	factor: 1.8,
+	jitter: .25
+};
+const SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL = "https://docs.slack.dev/apis/events-api/using-socket-mode#using-multiple-connections";
+const SLACK_SOCKET_HELLO_MARKER = Buffer.from("\"hello\"");
+function getSocketEmitter(app) {
+	const receiver = app.receiver;
+	const client = receiver && typeof receiver === "object" ? receiver.client : void 0;
+	if (!client || typeof client !== "object") return null;
+	const on = client.on;
+	const off = client.off;
+	if (typeof on !== "function" || typeof off !== "function") return null;
+	return {
+		on: (event, listener) => on.call(client, event, listener),
+		off: (event, listener) => off.call(client, event, listener)
+	};
+}
+function isBufferArray(value) {
+	return Array.isArray(value) && value.every((entry) => Buffer.isBuffer(entry));
+}
+function resolveSlackSocketModeConnectionCount(message) {
+	const buffer = Buffer.isBuffer(message) ? message : message instanceof ArrayBuffer ? Buffer.from(message) : isBufferArray(message) ? Buffer.concat(message) : void 0;
+	if (!buffer?.includes(SLACK_SOCKET_HELLO_MARKER)) return;
+	let payload;
+	try {
+		payload = JSON.parse(buffer.toString("utf8"));
+	} catch {
+		return;
+	}
+	const count = isRecord(payload) && payload.type === "hello" ? payload.num_connections : void 0;
+	return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : void 0;
+}
+function formatSlackSocketModeSharedConnectionWarning(activeConnections) {
+	return [
+		`slack socket mode reports ${activeConnections} active connections for this Slack app`,
+		"Slack may deliver each event to any one connection",
+		"ensure every OpenClaw gateway sharing this app has equivalent routing and authorization, or use a separate Slack app per gateway, one relay ingress, or HTTP Request URLs behind a load balancer",
+		`See ${SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL}`
+	].join("; ");
+}
+function registerSlackSocketModeConnectionDiagnostics(params) {
+	const emitter = getSocketEmitter(params.app);
+	if (!emitter) return () => {};
+	let hasWarned = false;
+	const listener = (message, isBinary) => {
+		if (isBinary === true || hasWarned) return;
+		const activeConnections = resolveSlackSocketModeConnectionCount(message);
+		if (activeConnections === void 0 || activeConnections <= 1) return;
+		hasWarned = true;
+		params.onSharedConnection(activeConnections);
+	};
+	emitter.on("ws_message", listener);
+	return () => {
+		emitter.off("ws_message", listener);
+	};
+}
+function waitForSlackSocketDisconnect(app, abortSignal) {
+	return new Promise((resolve) => {
+		const emitter = getSocketEmitter(app);
+		if (!emitter) {
+			abortSignal?.addEventListener("abort", () => resolve({ event: "disconnect" }), { once: true });
+			return;
+		}
+		const disconnectListener = () => resolveOnce({ event: "disconnect" });
+		const startFailListener = (error) => resolveOnce({
+			event: "unable_to_socket_mode_start",
+			error
+		});
+		const errorListener = (error) => resolveOnce({
+			event: "error",
+			error
+		});
+		const abortListener = () => resolveOnce({ event: "disconnect" });
+		const cleanup = () => {
+			emitter.off("disconnected", disconnectListener);
+			emitter.off("unable_to_socket_mode_start", startFailListener);
+			emitter.off("error", errorListener);
+			abortSignal?.removeEventListener("abort", abortListener);
+		};
+		const resolveOnce = (value) => {
+			cleanup();
+			resolve(value);
+		};
+		emitter.on("disconnected", disconnectListener);
+		emitter.on("unable_to_socket_mode_start", startFailListener);
+		emitter.on("error", errorListener);
+		abortSignal?.addEventListener("abort", abortListener, { once: true });
+	});
+}
+/**
+* Detect permanent Slack account and credential failures.
+* Transient request and HTTP failures stay in OpenClaw's reconnect loop.
+*/
+function isNonRecoverableSlackAuthError(error) {
+	return SLACK_AUTH_ERROR_RE.test(formatUnknownError(error, ""));
+}
+function formatUnknownError(error, fallback = NO_ERROR_DETAIL) {
+	return formatSlackError(error, fallback);
+}
+//#endregion
+//#region extensions/slack/src/monitor/ingress.ts
+const SLACK_INGRESS_PAYLOAD_VERSION = 1;
+const SLACK_INGRESS_POLL_INTERVAL_MS = 1e3;
+const SLACK_INGRESS_PRUNE_INTERVAL_MS = 3600 * 1e3;
+const SLACK_INGRESS_COMPLETED_TTL_MS = 720 * 60 * 60 * 1e3;
+const SLACK_INGRESS_COMPLETED_MAX_ENTRIES = 2e4;
+const SLACK_INGRESS_FAILED_TTL_MS = 720 * 60 * 60 * 1e3;
+const SLACK_INGRESS_FAILED_MAX_ENTRIES = 2e4;
+const SLACK_BOLT_AUTHORIZATION_ERROR = "slack_bolt_authorization_error";
+const SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY = "openclawIngressLifecycle";
+/** Logical message identity: mirrors the retired guard key (team:channel:ts). */
+function resolveSlackRelayIngressEventId(event) {
+	const ts = event.message.ts?.trim();
+	if (!event.message.channel?.trim() || !ts) return `relay:${event.deliveryId}`;
+	const team = event.message.team?.trim();
+	return `message:${team ? `${team}:` : ""}${event.message.channel.trim()}:${ts}`;
+}
+var SlackIngressPayloadError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SlackIngressPayloadError";
+	}
+};
+function resolveSlackEventId(body) {
+	const eventId = asOptionalRecord(body)?.event_id;
+	return typeof eventId === "string" && eventId.trim() ? eventId.trim() : null;
+}
+function resolveSlackIngressLane(body, eventId) {
+	const envelope = asOptionalRecord(body);
+	const event = asOptionalRecord(envelope?.event);
+	const item = asOptionalRecord(event?.item);
+	const assistantThread = asOptionalRecord(event?.assistant_thread);
+	const team = asOptionalRecord(envelope?.team);
+	const teamId = [
+		envelope?.team_id,
+		team?.id,
+		event?.team
+	].find((value) => typeof value === "string" && value.trim())?.toString().trim() || "workspace";
+	const channelId = [
+		event?.channel,
+		event?.channel_id,
+		item?.channel,
+		assistantThread?.channel_id
+	].find((value) => typeof value === "string" && value.trim())?.toString().trim();
+	if (channelId) return `team:${teamId}:conversation:${channelId}`;
+	const userId = [event?.user, event?.user_id].find((value) => typeof value === "string" && value.trim())?.toString().trim();
+	return userId ? `team:${teamId}:user:${userId}` : `event:${eventId}`;
+}
+function isSlackEventCallback(body) {
+	return asOptionalRecord(body)?.type === "event_callback";
+}
+function assertSlackIngressPayload(payload, eventId) {
+	if (payload.version !== SLACK_INGRESS_PAYLOAD_VERSION) throw new SlackIngressPayloadError(`Slack ingress payload ${eventId} was invalid.`);
+	if (payload.kind === "relay") {
+		if (!asOptionalRecord(payload.message)) throw new SlackIngressPayloadError(`Slack relay ingress payload ${eventId} was invalid.`);
+		return;
+	}
+	if (!asOptionalRecord(payload.body) || resolveSlackEventId(payload.body) !== eventId) throw new SlackIngressPayloadError(`Slack ingress payload ${eventId} was invalid.`);
+}
+function resolveSlackIngressNonRetryableFailure(error) {
+	for (const candidate of collectErrorGraphCandidates(error, (current) => [
+		current.cause,
+		current.error,
+		current.original
+	])) {
+		if (candidate instanceof SlackIngressPayloadError || candidate instanceof SyntaxError) return {
+			reason: "invalid-event",
+			message: formatErrorMessage(candidate)
+		};
+		if (extractErrorCode(candidate) === SLACK_BOLT_AUTHORIZATION_ERROR || isNonRecoverableSlackAuthError(candidate)) return {
+			reason: "slack-auth",
+			message: formatErrorMessage(candidate)
+		};
+	}
+	return null;
+}
+function resolveSlackIngressTurnLifecycle(context) {
+	const candidate = asOptionalRecord(context)?.[SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY];
+	if (!candidate || typeof candidate !== "object") return null;
+	const lifecycle = candidate;
+	return typeof lifecycle.onAdopted === "function" && lifecycle.abortSignal instanceof AbortSignal ? lifecycle : null;
+}
+function createSlackDurableIngress(options) {
+	let queue = options.queue;
+	let drain;
+	let app;
+	let relayDispatch;
+	let running = false;
+	let requested = false;
+	let pumping;
+	let pollTimer;
+	let lastPrunedAt = 0;
+	const getQueue = () => {
+		queue ??= getSlackRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
+		return queue;
+	};
+	const getDrain = () => {
+		drain ??= createChannelIngressDrain({
+			queue: getQueue(),
+			adoptionStallTimeoutMs: options.adoptionStallTimeoutMs ?? DEFAULT_INGRESS_ADOPTION_STALL_MS,
+			retryPolicy: {
+				maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+				deadLetterMinAgeMs: DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS
+			},
+			resolveNonRetryableFailure: resolveSlackIngressNonRetryableFailure,
+			deriveLaneKey: (record) => record.payload.kind === "relay" ? resolveSlackIngressLane({ event: record.payload.message }, record.id) : resolveSlackIngressLane(record.payload.body, record.id),
+			...options.onLog ? { onLog: options.onLog } : {},
+			...options.abortSignal ? { abortSignal: options.abortSignal } : {},
+			dispatchClaimedEvent: async (event, lifecycle) => {
+				assertSlackIngressPayload(event.payload, event.id);
+				if (lifecycle.abortSignal.aborted) throw lifecycle.abortSignal.reason;
+				const bound = bindIngressLifecycleToReplyOptions(lifecycle);
+				if (event.payload.kind === "relay") {
+					if (!relayDispatch) throw new Error("Slack relay ingress dispatcher is not attached.");
+					await relayDispatch(event.payload.message, bound.turnAdoptionLifecycle);
+					return;
+				}
+				if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
+				await app.processEvent({
+					body: event.payload.body,
+					ack: async () => {},
+					...event.payload.retryNum === void 0 ? {} : { retryNum: event.payload.retryNum },
+					...event.payload.retryReason === void 0 ? {} : { retryReason: event.payload.retryReason },
+					customProperties: { [SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY]: bound.turnAdoptionLifecycle }
+				});
+			}
+		});
+		return drain;
+	};
+	const pruneIfDue = async () => {
+		const now = Date.now();
+		if (now - lastPrunedAt < SLACK_INGRESS_PRUNE_INTERVAL_MS) return;
+		await getQueue().prune({
+			completedTtlMs: SLACK_INGRESS_COMPLETED_TTL_MS,
+			completedMaxEntries: SLACK_INGRESS_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: SLACK_INGRESS_FAILED_TTL_MS,
+			failedMaxEntries: SLACK_INGRESS_FAILED_MAX_ENTRIES,
+			now
+		});
+		lastPrunedAt = now;
+	};
+	const runPump = async () => {
+		try {
+			for (;;) {
+				requested = false;
+				await pruneIfDue();
+				const activeDrain = getDrain();
+				const { started } = await activeDrain.drainOnce();
+				await activeDrain.waitForIdle();
+				if (!running || !requested && started === 0) break;
+			}
+		} catch (error) {
+			options.onLog?.(`slack ingress drain failed: ${formatErrorMessage(error)}`);
+		} finally {
+			pumping = void 0;
+			if (running && requested) requestDrain();
+		}
+	};
+	const requestDrain = () => {
+		requested = true;
+		if (!running || pumping) return;
+		pumping = runPump();
+	};
+	const acceptReceiverEvent = async (event) => {
+		if (!isSlackEventCallback(event.body)) {
+			if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
+			await app.processEvent(event);
+			return;
+		}
+		const eventId = resolveSlackEventId(event.body);
+		if (!eventId) throw new SlackIngressPayloadError("Slack Events API envelope missing event_id.");
+		const receivedAt = Date.now();
+		await getQueue().enqueue(eventId, {
+			version: SLACK_INGRESS_PAYLOAD_VERSION,
+			receivedAt,
+			kind: "events-api",
+			body: event.body,
+			...event.retryNum === void 0 ? {} : { retryNum: event.retryNum },
+			...event.retryReason === void 0 ? {} : { retryReason: event.retryReason }
+		}, { receivedAt });
+		await event.ack();
+		requestDrain();
+	};
+	const acceptRelayEvent = async (event) => {
+		const receivedAt = Date.now();
+		await getQueue().enqueue(resolveSlackRelayIngressEventId(event), {
+			version: SLACK_INGRESS_PAYLOAD_VERSION,
+			receivedAt,
+			kind: "relay",
+			message: event.message
+		}, { receivedAt });
+		requestDrain();
+	};
+	return {
+		wrapReceiver: (receiver) => {
+			const client = Reflect.get(receiver, "client");
+			return {
+				init: (nextApp) => {
+					app = nextApp;
+					receiver.init({ processEvent: acceptReceiverEvent });
+				},
+				start: (...args) => receiver.start(...args),
+				stop: (...args) => receiver.stop(...args),
+				...client === void 0 ? {} : { client }
+			};
+		},
+		acceptRelayEvent,
+		attachRelayDispatch: (dispatch) => {
+			relayDispatch = dispatch;
+		},
+		start: () => {
+			if (running) return;
+			running = true;
+			pollTimer = setInterval(requestDrain, options.pollIntervalMs ?? SLACK_INGRESS_POLL_INTERVAL_MS);
+			pollTimer.unref?.();
+			requestDrain();
+		},
+		stop: async () => {
+			running = false;
+			if (pollTimer) {
+				clearInterval(pollTimer);
+				pollTimer = void 0;
+			}
+			drain?.dispose();
+			await pumping;
+			await drain?.waitForIdle();
+		},
+		waitForIdle: async () => {
+			for (;;) {
+				const activePump = pumping;
+				if (!activePump) break;
+				await activePump;
+			}
+			await drain?.waitForIdle();
+		}
+	};
+}
+//#endregion
 //#region extensions/slack/src/monitor/events/message-subtype-handlers.ts
 const SUBTYPE_HANDLER_REGISTRY = {
 	message_changed: {
@@ -2758,6 +3126,7 @@ function registerSlackMessageEvents(params) {
 		return resolved.scope;
 	};
 	const handleIncomingMessageEvent = async ({ event, body, context, client }) => {
+		const turnAdoptionLifecycle = resolveSlackIngressTurnLifecycle(context);
 		try {
 			const eventScope = resolveEventScope({
 				body,
@@ -2783,10 +3152,9 @@ function registerSlackMessageEvents(params) {
 			if (assistantChangedInbound) {
 				await handleSlackMessage(assistantChangedInbound, {
 					source: "message",
-					...eventScope ? {
-						eventScope,
-						awaitDispatch: true
-					} : {}
+					...eventScope ? { eventScope } : {},
+					...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
+					...eventScope || turnAdoptionLifecycle ? { awaitDispatch: true } : {}
 				});
 				return;
 			}
@@ -2814,12 +3182,12 @@ function registerSlackMessageEvents(params) {
 			}
 			await handleSlackMessage(message, {
 				source: "message",
-				...eventScope ? {
-					eventScope,
-					awaitDispatch: true
-				} : {}
+				...eventScope ? { eventScope } : {},
+				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
+				...eventScope || turnAdoptionLifecycle ? { awaitDispatch: true } : {}
 			});
 		} catch (err) {
+			if (turnAdoptionLifecycle) throw err;
 			ctx.runtime.error?.(danger(`slack handler failed: ${formatErrorMessage(err)}`));
 		}
 	};
@@ -2828,6 +3196,7 @@ function registerSlackMessageEvents(params) {
 	});
 	ctx.app.event("app_mention", async (args) => {
 		const { event, body, context, client } = args;
+		const turnAdoptionLifecycle = resolveSlackIngressTurnLifecycle(context);
 		try {
 			const eventScope = resolveEventScope({
 				body,
@@ -2854,12 +3223,12 @@ function registerSlackMessageEvents(params) {
 			await handleSlackMessage(mention, {
 				source: "app_mention",
 				wasMentioned: true,
-				...eventScope ? {
-					eventScope,
-					awaitDispatch: true
-				} : {}
+				...eventScope ? { eventScope } : {},
+				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
+				...eventScope || turnAdoptionLifecycle ? { awaitDispatch: true } : {}
 			});
 		} catch (err) {
+			if (turnAdoptionLifecycle) throw err;
 			ctx.runtime.error?.(danger(`slack mention handler failed: ${formatErrorMessage(err)}`));
 		}
 	});
@@ -3018,41 +3387,58 @@ function registerSlackMonitorEvents(params) {
 	});
 }
 //#endregion
-//#region extensions/slack/src/monitor/inbound-delivery-state.ts
-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 {}
+//#region extensions/slack/src/monitor/message-dispatch-dedupe.ts
+const SLACK_MESSAGE_DISPATCH_DEDUPE_TTL_MS = 1440 * 60 * 1e3;
+const SLACK_MESSAGE_DISPATCH_DEDUPE_MEMORY_MAX_ENTRIES = 2e4;
+const SLACK_MESSAGE_DISPATCH_DEDUPE_STATE_MAX_ENTRIES = 2e4;
+const SLACK_MESSAGE_DISPATCH_DEDUPE_NAMESPACE = "global";
+const SLACK_MESSAGE_DISPATCH_DEDUPE_NAMESPACE_PREFIX = "slack.message-dispatch-dedupe";
+const SLACK_MESSAGE_DISPATCH_DEDUPE_STATE_PLUGIN_ID = "slack-message-dispatch-dedupe";
+function buildSlackMessageDispatchReplayKey(params) {
+	const channelId = params.channelId?.trim();
+	const ts = params.ts?.trim();
+	if (!channelId || !ts) return null;
+	const teamId = params.teamId?.trim();
+	return JSON.stringify([
+		"message",
+		params.accountId,
+		teamId ?? "",
+		channelId,
+		ts
+	]);
+}
+function createSlackMessageDispatchReplayGuard(params = {}) {
+	return createChannelReplayGuard({
+		dedupe: {
+			ttlMs: SLACK_MESSAGE_DISPATCH_DEDUPE_TTL_MS,
+			memoryMaxSize: SLACK_MESSAGE_DISPATCH_DEDUPE_MEMORY_MAX_ENTRIES,
+			pluginId: SLACK_MESSAGE_DISPATCH_DEDUPE_STATE_PLUGIN_ID,
+			namespacePrefix: SLACK_MESSAGE_DISPATCH_DEDUPE_NAMESPACE_PREFIX,
+			stateMaxEntries: SLACK_MESSAGE_DISPATCH_DEDUPE_STATE_MAX_ENTRIES,
+			...params.onDiskError ? { onDiskError: params.onDiskError } : {}
+		},
+		buildReplayKey: (event) => event.keys,
+		namespace: () => SLACK_MESSAGE_DISPATCH_DEDUPE_NAMESPACE
+	});
+}
+/** Claim one logical message key; an in-flight sibling claim settles to duplicate. */
+async function claimSlackMessageDispatchReplay(params) {
+	let releaseRetries = 0;
+	while (true) {
+		const claim = await params.guard.claim({ keys: [params.key] });
+		if (claim.kind === "claimed") return {
+			kind: "claimed",
+			handle: claim.handle
+		};
+		if (claim.kind === "duplicate" || claim.kind === "invalid") return { kind: "duplicate" };
+		try {
+			await claim.pending;
+			return { kind: "duplicate" };
+		} catch {
+			releaseRetries += 1;
+			if (releaseRetries > 1) return { kind: "duplicate" };
 		}
 	}
-});
-function makeKey(accountId, channelId, ts, teamId) {
-	return `${accountId}:${teamId ? `${teamId}:` : ""}${channelId}:${ts}`;
-}
-async function hasSlackInboundMessageDelivery(params) {
-	if (!params.accountId || !params.channelId || !params.ts) return false;
-	return await deliveredMessages.lookup(makeKey(params.accountId, params.channelId, params.ts, params.teamId));
-}
-async function recordSlackInboundMessageDeliveries(params) {
-	if (!params.accountId || params.messages.length === 0) return;
-	const deliveredAt = Date.now();
-	const keys = /* @__PURE__ */ new Set();
-	for (const message of params.messages) {
-		if (!message.channel || !message.ts) continue;
-		keys.add(makeKey(params.accountId, message.channel, message.ts, params.teamId));
-	}
-	await Promise.all(Array.from(keys, (key) => deliveredMessages.register(key, { deliveredAt }, { at: deliveredAt })));
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/debounce-key.ts
@@ -3180,7 +3566,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-CTvokbty.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -3193,7 +3579,6 @@ function createSlackDispatchCompletion() {
 		reject
 	};
 }
-const APP_MENTION_RETRY_TTL_MS = 6e4;
 const RETRYABLE_FLUSH_MAX_ATTEMPTS = 3;
 const RETRYABLE_FLUSH_RETRY_DELAY_MS = 1e3;
 const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
@@ -3207,12 +3592,9 @@ function shouldDebounceSlackMessage(message, cfg) {
 		hasMedia: Boolean(message.files && message.files.length > 0)
 	});
 }
-function buildSeenMessageKey(channelId, ts, teamId) {
-	if (!channelId || !ts) return null;
-	return `${teamId ? `${teamId}:` : ""}${channelId}:${ts}`;
-}
 function createSlackMessageHandler(params) {
-	const { ctx, account, trackEvent } = params;
+	const { ctx, account, trackEvent, onPrepared } = params;
+	const dispatchReplayGuard = params.dispatchReplayGuard ?? createSlackMessageDispatchReplayGuard({ onDiskError: (error) => ctx.runtime.error?.(`slack message dispatch dedupe persistence failed: ${formatErrorMessage(error)}`) });
 	const { debounceMs, debouncer } = createChannelInboundDebouncer({
 		cfg: ctx.cfg,
 		channel: "slack",
@@ -3245,8 +3627,41 @@ function createSlackMessageHandler(params) {
 			const completions = entries.map((entry) => entry.opts.dispatchCompletion).filter((completion) => completion !== void 0);
 			try {
 				await (async () => {
-					const last = entries.at(-1);
-					if (!last) return;
+					const claims = [];
+					const claimedKeys = /* @__PURE__ */ new Set();
+					const surviving = [];
+					for (const entry of entries) {
+						const replayKey = buildSlackMessageDispatchReplayKey({
+							accountId: ctx.accountId,
+							channelId: entry.message.channel,
+							ts: entry.message.ts,
+							teamId: entry.opts.eventScope?.teamId
+						});
+						if (!replayKey || claimedKeys.has(replayKey)) {
+							surviving.push(entry);
+							continue;
+						}
+						const claim = await claimSlackMessageDispatchReplay({
+							guard: dispatchReplayGuard,
+							key: replayKey
+						});
+						if (claim.kind === "claimed") {
+							claims.push(claim.handle);
+							claimedKeys.add(replayKey);
+							surviving.push(entry);
+						}
+					}
+					const releaseClaims = (error) => {
+						for (const handle of claims) handle.release(error === void 0 ? {} : { error });
+					};
+					const commitClaims = async () => {
+						for (const handle of claims) await handle.commit();
+					};
+					const last = surviving.at(-1);
+					if (!last) {
+						releaseClaims();
+						return;
+					}
 					const teamId = last.opts.eventScope?.teamId;
 					const flushedKey = buildSlackDebounceKey(last.message, ctx.accountId, teamId);
 					const topLevelConversationKey = buildTopLevelSlackConversationKey(last.message, ctx.accountId, teamId);
@@ -3257,75 +3672,60 @@ function createSlackMessageHandler(params) {
 							if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
 						}
 					}
-					const combinedText = entries.length === 1 ? last.message.text ?? "" : entries.map((entry) => entry.message.text ?? "").filter(Boolean).join("\n");
-					const combinedMentioned = entries.some((entry) => Boolean(entry.opts.wasMentioned));
+					const 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 = {
 						...last.message,
 						text: combinedText
 					};
-					const seenMessageKey = buildSeenMessageKey(last.message.channel, last.message.ts, last.opts.eventScope?.teamId);
+					const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
+					const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, turnAdoptionLifecycle, ...lastOpts } = last.opts;
+					let prepared;
+					let settlementHandedOff = false;
 					try {
-						const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
-						const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, ...lastOpts } = last.opts;
-						const appMentionRetryKey = seenMessageKey && lastOpts.source === "app_mention" && !ctx.botUserId ? seenMessageKey : void 0;
-						if (appMentionRetryKey) appMentionPreparingKeys.add(appMentionRetryKey);
-						const prepared = await (async () => {
-							try {
-								const result = await prepareSlackMessage({
-									ctx,
-									account,
-									message: syntheticMessage,
-									opts: {
-										...lastOpts,
-										wasMentioned: combinedMentioned || last.opts.wasMentioned,
-										...seenMessageKey && lastOpts.source === "message" ? { shouldRecordDroppedHistory: () => !appMentionPreparingKeys.has(seenMessageKey) && !appMentionDispatchedKeys.has(seenMessageKey) } : {}
-									}
-								});
-								if (result && seenMessageKey) {
-									pruneAppMentionRetryKeys(Date.now());
-									if (last.opts.source === "app_mention") rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
-									else if (last.opts.source === "message" && appMentionDispatchedKeys.has(seenMessageKey)) {
-										appMentionDispatchedKeys.delete(seenMessageKey);
-										appMentionRetryKeys.delete(seenMessageKey);
-										return null;
-									}
-									appMentionRetryKeys.delete(seenMessageKey);
-								}
-								return result;
-							} finally {
-								if (appMentionRetryKey) appMentionPreparingKeys.delete(appMentionRetryKey);
+						prepared = await prepareSlackMessage({
+							ctx,
+							account,
+							message: syntheticMessage,
+							opts: {
+								...lastOpts,
+								wasMentioned: combinedMentioned || last.opts.wasMentioned
 							}
-						})();
-						if (!prepared) return;
-						if (entries.length > 1) {
-							const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
+						});
+						if (!prepared) {
+							releaseClaims();
+							return;
+						}
+						prepared.turnAdoptionLifecycle = turnAdoptionLifecycle ? {
+							...turnAdoptionLifecycle,
+							onAdopted: async () => {
+								settlementHandedOff = true;
+								await commitClaims();
+								await turnAdoptionLifecycle.onAdopted();
+							},
+							onDeferred: () => {
+								settlementHandedOff = true;
+								turnAdoptionLifecycle.onDeferred();
+							},
+							onAbandoned: () => {
+								releaseClaims();
+								turnAdoptionLifecycle.onAbandoned();
+							}
+						} : turnAdoptionLifecycle;
+						onPrepared?.(prepared);
+						if (surviving.length > 1) {
+							const ids = surviving.map((entry) => entry.message.ts).filter(Boolean);
 							if (ids.length > 0) {
 								prepared.ctxPayload.MessageSids = ids;
 								prepared.ctxPayload.MessageSidFirst = ids[0];
 								prepared.ctxPayload.MessageSidLast = ids[ids.length - 1];
 							}
 						}
-						try {
-							await dispatchPreparedSlackMessage(prepared);
-							await recordSlackInboundMessageDeliveries({
-								accountId: ctx.accountId,
-								...last.opts.eventScope ? { teamId: last.opts.eventScope.teamId } : {},
-								messages: entries.map((entry) => entry.message)
-							});
-						} catch (error) {
-							if (!isRetryableSlackInboundError(error)) await recordSlackInboundMessageDeliveries({
-								accountId: ctx.accountId,
-								...last.opts.eventScope ? { teamId: last.opts.eventScope.teamId } : {},
-								messages: entries.map((entry) => entry.message)
-							});
-							throw error;
-						}
+						await dispatchPreparedSlackMessage(prepared);
+						if (!turnAdoptionLifecycle) await commitClaims();
+						else if (!settlementHandedOff) releaseClaims();
 					} catch (error) {
-						if (isRetryableSlackInboundError(error)) for (const entry of entries) {
-							const entrySeenKey = buildSeenMessageKey(entry.message.channel, entry.message.ts, entry.opts.eventScope?.teamId);
-							if (entrySeenKey) appMentionDispatchedKeys.delete(entrySeenKey);
-							ctx.releaseSeenMessage(entry.message.channel, entry.message.ts, entry.opts.eventScope);
-						}
+						releaseClaims(error);
 						throw error;
 					}
 				})();
@@ -3342,51 +3742,10 @@ 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);
-		if (now === void 0) {
-			appMentionRetryKeys.clear();
-			appMentionDispatchedKeys.clear();
-			return false;
-		}
-		for (const [key, expiresAt] of appMentionRetryKeys) if (asDateTimestampMs(expiresAt) === void 0 || expiresAt <= now) appMentionRetryKeys.delete(key);
-		for (const [key, expiresAt] of appMentionDispatchedKeys) if (asDateTimestampMs(expiresAt) === void 0 || expiresAt <= now) appMentionDispatchedKeys.delete(key);
-		return true;
-	};
-	const rememberExpiringAppMentionKey = (map, key) => {
-		const now = Date.now();
-		if (!pruneAppMentionRetryKeys(now)) return;
-		const expiresAt = resolveExpiresAtMsFromDurationMs(APP_MENTION_RETRY_TTL_MS, { nowMs: now });
-		if (expiresAt !== void 0) map.set(key, expiresAt);
-	};
-	const rememberAppMentionRetryKey = (key) => {
-		rememberExpiringAppMentionKey(appMentionRetryKeys, key);
-	};
-	const consumeAppMentionRetryKey = (key) => {
-		if (!pruneAppMentionRetryKeys(Date.now())) return false;
-		if (!appMentionRetryKeys.has(key)) return false;
-		appMentionRetryKeys.delete(key);
-		return true;
-	};
 	async function enqueueSlackMessage(message, opts) {
 		if (opts.source === "message" && message.type !== "message") return;
 		if (opts.source === "message" && message.subtype && message.subtype !== "file_share" && message.subtype !== "bot_message" && message.subtype !== "thread_broadcast") return;
 		ctx.rememberSlackChannelType(message.channel, message.channel_type, opts.eventScope);
-		const seenMessageKey = buildSeenMessageKey(message.channel, message.ts, opts.eventScope?.teamId);
-		if (seenMessageKey && await hasSlackInboundMessageDelivery({
-			accountId: ctx.accountId,
-			channelId: message.channel,
-			ts: message.ts,
-			...opts.eventScope ? { teamId: opts.eventScope.teamId } : {}
-		})) return;
-		const wasSeen = seenMessageKey ? ctx.markMessageSeen(message.channel, message.ts, opts.eventScope) : false;
-		if (seenMessageKey && opts.source === "message" && !wasSeen) rememberAppMentionRetryKey(seenMessageKey);
-		if (seenMessageKey && wasSeen) {
-			if (opts.source !== "app_mention" || !consumeAppMentionRetryKey(seenMessageKey)) return;
-		}
 		trackEvent?.();
 		const resolvedMessage = await (opts.eventScope ? createSlackThreadTsResolver({ client: opts.eventScope.client }) : threadTsResolver).resolve({
 			message,
@@ -3426,110 +3785,201 @@ function createSlackMessageHandler(params) {
 	};
 }
 //#endregion
-//#region extensions/slack/src/monitor/reconnect-policy.ts
-const SLACK_AUTH_ERROR_RE = /account_inactive|invalid_auth|token_revoked|token_expired|not_authed|org_login_required|team_access_not_granted|user_removed_from_team|team_disabled|missing_scope|cannot_find_service|invalid_token/i;
-const NO_ERROR_DETAIL = "no error detail";
-const SLACK_SOCKET_RECONNECT_POLICY = {
-	initialMs: 2e3,
-	maxMs: 3e4,
-	factor: 1.8,
-	jitter: .25
-};
-const SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL = "https://docs.slack.dev/apis/events-api/using-socket-mode#using-multiple-connections";
-const SLACK_SOCKET_HELLO_MARKER = Buffer.from("\"hello\"");
-function getSocketEmitter(app) {
-	const receiver = app.receiver;
-	const client = receiver && typeof receiver === "object" ? receiver.client : void 0;
-	if (!client || typeof client !== "object") return null;
-	const on = client.on;
-	const off = client.off;
-	if (typeof on !== "function" || typeof off !== "function") return null;
+//#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 {
-		on: (event, listener) => on.call(client, event, listener),
-		off: (event, listener) => off.call(client, event, listener)
+		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 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);
+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);
 	};
-	emitter.on("ws_message", listener);
-	return () => {
-		emitter.off("ws_message", listener);
+	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);
 	};
-}
-function waitForSlackSocketDisconnect(app, abortSignal) {
-	return new Promise((resolve) => {
-		const emitter = getSocketEmitter(app);
-		if (!emitter) {
-			abortSignal?.addEventListener("abort", () => resolve({ event: "disconnect" }), { once: true });
+	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;
 		}
-		const disconnectListener = () => resolveOnce({ event: "disconnect" });
-		const startFailListener = (error) => resolveOnce({
-			event: "unable_to_socket_mode_start",
-			error
+		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 errorListener = (error) => resolveOnce({
-			event: "error",
-			error
+	};
+	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;
 		});
-		const abortListener = () => resolveOnce({ event: "disconnect" });
-		const cleanup = () => {
-			emitter.off("disconnected", disconnectListener);
-			emitter.off("unable_to_socket_mode_start", startFailListener);
-			emitter.off("error", errorListener);
-			abortSignal?.removeEventListener("abort", abortListener);
-		};
-		const resolveOnce = (value) => {
-			cleanup();
-			resolve(value);
-		};
-		emitter.on("disconnected", disconnectListener);
-		emitter.on("unable_to_socket_mode_start", startFailListener);
-		emitter.on("error", errorListener);
-		abortSignal?.addEventListener("abort", abortListener, { once: true });
-	});
-}
-/**
-* Detect permanent Slack account and credential failures.
-* Transient request and HTTP failures stay in OpenClaw's reconnect loop.
-*/
-function isNonRecoverableSlackAuthError(error) {
-	return SLACK_AUTH_ERROR_RE.test(formatUnknownError(error, ""));
+		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;
+		}
+	};
 }
-function formatUnknownError(error, fallback = NO_ERROR_DETAIL) {
-	return formatSlackError(error, fallback);
+//#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/provider-support.ts
@@ -3614,13 +4064,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) {
@@ -3694,7 +4146,8 @@ function createSlackBoltApp(params) {
 		autoReconnectEnabled: true,
 		clientPingTimeout: params.socketMode?.clientPingTimeout ?? OPENCLAW_SLACK_CLIENT_PING_TIMEOUT_MS,
 		logger: socketModeLogger,
-		installerOptions: { clientOptions: params.clientOptions }
+		installerOptions: { clientOptions: params.clientOptions },
+		...params.wrapReceiver ? { processEventErrorHandler: async () => false } : {}
 	};
 	if (params.socketMode?.serverPingTimeout !== void 0) socketModeReceiverOptions.serverPingTimeout = params.socketMode.serverPingTimeout;
 	if (params.socketMode?.pingPongLoggingEnabled !== void 0) socketModeReceiverOptions.pingPongLoggingEnabled = params.socketMode.pingPongLoggingEnabled;
@@ -3704,15 +4157,17 @@ function createSlackBoltApp(params) {
 		installSlackNativeReconnectFailureObserver(receiver);
 	} else if (params.slackMode === "http") receiver = new params.interop.HTTPReceiver({
 		signingSecret: params.signingSecret ?? "",
-		endpoints: params.slackWebhookPath
+		endpoints: params.slackWebhookPath,
+		...params.wrapReceiver ? { processEventErrorHandler: async () => false } : {}
 	});
 	else receiver = createSlackRelayReceiver();
+	const appReceiver = receiver && params.wrapReceiver ? params.wrapReceiver(receiver) : receiver;
 	const app = new params.interop.App({
-		token: params.botToken,
+		token: params.token,
 		clientOptions: params.clientOptions,
 		ignoreSelf: false,
 		tokenVerificationEnabled: false,
-		...receiver ? { receiver } : {}
+		...appReceiver ? { receiver: appReceiver } : {}
 	});
 	app.use(async (args) => {
 		if (shouldSkipOpenClawSlackSelfEvent(args)) return;
@@ -3960,7 +4415,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-BT-mMm-f.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 +5155,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-B-6LFUdz.js"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-Ea_P9VcO.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveStableSlackUserIdEntry(raw) {
@@ -4793,16 +5248,26 @@ async function monitorSlackProvider(opts = {}) {
 		path: `channels.slack.accounts.${account.accountId}.signingSecret`
 	});
 	const botToken = resolveSlackBotToken(opts.botToken ?? account.botToken);
+	const userToken = account.userToken;
 	const appToken = resolveSlackAppToken(opts.appToken ?? account.appToken);
 	const relayConfig = slackMode === "relay" ? resolveSlackRelayConfig({
 		relay: account.config.relay,
 		accountId: account.accountId
 	}) : void 0;
-	if (!botToken || slackMode === "socket" && !appToken) {
-		const missing = slackMode === "http" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : slackMode === "relay" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : `Slack bot + app tokens missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken/appToken or SLACK_BOT_TOKEN/SLACK_APP_TOKEN for default).`;
-		throw new Error(missing);
+	let token;
+	if (account.identity === "user") {
+		if (!userToken) throw new Error(`Slack user token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.userToken or SLACK_USER_TOKEN for default).`);
+		if (slackMode === "socket" && !appToken) throw new Error(`Slack app token missing for user-identity socket mode account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.appToken or SLACK_APP_TOKEN for default).`);
+		if (slackMode === "http" && !signingSecret) throw new Error(`Slack signing secret missing for user-identity HTTP mode account "${account.accountId}" (set channels.slack.signingSecret or channels.slack.accounts.${account.accountId}.signingSecret).`);
+		token = userToken;
+	} else {
+		if (!botToken || slackMode === "socket" && !appToken) {
+			const missing = slackMode === "http" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : slackMode === "relay" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : `Slack bot + app tokens missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken/appToken or SLACK_BOT_TOKEN/SLACK_APP_TOKEN for default).`;
+			throw new Error(missing);
+		}
+		if (slackMode === "http" && !signingSecret) throw new Error(`Slack signing secret missing for account "${account.accountId}" (set channels.slack.signingSecret or channels.slack.accounts.${account.accountId}.signingSecret).`);
+		token = botToken;
 	}
-	if (slackMode === "http" && !signingSecret) throw new Error(`Slack signing secret missing for account "${account.accountId}" (set channels.slack.signingSecret or channels.slack.accounts.${account.accountId}.signingSecret).`);
 	const slackCfg = account.config;
 	const dmConfig = slackCfg.dm;
 	const dmEnabled = dmConfig?.enabled ?? true;
@@ -4842,7 +5307,6 @@ async function monitorSlackProvider(opts = {}) {
 	const replyToMode = slackCfg.replyToMode ?? "off";
 	const threadHistoryScope = slackCfg.thread?.historyScope ?? "thread";
 	const threadInheritParent = slackCfg.thread?.inheritParent ?? false;
-	const threadRequireExplicitMention = slackCfg.thread?.requireExplicitMention ?? false;
 	const slashCommand = resolveSlackSlashCommandConfig(opts.slashCommand ?? slackCfg.slashCommand);
 	const allowNameMatching = isDangerousNameMatchingEnabled(slackCfg);
 	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: SLACK_TEXT_LIMIT });
@@ -4851,15 +5315,21 @@ async function monitorSlackProvider(opts = {}) {
 	const mediaMaxBytes = (opts.mediaMaxMb ?? slackCfg.mediaMaxMb ?? 20) * 1024 * 1024;
 	const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
 	const clientOptions = resolveSlackWebClientOptions();
+	const durableIngress = createSlackDurableIngress({
+		accountId: account.accountId,
+		...runtime.log ? { onLog: runtime.log } : {},
+		...opts.abortSignal ? { abortSignal: opts.abortSignal } : {}
+	});
 	const { app, receiver, socketModeLogger } = createSlackBoltApp({
 		interop: await getSlackBoltInterop(),
 		slackMode,
-		botToken,
+		token,
 		appToken: slackMode === "socket" ? appToken ?? void 0 : void 0,
 		signingSecret: slackMode === "http" ? signingSecret ?? void 0 : void 0,
 		slackWebhookPath,
 		clientOptions,
-		...slackCfg.socketMode ? { socketMode: slackCfg.socketMode } : {}
+		...slackCfg.socketMode ? { socketMode: slackCfg.socketMode } : {},
+		wrapReceiver: durableIngress.wrapReceiver
 	});
 	const gracefulStop = async () => {
 		await gracefulStopSlackApp(app);
@@ -4890,43 +5360,50 @@ 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(token, clientOptions).auth.test();
 		const authUserId = normalizeOptionalString(auth.user_id) ?? "";
 		botId = normalizeOptionalString(auth.bot_id) ?? "";
-		botUserId = botId ? authUserId : "";
+		botUserId = account.identity === "user" ? authUserId : botId ? authUserId : "";
 		authTestIdentity = auth;
-		authIdentityWarning = formatSlackBotTokenIdentityWarning({
+		if (account.identity === "bot") authIdentityWarning = formatSlackBotTokenIdentityWarning({
 			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) {
+		const identityFailureDetail = account.identity === "user" ? "explicit self-mention detection will be disabled until restart with a valid user token" : "explicit bot-mention detection will be disabled until restart with a valid bot token";
+		runtime.log?.(warn(`[${account.accountId}] slack auth.test failed at boot (${authTestError}); ${identityFailureDetail}; 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 app_id=${apiAppId} but app token looks like app_id=${expectedApiAppIdFromAppToken}`);
+	const identityHealth = resolveSlackIdentityHealth({
+		installationIdentity,
+		botUserId,
+		authTestError,
+		authIdentityWarning
+	});
+	if (apiAppId && expectedApiAppIdFromAppToken && apiAppId !== expectedApiAppIdFromAppToken) {
+		const identityTokenLabel = account.identity === "user" ? "user token" : "bot token";
+		runtime.error?.(`slack token mismatch: ${identityTokenLabel} app_id=${apiAppId} but app token looks like app_id=${expectedApiAppIdFromAppToken}`);
+	}
 	const ctx = createSlackMonitorContext({
 		cfg,
 		accountId: account.accountId,
-		botToken,
+		botToken: token,
 		app,
 		runtime,
 		channelRuntime: opts.channelRuntime,
@@ -4954,7 +5431,6 @@ async function monitorSlackProvider(opts = {}) {
 		replyToMode,
 		threadHistoryScope,
 		threadInheritParent,
-		threadRequireExplicitMention,
 		slashCommand,
 		textLimit,
 		ackReactionScope,
@@ -4968,10 +5444,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 +5489,8 @@ async function monitorSlackProvider(opts = {}) {
 		appHomeSlashCommandName: commandRegistration.mode === "single" ? commandRegistration.name : void 0,
 		trackEvent
 	});
+	durableIngress.start();
+	presenceMonitor?.start();
 	if (slackMode === "http" && slackHttpHandler) unregisterHttpHandler = registerSlackHttpHandler({
 		path: slackWebhookPath,
 		handler: slackHttpHandler,
@@ -5113,10 +5605,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");
 						}
 					}
 				});
@@ -5163,9 +5655,17 @@ async function monitorSlackProvider(opts = {}) {
 			}
 		} else if (slackMode === "relay" && relayConfig) {
 			runtime.log?.(`slack relay mode connecting to ${relayConfig.url} gateway_id:${relayConfig.gatewayId}`);
+			durableIngress.attachRelayDispatch(async (message, turnAdoptionLifecycle) => {
+				await handleSlackMessage(message, {
+					source: "message",
+					wasMentioned: true,
+					awaitDispatch: true,
+					turnAdoptionLifecycle
+				});
+			});
 			await (await loadSlackRelaySource()).monitorSlackRelaySource({
 				config: relayConfig,
-				handleSlackMessage,
+				acceptRelayEvent: durableIngress.acceptRelayEvent,
 				runtime,
 				abortSignal: opts.abortSignal,
 				setStatus: opts.setStatus,
@@ -5178,13 +5678,15 @@ async function monitorSlackProvider(opts = {}) {
 			});
 		}
 	} finally {
+		await presenceMonitor?.stop();
 		if (slackMode === "relay") setSlackDefaultSendIdentity(account.accountId, void 0);
 		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
 		unregisterSocketModeConnectionDiagnostics();
 		unregisterHttpHandler?.();
+		await durableIngress.stop();
 		await gracefulStop();
 	}
 }
 const resolveSlackRuntimeGroupPolicy = resolveOpenProviderRuntimeGroupPolicy$1;
 //#endregion
-export { buildSlackSlashCommandMatcher as C, updateLastRoute as S, resolveSlackChatType as _, createSlackResponseUrlBudget as a, resolveChannelResetConfig as b, formatUnknownError as c, authorizeSlackBotRoomMessage as d, resolveSlackCommandIngress as f, normalizeSlackChannelType as g, parseSlackAssistantThreadMetadata as h, SlackResponseAlreadyReportedError as i, recordInboundSession as l, buildSlackAssistantThreadMetadata as m, resolveSlackRuntimeGroupPolicy as n, authorizeSlackDirectMessage as o, resolveSlackEffectiveAllowFrom as p, resolveSlackRoomContextHints as r, SLACK_SOCKET_RECONNECT_POLICY as s, monitorSlackProvider as t, resolveConversationLabel$1 as u, readSessionUpdatedAt as v, stripSlackMentionsForCommandDetection as w, resolveStorePath$1 as x, resolveChannelContextVisibilityMode as y };
+export { stripSlackMentionsForCommandDetection as C, buildSlackSlashCommandMatcher as S, readSessionUpdatedAt as _, createSlackResponseUrlBudget as a, resolveStorePath$1 as b, formatUnknownError as c, resolveSlackCommandIngress as d, resolveSlackEffectiveAllowFrom as f, resolveSlackChatType as g, normalizeSlackChannelType as h, SlackResponseAlreadyReportedError as i, resolveConversationLabel$1 as l, parseSlackAssistantThreadMetadata as m, resolveSlackRuntimeGroupPolicy as n, authorizeSlackDirectMessage as o, buildSlackAssistantThreadMetadata as p, resolveSlackRoomContextHints as r, SLACK_SOCKET_RECONNECT_POLICY as s, monitorSlackProvider as t, authorizeSlackBotRoomMessage as u, resolveChannelContextVisibilityMode as v, updateLastRoute as x, resolveChannelResetConfig as y };