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

package/dist/{provider-CmeoUiIM.js → provider-htuIJGFD.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 { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as formatSlackBotTokenIdentityWarning } from "./accounts-BSr252c_.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-CdnQzQBI.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-C3ffk6oN.js";
+import { m as resolveSlackWebClientOptions, o as createSlackStartupAuthClient, r as formatSlackError, u as getSlackListenerUploadCompletionClient } from "./probe-CVRuArHA.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 { i as setSlackDefaultSendIdentity } from "./send-BZ1tPv7-.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DodP2TFx.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-M9eF8891.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-C31RYSuT.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 { createChannelIngressMonitor, 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";
@@ -35,7 +35,7 @@ import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-na
 import { getSessionEntry, readSessionUpdatedAt, resolveChannelResetConfig, resolveSessionKey, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy as resolveOpenProviderRuntimeGroupPolicy$1, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
-import { loadModelCatalog, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { loadPreparedModelCatalog, resolveAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
@@ -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, runClaimableDedupeClaimLoop } from "openclaw/plugin-sdk/persistent-dedupe";
 import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
 //#region extensions/slack/src/monitor/commands.ts
 /**
@@ -71,6 +72,151 @@ function buildSlackSlashCommandMatcher(name) {
 	return new RegExp(`^/?${escaped}$`);
 }
 //#endregion
+//#region extensions/slack/src/monitor/agent-view-state.ts
+const SLACK_AGENT_VIEW_STATE_NAMESPACE = "agent-view-workspaces";
+const SLACK_AGENT_VIEW_THREAD_STATE_NAMESPACE = "agent-view-threads";
+const SLACK_AGENT_VIEW_STATE_MAX_ENTRIES = 4096;
+const SLACK_AGENT_VIEW_THREAD_STATE_MAX_ENTRIES = 4096;
+const SLACK_MANAGED_THREAD_CACHE_MAX_ENTRIES = 4096;
+function createSlackAgentViewState(params) {
+	let enabled = false;
+	let loaded = false;
+	let persisted = false;
+	let workspaceStore;
+	let threadStore;
+	let warned = false;
+	const managedThreads = /* @__PURE__ */ new Map();
+	const warnOnce = (action, error) => {
+		if (warned) return;
+		warned = true;
+		params.warn(action, error);
+	};
+	const openWorkspaceStore = () => {
+		if (workspaceStore) return workspaceStore;
+		const runtime = getOptionalSlackRuntime();
+		if (!runtime) return;
+		try {
+			workspaceStore = runtime.state.openKeyedStore({
+				namespace: SLACK_AGENT_VIEW_STATE_NAMESPACE,
+				maxEntries: SLACK_AGENT_VIEW_STATE_MAX_ENTRIES
+			});
+			return workspaceStore;
+		} catch (error) {
+			warnOnce("open", error);
+			return;
+		}
+	};
+	const openThreadStore = () => {
+		if (threadStore) return threadStore;
+		const runtime = getOptionalSlackRuntime();
+		if (!runtime) return;
+		try {
+			threadStore = runtime.state.openKeyedStore({
+				namespace: SLACK_AGENT_VIEW_THREAD_STATE_NAMESPACE,
+				maxEntries: SLACK_AGENT_VIEW_THREAD_STATE_MAX_ENTRIES
+			});
+			return threadStore;
+		} catch (error) {
+			warnOnce("open", error);
+			return;
+		}
+	};
+	const workspaceStateKey = params.apiAppId ? JSON.stringify([
+		"workspace",
+		params.accountId,
+		params.teamId,
+		params.apiAppId
+	]) : void 0;
+	const record = async () => {
+		enabled = true;
+		loaded = true;
+		if (persisted || !workspaceStateKey) return;
+		const openedStore = openWorkspaceStore();
+		if (!openedStore) return;
+		try {
+			await openedStore.register(workspaceStateKey, {
+				experience: "agent",
+				observedAt: Date.now()
+			});
+			persisted = true;
+		} catch (error) {
+			warnOnce("persist", error);
+		}
+	};
+	const isEnabled = async () => {
+		if (enabled) return true;
+		if (loaded) return false;
+		if (!workspaceStateKey) {
+			loaded = true;
+			return false;
+		}
+		const openedStore = openWorkspaceStore();
+		if (!openedStore) return false;
+		try {
+			const stored = await openedStore.lookup(workspaceStateKey);
+			loaded = true;
+			enabled = stored?.experience === "agent";
+			persisted = enabled;
+			return enabled;
+		} catch (error) {
+			warnOnce("load", error);
+			return false;
+		}
+	};
+	const managedThreadKey = (channelId, threadTs) => JSON.stringify([channelId, threadTs]);
+	const managedThreadStateKey = (channelId, threadTs) => params.apiAppId ? JSON.stringify([
+		"thread",
+		params.accountId,
+		params.teamId,
+		params.apiAppId,
+		channelId,
+		threadTs
+	]) : void 0;
+	const rememberManagedThread = (key) => {
+		managedThreads.delete(key);
+		managedThreads.set(key, true);
+		if (managedThreads.size <= SLACK_MANAGED_THREAD_CACHE_MAX_ENTRIES) return;
+		const oldestKey = managedThreads.keys().next().value;
+		if (oldestKey !== void 0) managedThreads.delete(oldestKey);
+	};
+	const recordManagedThread = async (channelId, threadTs) => {
+		const key = managedThreadKey(channelId, threadTs);
+		rememberManagedThread(key);
+		const stateKey = managedThreadStateKey(channelId, threadTs);
+		const openedStore = stateKey ? openThreadStore() : void 0;
+		if (!openedStore || !stateKey) return;
+		try {
+			await openedStore.register(stateKey, {
+				experience: "managed-thread",
+				observedAt: Date.now()
+			});
+		} catch (error) {
+			warnOnce("persist", error);
+		}
+	};
+	const isManagedThread = async (channelId, threadTs) => {
+		const key = managedThreadKey(channelId, threadTs);
+		if (managedThreads.has(key)) return true;
+		const stateKey = managedThreadStateKey(channelId, threadTs);
+		const openedStore = stateKey ? openThreadStore() : void 0;
+		if (!openedStore || !stateKey) return false;
+		try {
+			const found = (await openedStore.lookup(stateKey))?.experience === "managed-thread";
+			if (found) rememberManagedThread(key);
+			return found;
+		} catch (error) {
+			warnOnce("load", error);
+			return false;
+		}
+	};
+	return {
+		isEnabled,
+		isManagedThread,
+		record,
+		recordManagedThread
+	};
+}
+//#endregion
 //#region extensions/slack/src/monitor/channel-type.ts
 function inferSlackChannelType(channelId) {
 	const trimmed = channelId?.trim();
@@ -110,6 +256,42 @@ function writeLruMapEntry(cache, cacheKey, entry, maxEntries) {
 	pruneMapToMaxSize(cache, maxEntries);
 }
 //#endregion
+//#region extensions/slack/src/monitor/suggested-prompts.ts
+const DEFAULT_SLACK_SUGGESTED_PROMPTS = [
+	{
+		title: "What can you do?",
+		message: "What can you help me with?"
+	},
+	{
+		title: "Summarize this channel",
+		message: "Summarize the recent activity in this channel."
+	},
+	{
+		title: "Draft a reply",
+		message: "Help me draft a reply."
+	}
+];
+async function updateSlackSuggestedPrompts(params) {
+	const prompts = params.prompts.map((prompt) => ({
+		title: prompt.title.trim(),
+		message: prompt.message.trim()
+	})).filter((prompt) => prompt.title && prompt.message).slice(0, 4);
+	if (prompts.length === 0) return false;
+	try {
+		await params.client.assistant.threads.setSuggestedPrompts({
+			token: params.botToken,
+			channel_id: params.channelId,
+			...params.threadTs ? { thread_ts: params.threadTs } : {},
+			...params.title?.trim() ? { title: params.title.trim() } : {},
+			prompts
+		});
+		return true;
+	} catch (error) {
+		logVerbose(`slack suggested prompts update failed for channel ${params.channelId}: ${formatSlackError(error)}`);
+		return false;
+	}
+}
+//#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;
@@ -150,16 +332,18 @@ 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
 	});
 	const assistantThreadContexts = /* @__PURE__ */ new Map();
 	let lastAssistantContextCleanupAt = Date.now();
+	const agentViewState = createSlackAgentViewState({
+		accountId: params.accountId,
+		teamId: params.teamId,
+		apiAppId: params.apiAppId,
+		warn: (action, error) => logger.warn({ error: formatSlackError(error) }, `Slack Agent View state failed to ${action}`)
+	});
 	const allowFrom = normalizeAllowList(params.allowFrom);
 	const groupDmChannels = normalizeAllowList(params.groupDmChannels);
 	const groupDmChannelsLower = new Set(normalizeAllowListLower(groupDmChannels).map((entry) => entry.replace(/^channel:/, "")));
@@ -187,14 +371,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();
@@ -342,26 +518,11 @@ function createSlackMonitorContext(params) {
 			logVerbose(`slack status update failed for channel ${p.channelId}: ${formatSlackError(err)}`);
 		}
 	};
-	const setSlackAssistantSuggestedPrompts = async (p) => {
-		const prompts = p.prompts.map((prompt) => ({
-			title: prompt.title.trim(),
-			message: prompt.message.trim()
-		})).filter((prompt) => prompt.title && prompt.message).slice(0, 4);
-		if (prompts.length === 0) return false;
-		try {
-			await params.app.client.assistant.threads.setSuggestedPrompts({
-				token: params.botToken,
-				channel_id: p.channelId,
-				thread_ts: p.threadTs,
-				...p.title?.trim() ? { title: p.title.trim() } : {},
-				prompts
-			});
-			return true;
-		} catch (err) {
-			logVerbose(`slack suggested prompts update failed for channel ${p.channelId}: ${formatSlackError(err)}`);
-			return false;
-		}
-	};
+	const setSlackSuggestedPrompts = (input) => updateSlackSuggestedPrompts({
+		...input,
+		botToken: params.botToken,
+		client: params.app.client
+	});
 	const isChannelAllowed = (p) => {
 		const channelType = normalizeSlackChannelType(p.channelType, p.channelId);
 		const isDirectMessage = channelType === "im";
@@ -472,16 +633,12 @@ function createSlackMonitorContext(params) {
 		replyToMode: params.replyToMode,
 		threadHistoryScope: params.threadHistoryScope,
 		threadInheritParent: params.threadInheritParent,
-		threadRequireExplicitMention: params.threadRequireExplicitMention,
 		slashCommand: params.slashCommand,
 		textLimit: params.textLimit,
 		ackReactionScope: params.ackReactionScope,
 		typingReaction: params.typingReaction,
 		mediaMaxBytes: params.mediaMaxBytes,
-		removeAckAfterReply: params.removeAckAfterReply,
 		logger,
-		markMessageSeen,
-		releaseSeenMessage,
 		shouldDropMismatchedSlackEvent,
 		resolveSlackSystemEventSessionKey,
 		isChannelAllowed,
@@ -492,7 +649,11 @@ function createSlackMonitorContext(params) {
 		setSlackThreadStatus,
 		getSlackAssistantThreadContext,
 		saveSlackAssistantThreadContext,
-		setSlackAssistantSuggestedPrompts
+		setSlackSuggestedPrompts,
+		recordSlackAgentView: agentViewState.record,
+		isSlackAgentView: agentViewState.isEnabled,
+		recordSlackManagedViewThread: agentViewState.recordManagedThread,
+		isSlackManagedViewThread: agentViewState.isManagedThread
 	};
 }
 //#endregion
@@ -535,8 +696,8 @@ function assertEnterpriseSlackPolicyConfig(params) {
 		predicate: isStableSlackAllowlistUserEntry
 	});
 	assertStableEntries({
-		values: config.dm?.allowFrom,
-		path: `channels.slack.accounts.${accountId}.dm.allowFrom`,
+		values: config.allowFrom,
+		path: `channels.slack.accounts.${accountId}.allowFrom`,
 		predicate: isStableSlackAllowlistUserEntry
 	});
 	assertStableEntries({
@@ -625,21 +786,21 @@ function resolveSlackIdentityHealth(params) {
 	};
 }
 //#endregion
+//#region extensions/slack/src/monitor/events/agent.ts
+function registerSlackAgentEvents(params) {
+	const { ctx, trackEvent } = params;
+	ctx.app.event("app_context_changed", async ({ body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			await ctx.recordSlackAgentView();
+		} catch (error) {
+			ctx.runtime.error?.(danger(`slack app_context_changed handler failed: ${formatErrorMessage(error)}`));
+		}
+	});
+}
+//#endregion
 //#region extensions/slack/src/monitor/events/assistant.ts
-const DEFAULT_ASSISTANT_PROMPTS = [
-	{
-		title: "What can you do?",
-		message: "What can you help me with?"
-	},
-	{
-		title: "Summarize this channel",
-		message: "Summarize the recent activity in this channel."
-	},
-	{
-		title: "Draft a reply",
-		message: "Help me draft a reply."
-	}
-];
 function normalizeAssistantThread(event, getPrevious) {
 	const thread = event.assistant_thread;
 	if (!thread) return null;
@@ -701,11 +862,11 @@ function registerSlackAssistantEvents(params) {
 				return;
 			}
 			ctx.saveSlackAssistantThreadContext(assistantThread);
-			await ctx.setSlackAssistantSuggestedPrompts({
+			await ctx.setSlackSuggestedPrompts({
 				channelId: assistantThread.assistantChannelId,
 				threadTs: assistantThread.threadTs,
 				title: "Try asking",
-				prompts: DEFAULT_ASSISTANT_PROMPTS
+				prompts: DEFAULT_SLACK_SUGGESTED_PROMPTS
 			});
 		} catch (err) {
 			ctx.runtime.error?.(danger(`slack assistant_thread_started handler failed: ${formatErrorMessage(err)}`));
@@ -945,7 +1106,16 @@ function registerSlackHomeEvents(params) {
 			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
 			trackEvent?.();
 			const payload = event;
-			if (!payload.user || payload.tab === "messages") return;
+			if (!payload.user) return;
+			if (payload.tab === "messages") {
+				if (!payload.channel) return;
+				if (await ctx.setSlackSuggestedPrompts({
+					channelId: payload.channel,
+					title: "Try asking",
+					prompts: DEFAULT_SLACK_SUGGESTED_PROMPTS
+				})) await ctx.recordSlackAgentView();
+				return;
+			}
 			await ctx.app.client.views.publish({
 				token: ctx.botToken,
 				user_id: payload.user,
@@ -1927,6 +2097,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 +2839,334 @@ 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 decodeSlackIngressPayload(payload, eventId) {
+	if (payload.kind === "relay") {
+		if (!asOptionalRecord(payload.message)) throw new SlackIngressPayloadError(`Slack relay ingress payload ${eventId} was invalid.`);
+		return {
+			version: payload.version,
+			body: payload
+		};
+	}
+	if (!asOptionalRecord(payload.body) || resolveSlackEventId(payload.body) !== eventId) throw new SlackIngressPayloadError(`Slack ingress payload ${eventId} was invalid.`);
+	return {
+		version: payload.version,
+		body: payload
+	};
+}
+function inspectSlackIngress(raw) {
+	if (raw.kind === "relay") {
+		const eventId = resolveSlackRelayIngressEventId({
+			deliveryId: raw.deliveryId,
+			message: raw.message
+		});
+		return {
+			eventId,
+			laneKey: resolveSlackIngressLane({ event: raw.message }, eventId)
+		};
+	}
+	const eventId = resolveSlackEventId(raw.body);
+	if (!eventId) throw new SlackIngressPayloadError("Slack Events API envelope missing event_id.");
+	return {
+		eventId,
+		laneKey: resolveSlackIngressLane(raw.body, eventId)
+	};
+}
+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 app;
+	let relayDispatch;
+	const monitor = createChannelIngressMonitor({
+		queue: options.queue ?? (() => getSlackRuntime().state.openChannelIngressQueue({ accountId: options.accountId })),
+		inspect: inspectSlackIngress,
+		payload: {
+			version: SLACK_INGRESS_PAYLOAD_VERSION,
+			serialize: (raw, { receivedAt }) => raw.kind === "relay" ? {
+				kind: "relay",
+				receivedAt,
+				message: raw.message
+			} : {
+				kind: "events-api",
+				receivedAt,
+				body: raw.body,
+				...raw.retryNum === void 0 ? {} : { retryNum: raw.retryNum },
+				...raw.retryReason === void 0 ? {} : { retryReason: raw.retryReason }
+			},
+			deserialize: (body, { claim }) => body.kind === "relay" ? {
+				kind: "relay",
+				deliveryId: claim.id.startsWith("relay:") ? claim.id.slice(6) : claim.id,
+				message: body.message
+			} : {
+				kind: "events-api",
+				body: body.body,
+				...body.retryNum === void 0 ? {} : { retryNum: body.retryNum },
+				...body.retryReason === void 0 ? {} : { retryReason: body.retryReason }
+			},
+			encode: ({ body }) => ({
+				version: SLACK_INGRESS_PAYLOAD_VERSION,
+				...body
+			}),
+			decode: (payload, { claim }) => decodeSlackIngressPayload(payload, claim.id),
+			createClaimError: (_kind, claim) => new SlackIngressPayloadError(`Slack ingress payload ${claim.id} was invalid.`)
+		},
+		onDurableAdmission: async (raw) => {
+			if (raw.kind === "events-api") await raw.afterDurableAdmission?.();
+		},
+		deliver: async (raw, lifecycle) => {
+			if (raw.kind === "relay") {
+				if (!relayDispatch) throw new Error("Slack relay ingress dispatcher is not attached.");
+				await relayDispatch(raw.message, lifecycle);
+				return;
+			}
+			if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
+			await app.processEvent({
+				body: raw.body,
+				ack: async () => {},
+				...raw.retryNum === void 0 ? {} : { retryNum: raw.retryNum },
+				...raw.retryReason === void 0 ? {} : { retryReason: raw.retryReason },
+				customProperties: { [SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY]: lifecycle }
+			});
+		},
+		pollIntervalMs: options.pollIntervalMs ?? SLACK_INGRESS_POLL_INTERVAL_MS,
+		retention: {
+			pruneIntervalMs: SLACK_INGRESS_PRUNE_INTERVAL_MS,
+			completedTtlMs: SLACK_INGRESS_COMPLETED_TTL_MS,
+			completedMaxEntries: SLACK_INGRESS_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: SLACK_INGRESS_FAILED_TTL_MS,
+			failedMaxEntries: SLACK_INGRESS_FAILED_MAX_ENTRIES
+		},
+		appendRetryDelaysMs: [0],
+		drain: {
+			resolveNonRetryableFailure: resolveSlackIngressNonRetryableFailure,
+			deriveLaneKey: (record) => record.payload.kind === "relay" ? resolveSlackIngressLane({ event: record.payload.message }, record.id) : resolveSlackIngressLane(record.payload.body, record.id),
+			...options.adoptionStallTimeoutMs === void 0 ? {} : { adoptionStallTimeoutMs: options.adoptionStallTimeoutMs },
+			...options.onLog ? { onLog: options.onLog } : {}
+		},
+		...options.abortSignal ? { abortSignal: options.abortSignal } : {},
+		onError: (error) => options.onLog?.(`slack ingress drain failed: ${formatErrorMessage(error)}`)
+	});
+	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;
+		}
+		await monitor.admit({
+			kind: "events-api",
+			body: event.body,
+			...event.retryNum === void 0 ? {} : { retryNum: event.retryNum },
+			...event.retryReason === void 0 ? {} : { retryReason: event.retryReason },
+			afterDurableAdmission: () => event.ack()
+		});
+	};
+	const acceptRelayEvent = async (event) => {
+		await monitor.admit({
+			kind: "relay",
+			deliveryId: event.deliveryId,
+			message: event.message
+		});
+	};
+	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: monitor.start,
+		stop: monitor.stop,
+		waitForIdle: monitor.waitForIdle
+	};
+}
+//#endregion
 //#region extensions/slack/src/monitor/events/message-subtype-handlers.ts
 const SUBTYPE_HANDLER_REGISTRY = {
 	message_changed: {
@@ -2776,6 +3294,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 +3320,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 +3350,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 +3364,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 +3391,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)}`));
 		}
 	});
@@ -3026,6 +3545,10 @@ function registerSlackMonitorEvents(params) {
 		slashCommandName: params.appHomeSlashCommandName,
 		trackEvent: params.trackEvent
 	});
+	registerSlackAgentEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
 	registerSlackInteractionEvents({
 		ctx: params.ctx,
 		trackEvent: params.trackEvent
@@ -3036,41 +3559,47 @@ 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 {}
-		}
-	}
-});
-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 })));
+//#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) {
+	const claim = await runClaimableDedupeClaimLoop(() => params.guard.claim({ keys: [params.key] }), (_error, rejectionCount) => rejectionCount <= 1);
+	return claim.kind === "claimed" ? {
+		kind: "claimed",
+		handle: claim.handle
+	} : { kind: "duplicate" };
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/debounce-key.ts
@@ -3198,7 +3727,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-5rRYZuX5.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -3211,7 +3740,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 +3753,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 +3788,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 +3833,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 (!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 (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 +3903,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 +4143,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";
@@ -3910,27 +4305,28 @@ function createSlackBoltApp(params) {
 	const socketModeReceiverOptions = {
 		appToken: params.appToken ?? "",
 		autoReconnectEnabled: true,
-		clientPingTimeout: params.socketMode?.clientPingTimeout ?? OPENCLAW_SLACK_CLIENT_PING_TIMEOUT_MS,
+		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;
 	let receiver;
 	if (params.slackMode === "socket") {
 		receiver = new params.interop.SocketModeReceiver(socketModeReceiverOptions);
 		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 +4574,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-lfeIsXTX.js"));
 const loadSlackPluginCommandsRuntime = createLazyRuntimeModule(() => import("./slash-plugin-commands.runtime-Dosfcx3X.js"));
 const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 function resolveSlackCommandMenuModelContext(params) {
@@ -4571,8 +4967,12 @@ async function registerSlackMonitorSlashCommands(params) {
 					agentId: menuRoute.agentId,
 					sessionKey: menuRoute.sessionKey
 				}) : {};
-				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadModelCatalog({
+				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadPreparedModelCatalog({
 					config: cfg,
+					...menuRoute ? {
+						agentId: menuRoute.agentId,
+						agentDir: resolveAgentDir(cfg, menuRoute.agentId)
+					} : {},
 					readOnly: true
 				}) : void 0;
 				const menu = resolveCommandArgMenu({
@@ -4630,7 +5030,7 @@ async function registerSlackMonitorSlashCommands(params) {
 				sessionPrefix: slashCommand.sessionPrefix,
 				userId: command.user_id,
 				targetSessionKey: route.sessionKey,
-				lowercaseSessionKey: true
+				sessionKeyCase: "lowercase"
 			});
 			const slashReplyTarget = !slashCommand.ephemeral && isRoomish ? `channel:${command.channel_id}` : `user:${command.user_id}`;
 			const ctxPayload = finalizeInboundContext({
@@ -4709,12 +5109,17 @@ async function registerSlackMonitorSlashCommands(params) {
 				});
 			};
 			const pendingSlashReplies = [];
+			const shouldDeliverBlockImmediately = commandDefinition?.key === "login";
 			const { counts } = await dispatchReplyWithDispatcher({
 				ctx: ctxPayload,
 				cfg,
 				dispatcherOptions: {
 					...replyPipeline,
-					deliver: async (payload) => {
+					deliver: async (payload, info) => {
+						if (info.kind === "block" && shouldDeliverBlockImmediately) {
+							await deliverSlashPayloads([payload]);
+							return;
+						}
 						pendingSlashReplies.push(payload);
 					},
 					onError: (err, info) => {
@@ -4918,7 +5323,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-DMmgtvg4.js"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-Df9EaiTF.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveStableSlackUserIdEntry(raw) {
@@ -5011,16 +5416,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;
@@ -5054,30 +5469,33 @@ async function monitorSlackProvider(opts = {}) {
 		log: (message) => runtime.log?.(warn(message))
 	});
 	const resolveToken = account.userToken || botToken;
-	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const useAccessGroups = true;
 	const reactionMode = slackCfg.reactionNotifications ?? "own";
 	const reactionAllowlist = slackCfg.reactionAllowlist ?? [];
 	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 });
 	const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
 	const typingReaction = slackCfg.typingReaction?.trim() ?? "";
 	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 } : {}
+		wrapReceiver: durableIngress.wrapReceiver
 	});
 	const gracefulStop = async () => {
 		await gracefulStopSlackApp(app);
@@ -5112,12 +5530,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 +5551,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 +5562,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,13 +5597,11 @@ async function monitorSlackProvider(opts = {}) {
 		replyToMode,
 		threadHistoryScope,
 		threadInheritParent,
-		threadRequireExplicitMention,
 		slashCommand,
 		textLimit,
 		ackReactionScope,
 		typingReaction,
-		mediaMaxBytes,
-		removeAckAfterReply
+		mediaMaxBytes
 	});
 	const trackEvent = opts.setStatus ? () => {
 		opts.setStatus({
@@ -5232,6 +5654,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 +5820,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 +5848,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 };