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

package/dist/{provider-CmeoUiIM.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 { 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 { 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 { 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
 /**
@@ -150,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
@@ -187,14 +184,6 @@ function createSlackMonitorContext(params) {
 		const id = normalizeOptionalString(channelId);
 		return id ? readLruMapEntry(channelCache, 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));
-	};
 	const assistantContextKey = (channelId, threadTs, eventScope) => scopedKey(`${channelId}:${threadTs}`, eventScope);
 	const cleanupAssistantThreadContexts = () => {
 		const now = Date.now();
@@ -472,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,
@@ -480,8 +468,6 @@ function createSlackMonitorContext(params) {
 		mediaMaxBytes: params.mediaMaxBytes,
 		removeAckAfterReply: params.removeAckAfterReply,
 		logger,
-		markMessageSeen,
-		releaseSeenMessage,
 		shouldDropMismatchedSlackEvent,
 		resolveSlackSystemEventSessionKey,
 		isChannelAllowed,
@@ -1927,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
@@ -2649,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: {
@@ -2776,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,
@@ -2801,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;
 			}
@@ -2832,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)}`));
 		}
 	};
@@ -2846,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,
@@ -2872,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)}`));
 		}
 	});
@@ -3036,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
@@ -3198,7 +3566,7 @@ function createSlackThreadTsResolver(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-DofAvTtb.js"));
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-CTvokbty.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -3211,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;
@@ -3225,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, 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",
@@ -3263,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);
@@ -3275,76 +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) {
+							releaseClaims();
+							return;
+						}
+						prepared.turnAdoptionLifecycle = turnAdoptionLifecycle ? {
+							...turnAdoptionLifecycle,
+							onAdopted: async () => {
+								settlementHandedOff = true;
+								await commitClaims();
+								await turnAdoptionLifecycle.onAdopted();
+							},
+							onDeferred: () => {
+								settlementHandedOff = true;
+								turnAdoptionLifecycle.onDeferred();
+							},
+							onAbandoned: () => {
+								releaseClaims();
+								turnAdoptionLifecycle.onAbandoned();
 							}
-						})();
-						if (!prepared) return;
+						} : turnAdoptionLifecycle;
 						onPrepared?.(prepared);
-						if (entries.length > 1) {
-							const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
+						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;
 					}
 				})();
@@ -3361,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,
@@ -3642,112 +3982,6 @@ function openSlackPresenceCooldownStore() {
 	});
 }
 //#endregion
-//#region extensions/slack/src/monitor/reconnect-policy.ts
-const SLACK_AUTH_ERROR_RE = /account_inactive|invalid_auth|token_revoked|token_expired|not_authed|org_login_required|team_access_not_granted|user_removed_from_team|team_disabled|missing_scope|cannot_find_service|invalid_token/i;
-const NO_ERROR_DETAIL = "no error detail";
-const SLACK_SOCKET_RECONNECT_POLICY = {
-	initialMs: 2e3,
-	maxMs: 3e4,
-	factor: 1.8,
-	jitter: .25
-};
-const SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL = "https://docs.slack.dev/apis/events-api/using-socket-mode#using-multiple-connections";
-const SLACK_SOCKET_HELLO_MARKER = Buffer.from("\"hello\"");
-function getSocketEmitter(app) {
-	const receiver = app.receiver;
-	const client = receiver && typeof receiver === "object" ? receiver.client : void 0;
-	if (!client || typeof client !== "object") return null;
-	const on = client.on;
-	const off = client.off;
-	if (typeof on !== "function" || typeof off !== "function") return null;
-	return {
-		on: (event, listener) => on.call(client, event, listener),
-		off: (event, listener) => off.call(client, event, listener)
-	};
-}
-function isBufferArray(value) {
-	return Array.isArray(value) && value.every((entry) => Buffer.isBuffer(entry));
-}
-function resolveSlackSocketModeConnectionCount(message) {
-	const buffer = Buffer.isBuffer(message) ? message : message instanceof ArrayBuffer ? Buffer.from(message) : isBufferArray(message) ? Buffer.concat(message) : void 0;
-	if (!buffer?.includes(SLACK_SOCKET_HELLO_MARKER)) return;
-	let payload;
-	try {
-		payload = JSON.parse(buffer.toString("utf8"));
-	} catch {
-		return;
-	}
-	const count = isRecord(payload) && payload.type === "hello" ? payload.num_connections : void 0;
-	return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : void 0;
-}
-function formatSlackSocketModeSharedConnectionWarning(activeConnections) {
-	return [
-		`slack socket mode reports ${activeConnections} active connections for this Slack app`,
-		"Slack may deliver each event to any one connection",
-		"ensure every OpenClaw gateway sharing this app has equivalent routing and authorization, or use a separate Slack app per gateway, one relay ingress, or HTTP Request URLs behind a load balancer",
-		`See ${SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL}`
-	].join("; ");
-}
-function registerSlackSocketModeConnectionDiagnostics(params) {
-	const emitter = getSocketEmitter(params.app);
-	if (!emitter) return () => {};
-	let hasWarned = false;
-	const listener = (message, isBinary) => {
-		if (isBinary === true || hasWarned) return;
-		const activeConnections = resolveSlackSocketModeConnectionCount(message);
-		if (activeConnections === void 0 || activeConnections <= 1) return;
-		hasWarned = true;
-		params.onSharedConnection(activeConnections);
-	};
-	emitter.on("ws_message", listener);
-	return () => {
-		emitter.off("ws_message", listener);
-	};
-}
-function waitForSlackSocketDisconnect(app, abortSignal) {
-	return new Promise((resolve) => {
-		const emitter = getSocketEmitter(app);
-		if (!emitter) {
-			abortSignal?.addEventListener("abort", () => resolve({ event: "disconnect" }), { once: true });
-			return;
-		}
-		const disconnectListener = () => resolveOnce({ event: "disconnect" });
-		const startFailListener = (error) => resolveOnce({
-			event: "unable_to_socket_mode_start",
-			error
-		});
-		const errorListener = (error) => resolveOnce({
-			event: "error",
-			error
-		});
-		const abortListener = () => resolveOnce({ event: "disconnect" });
-		const cleanup = () => {
-			emitter.off("disconnected", disconnectListener);
-			emitter.off("unable_to_socket_mode_start", startFailListener);
-			emitter.off("error", errorListener);
-			abortSignal?.removeEventListener("abort", abortListener);
-		};
-		const resolveOnce = (value) => {
-			cleanup();
-			resolve(value);
-		};
-		emitter.on("disconnected", disconnectListener);
-		emitter.on("unable_to_socket_mode_start", startFailListener);
-		emitter.on("error", errorListener);
-		abortSignal?.addEventListener("abort", abortListener, { once: true });
-	});
-}
-/**
-* Detect permanent Slack account and credential failures.
-* Transient request and HTTP failures stay in OpenClaw's reconnect loop.
-*/
-function isNonRecoverableSlackAuthError(error) {
-	return SLACK_AUTH_ERROR_RE.test(formatUnknownError(error, ""));
-}
-function formatUnknownError(error, fallback = NO_ERROR_DETAIL) {
-	return formatSlackError(error, fallback);
-}
-//#endregion
 //#region extensions/slack/src/monitor/provider-support.ts
 const OPENCLAW_SLACK_CLIENT_PING_TIMEOUT_MS = 15e3;
 const OPENCLAW_SLACK_SOCKET_START_FAILED_EVENT = "unable_to_socket_mode_start";
@@ -3912,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;
@@ -3922,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;
@@ -4178,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-CSja9VuD.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) {
@@ -4918,7 +5155,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-DMmgtvg4.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) {
@@ -5011,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;
@@ -5060,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 });
@@ -5069,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);
@@ -5112,12 +5364,12 @@ async function monitorSlackProvider(opts = {}) {
 	let authIdentityWarning;
 	let authTestIdentity;
 	try {
-		const auth = await createSlackStartupAuthClient(botToken, clientOptions).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
 		});
@@ -5133,7 +5385,10 @@ async function monitorSlackProvider(opts = {}) {
 	});
 	const teamId = installationIdentity.kind === "workspace" ? installationIdentity.teamId : "";
 	const apiAppId = installationIdentity.kind === "degraded" ? "" : installationIdentity.apiAppId ?? "";
-	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 (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));
 	const identityHealth = resolveSlackIdentityHealth({
 		installationIdentity,
@@ -5141,11 +5396,14 @@ async function monitorSlackProvider(opts = {}) {
 		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}`);
+	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,
@@ -5173,7 +5431,6 @@ async function monitorSlackProvider(opts = {}) {
 		replyToMode,
 		threadHistoryScope,
 		threadInheritParent,
-		threadRequireExplicitMention,
 		slashCommand,
 		textLimit,
 		ackReactionScope,
@@ -5232,6 +5489,7 @@ 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,
@@ -5397,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,
@@ -5417,9 +5683,10 @@ async function monitorSlackProvider(opts = {}) {
 		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 };