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

package/dist/{provider-B-HVL5ZE.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-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 { 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-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 { 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 { 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";
@@ -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,7 +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 { createChannelReplayGuard, runClaimableDedupeClaimLoop } from "openclaw/plugin-sdk/persistent-dedupe";
 import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
 //#region extensions/slack/src/monitor/commands.ts
 /**
@@ -72,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();
@@ -111,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;
@@ -157,6 +338,12 @@ function createSlackMonitorContext(params) {
 	});
 	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:/, "")));
@@ -331,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";
@@ -466,7 +638,6 @@ function createSlackMonitorContext(params) {
 		ackReactionScope: params.ackReactionScope,
 		typingReaction: params.typingReaction,
 		mediaMaxBytes: params.mediaMaxBytes,
-		removeAckAfterReply: params.removeAckAfterReply,
 		logger,
 		shouldDropMismatchedSlackEvent,
 		resolveSlackSystemEventSessionKey,
@@ -478,7 +649,11 @@ function createSlackMonitorContext(params) {
 		setSlackThreadStatus,
 		getSlackAssistantThreadContext,
 		saveSlackAssistantThreadContext,
-		setSlackAssistantSuggestedPrompts
+		setSlackSuggestedPrompts,
+		recordSlackAgentView: agentViewState.record,
+		isSlackAgentView: agentViewState.isEnabled,
+		recordSlackManagedViewThread: agentViewState.recordManagedThread,
+		isSlackManagedViewThread: agentViewState.isManagedThread
 	};
 }
 //#endregion
@@ -521,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({
@@ -611,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;
@@ -687,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)}`));
@@ -931,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,
@@ -2812,13 +2996,37 @@ function resolveSlackIngressLane(body, 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.`);
+function decodeSlackIngressPayload(payload, eventId) {
 	if (payload.kind === "relay") {
 		if (!asOptionalRecord(payload.message)) throw new SlackIngressPayloadError(`Slack relay ingress payload ${eventId} was invalid.`);
-		return;
+		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) => [
@@ -2844,115 +3052,97 @@ function resolveSlackIngressTurnLifecycle(context) {
 	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
+	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 }
 			},
-			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 }
-				});
+			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;
 			}
-		});
-		return drain;
-	};
-	const pruneIfDue = async () => {
-		const now = Date.now();
-		if (now - lastPrunedAt < SLACK_INGRESS_PRUNE_INTERVAL_MS) return;
-		await getQueue().prune({
+			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,
-			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();
-	};
+			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;
 		}
-		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,
+		await monitor.admit({
 			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();
+			...event.retryReason === void 0 ? {} : { retryReason: event.retryReason },
+			afterDurableAdmission: () => event.ack()
+		});
 	};
 	const acceptRelayEvent = async (event) => {
-		const receivedAt = Date.now();
-		await getQueue().enqueue(resolveSlackRelayIngressEventId(event), {
-			version: SLACK_INGRESS_PAYLOAD_VERSION,
-			receivedAt,
+		await monitor.admit({
 			kind: "relay",
+			deliveryId: event.deliveryId,
 			message: event.message
-		}, { receivedAt });
-		requestDrain();
+		});
 	};
 	return {
 		wrapReceiver: (receiver) => {
@@ -2971,31 +3161,9 @@ function createSlackDurableIngress(options) {
 		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();
-		}
+		start: monitor.start,
+		stop: monitor.stop,
+		waitForIdle: monitor.waitForIdle
 	};
 }
 //#endregion
@@ -3377,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
@@ -3423,22 +3595,11 @@ function createSlackMessageDispatchReplayGuard(params = {}) {
 }
 /** 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" };
-		}
-	}
+	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
@@ -3566,7 +3727,7 @@ function createSlackThreadTsResolver(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-CTvokbty.js"));
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-5rRYZuX5.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -4144,13 +4305,11 @@ 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 },
 		...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);
@@ -4415,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-BT-mMm-f.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) {
@@ -4808,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({
@@ -4867,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({
@@ -4946,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) => {
@@ -5155,7 +5323,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-Ea_P9VcO.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) {
@@ -5301,7 +5469,7 @@ 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";
@@ -5313,7 +5481,6 @@ async function monitorSlackProvider(opts = {}) {
 	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,
@@ -5328,7 +5495,6 @@ async function monitorSlackProvider(opts = {}) {
 		signingSecret: slackMode === "http" ? signingSecret ?? void 0 : void 0,
 		slackWebhookPath,
 		clientOptions,
-		...slackCfg.socketMode ? { socketMode: slackCfg.socketMode } : {},
 		wrapReceiver: durableIngress.wrapReceiver
 	});
 	const gracefulStop = async () => {
@@ -5435,8 +5601,7 @@ async function monitorSlackProvider(opts = {}) {
 		textLimit,
 		ackReactionScope,
 		typingReaction,
-		mediaMaxBytes,
-		removeAckAfterReply
+		mediaMaxBytes
 	});
 	const trackEvent = opts.setStatus ? () => {
 		opts.setStatus({