@openclaw/slack 2026.9.8 → 2026.10.1-beta.1

package/dist/.setup/{monitor-BPVfkumU.mjs → monitor-BuYBDmm7.mjs}

@@ -1,17 +1,17 @@
-import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-CIbMfuf8.mjs";
-import { a as mergeSlackAccountConfig, c as resolveSlackAccountAllowFrom, f as resolveSlackReplyToMode, h as resolveSlackBotToken, l as resolveSlackAccountDmPolicy, m as resolveSlackAppToken, o as resolveDefaultSlackAccountId, p as formatSlackBotTokenIdentityWarning, s as resolveSlackAccount } from "./accounts-D_N9IqNA.mjs";
+import { a as mergeSlackAccountConfig, c as resolveSlackAccountAllowFrom, f as resolveSlackReplyToMode, h as resolveSlackBotToken, l as resolveSlackAccountDmPolicy, m as resolveSlackAppToken, o as resolveDefaultSlackAccountId, p as formatSlackBotTokenIdentityWarning, s as resolveSlackAccount } from "./accounts-CDgkV7Cm.mjs";
 import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
-import { Ft as registerSlackInstallationState, G as isSlackQuestionActionId, Lt as isSlackExecApprovalAuthorizedSender, U as isSlackApprovalActionId, W as isSlackCallbackActionId, Y as resolveSlackQuestionAction, c as qualifySlackRoutePeerId, d as resolveSlackConversationBindingRoute, dt as decodeSlackApprovalAction, j as truncateSlackText, jt as isSlackPluginApprovalAuthorizedSender, k as SLACK_TEXT_LIMIT, l as resolveSlackEnterpriseMainDmSessionKey, lt as escapeSlackMrkdwn, n as setSlackSessionStatus, q as decodeSlackQuestionAction, r as buildSlackChannelIdCandidates, s as qualifySlackConversationId, t as renameSlackSession, u as normalizeSlackRouteBindingConfig, yt as isSlackAnyNativeApprovalClientEnabled } from "./session-status-DscajIsd.mjs";
-import { A as resolveSlackUserAllowListForTeam, C as resolveSlackMonitorDispatchers, D as normalizeSlackAllowOwnerEntry, E as allowListMatches, O as normalizeSlackSlug, S as resolveSlackLookupClientOptions, a as slackIngressIdentity, c as collectSlackCursorPages, f as createSlackStartupAuthClient, g as getSlackListenerWriteClient, i as createSlackIngressSubject, k as resolveSlackAllowListMatch, m as createSlackWebClient, o as formatSlackError, v as readLruMapEntry, w as resolveSlackWebClientOptions, y as writeLruMapEntry } from "./probe-B2Y9qc_z.mjs";
+import { B as isSlackApprovalActionId, H as isSlackQuestionActionId, K as resolveSlackQuestionAction, Mt as registerSlackInstallationState, Ot as isSlackPluginApprovalAuthorizedSender, Pt as isSlackExecApprovalAuthorizedSender, V as isSlackCallbackActionId, W as decodeSlackQuestionAction, c as qualifySlackRoutePeerId, ct as decodeSlackApprovalAction, d as resolveSlackConversationBindingRoute, gt as isSlackAnyNativeApprovalClientEnabled, j as truncateSlackText, k as SLACK_TEXT_LIMIT, l as resolveSlackEnterpriseMainDmSessionKey, n as setSlackSessionStatus, ot as escapeSlackMrkdwn, r as buildSlackChannelIdCandidates, s as qualifySlackConversationId, t as renameSlackSession, u as normalizeSlackRouteBindingConfig } from "./session-status-D46GHwOV.mjs";
+import { A as resolveSlackUserAllowListForTeam, C as resolveSlackMonitorDispatchers, D as normalizeSlackAllowOwnerEntry, E as allowListMatches, O as normalizeSlackSlug, S as resolveSlackLookupClientOptions, a as slackIngressIdentity, c as collectSlackCursorPages, f as createSlackStartupAuthClient, g as getSlackListenerWriteClient, i as createSlackIngressSubject, k as resolveSlackAllowListMatch, m as createSlackWebClient, o as formatSlackError, v as readLruMapEntry, w as resolveSlackWebClientOptions, y as writeLruMapEntry } from "./probe-BVlJ3dp0.mjs";
 import { n as getSlackRuntime, t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.mjs";
 import { t as DEFAULT_SLACK_SUGGESTED_PROMPTS } from "./channel-meta-C443t-lI.mjs";
-import { S as hasSlackMessageTableBlock, f as readSlackMessages, v as isGovSlackClient, y as saveRemoteMedia } from "./actions-Df0CzcDl.mjs";
-import { d as requireSlackPostMessageTimestamp, f as buildSlackMessageIdentityPayload, r as setSlackDefaultSendIdentity } from "./send-BOVLQi3n.mjs";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-D-jfM174.mjs";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-XXBn8UU_.mjs";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-DW0ngD03.mjs";
-import { n as runSlackApprovalMessageUpdate, t as hasSlackApprovalControl } from "./approval-message-updates-BadvtA7R.mjs";
+import { S as hasSlackMessageTableBlock, f as readSlackMessages, v as isGovSlackClient, y as saveRemoteMedia } from "./actions-DDoAJnrH.mjs";
+import { d as requireSlackPostMessageTimestamp, f as buildSlackMessageIdentityPayload, r as setSlackDefaultSendIdentity } from "./send-CgPI3Zj8.mjs";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-KKTqEiDv.mjs";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-HR0TgArR.mjs";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-BNYBhF0q.mjs";
+import { n as runSlackApprovalMessageUpdate, t as hasSlackApprovalControl } from "./approval-message-updates-EgKGmFXx.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asNonArrayRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -359,8 +359,8 @@ function isStableSlackToolsBySenderEntry(value) {
 	if (typeof value !== "string") return false;
 	const normalized = value.trim();
 	if (normalized === "*") return true;
-	const prefixed = /^(?:id:|channel:slack:)([UW][A-Z0-9]{8,})$/.exec(normalized);
-	return Boolean(prefixed?.[1]) || SLACK_USER_ID_RE.test(normalized);
+	const senderId = /^(?:id:|channel:slack:)(.+)$/.exec(normalized)?.[1];
+	return senderId !== void 0 && SLACK_USER_ID_RE.test(senderId);
 }
 function assertStableEntries(params) {
 	const invalid = params.values?.find((value) => !params.predicate(value));
@@ -732,7 +732,7 @@ function isSlackSocketSelfInflictedLoggerWarning(args) {
 function formatSlackSdkLogArgs(args) {
 	return args.map((arg) => formatSlackError(arg, "")).filter(Boolean).join(" ");
 }
-function createSlackSocketModeLogger(sink = console) {
+function createSlackSocketModeLogger() {
 	let level = "info";
 	let name = "socket-mode";
 	const prefix = () => `socket-mode:${name}`;
@@ -747,11 +747,11 @@ function createSlackSocketModeLogger(sink = console) {
 		warn: (...args) => {
 			if (isSlackSocketHeartbeatTimeoutWarning(args) || isSlackSocketSelfInflictedLoggerWarning(args)) return;
 			remember(args);
-			sink.warn(prefix(), ...args);
+			console.warn(prefix(), ...args);
 		},
 		error: (...args) => {
 			remember(args);
-			sink.error(prefix(), ...args);
+			console.error(prefix(), ...args);
 		},
 		setLevel: (nextLevel) => {
 			level = nextLevel;
@@ -1689,15 +1689,12 @@ function createSlackThreadTsResolver(params) {
 	const getCached = (key, now) => {
 		const entry = cache.get(key);
 		if (!entry) return;
-		if (entry.expiresAt === 0) {
-			cache.delete(key);
-			cache.set(key, entry);
-			return entry.threadTs;
-		}
-		const normalizedNow = asDateTimestampMs(now);
-		if (normalizedNow === void 0 || asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= normalizedNow) {
-			cache.delete(key);
-			return;
+		if (entry.expiresAt !== 0) {
+			const normalizedNow = asDateTimestampMs(now);
+			if (normalizedNow === void 0 || asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= normalizedNow) {
+				cache.delete(key);
+				return;
+			}
 		}
 		cache.delete(key);
 		cache.set(key, entry);
@@ -2522,15 +2519,15 @@ function resolveSlackInitialAgentRoute(params) {
 		accountId: params.account.accountId,
 		teamId: params.eventScope?.teamId || params.ctx.teamId || void 0,
 		peer: {
-			kind: params.isDirectMessage ? "direct" : params.isRoom ? "channel" : "group",
+			kind: params.chatType,
 			id: qualifySlackRoutePeerId({
-				id: params.isDirectMessage ? params.message.user ?? "unknown" : params.message.channel,
-				kind: params.isDirectMessage ? "user" : "channel",
+				id: params.chatType === "direct" ? params.message.user ?? "unknown" : params.message.channel,
+				kind: params.chatType === "direct" ? "user" : "channel",
 				eventScope: params.eventScope
 			})
 		}
 	});
-	if (!params.eventScope || !params.isDirectMessage || route.dmScope !== "main") return route;
+	if (!params.eventScope || params.chatType !== "direct" || route.dmScope !== "main") return route;
 	const sessionKey = resolveSlackEnterpriseMainDmSessionKey({
 		baseSessionKey: route.sessionKey,
 		accountId: params.account.accountId,
@@ -2543,8 +2540,9 @@ function resolveSlackInitialAgentRoute(params) {
 	};
 }
 function resolveSlackRoutingContext(params) {
-	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, agentViewThreadTs, eventScope } = params;
-	const chatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
+	const { ctx, account, message, chatType, channelConfig, seedTopLevelRoomThread, assistantThreadTs, agentViewThreadTs, eventScope } = params;
+	const isDirectMessage = chatType === "direct";
+	const isRoom = chatType === "channel";
 	const replyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, chatType);
 	const threadContext = resolveSlackThreadContext({
 		message,
@@ -2553,9 +2551,8 @@ function resolveSlackRoutingContext(params) {
 	});
 	const threadTs = threadContext.incomingThreadTs;
 	const isThreadReply = threadContext.isThreadReply;
-	const autoThreadId = !isThreadReply && replyToMode === "all" && threadContext.messageTs ? threadContext.messageTs : void 0;
 	const seedCandidateThreadId = threadContext.incomingThreadTs ?? threadContext.messageTs;
-	const routedThreadId = (isDirectMessage ? assistantThreadTs ?? agentViewThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
+	const routedThreadId = isDirectMessage ? assistantThreadTs ?? agentViewThreadTs : (isThreadReply && threadTs ? threadTs : void 0) ?? (!isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0);
 	const baseConversationId = qualifySlackConversationId(isDirectMessage ? `user:${message.user ?? "unknown"}` : message.channel, eventScope);
 	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
 	const bindingRoute = resolveSlackConversationBindingRoute({
@@ -2565,8 +2562,7 @@ function resolveSlackRoutingContext(params) {
 			ctx,
 			account,
 			message,
-			isDirectMessage,
-			isRoom,
+			chatType,
 			eventScope
 		}),
 		accountId: account.accountId,
@@ -2613,8 +2609,8 @@ async function resolveSlackSessionEventRoutingContext(params) {
 		accountId: params.account.accountId,
 		kind: routing.chatType,
 		peerId: qualifySlackRoutePeerId({
-			id: params.isDirectMessage ? message.user ?? "unknown" : message.channel,
-			kind: params.isDirectMessage ? "user" : "channel",
+			id: params.chatType === "direct" ? message.user ?? "unknown" : message.channel,
+			kind: params.chatType === "direct" ? "user" : "channel",
 			eventScope
 		})
 	};
@@ -2653,8 +2649,8 @@ async function resolveSlackSessionEventRoutingContext(params) {
 		} : void 0;
 	};
 	let owner = readOwner();
-	if (owner?.source === "live" && params.isDirectMessage) allowDirectParent = getConversationSession(address)?.sessionKey === owner.route.sessionKey;
-	if (!owner && params.isDirectMessage && threadTs) {
+	if (owner?.source === "live" && params.chatType === "direct") allowDirectParent = getConversationSession(address)?.sessionKey === owner.route.sessionKey;
+	if (!owner && params.chatType === "direct" && threadTs) {
 		const assistantContext = ctx.getSlackAssistantThreadContext(message.channel, threadTs, eventScope);
 		const managedThread = !eventScope && (await ctx.isSlackManagedViewThread(message.channel, threadTs) || await ctx.isSlackAgentView());
 		allowDirectParent = !(assistantContext ?? (managedThread ? void 0 : await readSlackAssistantThreadContext({
@@ -2854,9 +2850,6 @@ function createSlackExternalArgMenuStore() {
 //#region extensions/slack/src/monitor/response-url-budget.ts
 const SLACK_RESPONSE_URL_MAX_CALLS = 5;
 var SlackResponseAlreadyReportedError = class extends Error {};
-function isSlackResponseAlreadyReportedError(error) {
-	return error instanceof SlackResponseAlreadyReportedError;
-}
 /** Count every response_url attempt, including requests Slack rejects. */
 function createSlackResponseUrlBudget(respond, maxCalls = SLACK_RESPONSE_URL_MAX_CALLS) {
 	let remaining = maxCalls;
@@ -2898,7 +2891,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("openclaw/plugin-sdk/command-auth-native"));
-const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime--AEzLVBF.mjs"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-gBj_uaLM.mjs"));
 const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
 function resolveSlackCommandMenuModelContext(params) {
 	if (!params.sessionKey.trim()) return {};
@@ -3016,64 +3009,47 @@ function buildSlackCommandArgMenuBlocks(params) {
 	const canUseStaticSelect = encodedChoices.every((choice) => choice.value.length <= SLACK_COMMAND_ARG_SELECT_OPTION_VALUE_MAX);
 	const canUseOverflow = canUseStaticSelect && encodedChoices.length >= SLACK_COMMAND_ARG_OVERFLOW_MIN && encodedChoices.length <= SLACK_COMMAND_ARG_OVERFLOW_MAX;
 	const canUseExternalSelect = params.supportsExternalSelect && canUseStaticSelect && encodedChoices.length > SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX;
-	const rows = canUseOverflow ? [{
-		type: "actions",
-		elements: [{
-			type: "overflow",
-			action_id: SLACK_COMMAND_ARG_ACTION_ID,
-			confirm: buildSlackArgMenuConfirm({
-				command: params.command,
-				arg: params.arg
-			}),
-			options: buildSlackArgMenuOptions(encodedChoices)
-		}]
-	}] : canUseExternalSelect ? [{
-		type: "actions",
+	const confirm = buildSlackArgMenuConfirm({
+		command: params.command,
+		arg: params.arg
+	});
+	const selectElement = {
+		action_id: SLACK_COMMAND_ARG_ACTION_ID,
+		confirm
+	};
+	const rows = canUseOverflow ? [{ elements: [{
+		...selectElement,
+		type: "overflow",
+		options: buildSlackArgMenuOptions(encodedChoices)
+	}] }] : canUseExternalSelect ? [{
 		block_id: `${SLACK_EXTERNAL_ARG_MENU_PREFIX}${params.createExternalMenuToken(encodedChoices)}`,
 		elements: [{
+			...selectElement,
 			type: "external_select",
-			action_id: SLACK_COMMAND_ARG_ACTION_ID,
-			confirm: buildSlackArgMenuConfirm({
-				command: params.command,
-				arg: params.arg
-			}),
 			min_query_length: 0,
 			placeholder: {
 				type: "plain_text",
 				text: `Search ${params.arg}`
 			}
 		}]
-	}] : encodedChoices.length <= SLACK_COMMAND_ARG_BUTTON_ROW_SIZE || !canUseStaticSelect ? chunkItems(encodedChoices.filter((choice) => choice.value.length <= SLACK_COMMAND_ARG_BUTTON_VALUE_MAX), SLACK_COMMAND_ARG_BUTTON_ROW_SIZE).map((choices, rowIndex) => ({
-		type: "actions",
-		elements: choices.map((choice, colIndex) => ({
-			type: "button",
-			action_id: `${SLACK_COMMAND_ARG_ACTION_ID}_${rowIndex}_${colIndex}`,
-			text: {
-				type: "plain_text",
-				text: truncateSlackText(choice.label, SLACK_COMMAND_ARG_BUTTON_TEXT_MAX)
-			},
-			value: choice.value,
-			confirm: buildSlackArgMenuConfirm({
-				command: params.command,
-				arg: params.arg
-			})
-		}))
-	})) : chunkItems(encodedChoices, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX).map((choices, index) => ({
-		type: "actions",
-		elements: [{
-			type: "static_select",
-			action_id: SLACK_COMMAND_ARG_ACTION_ID,
-			confirm: buildSlackArgMenuConfirm({
-				command: params.command,
-				arg: params.arg
-			}),
-			placeholder: {
-				type: "plain_text",
-				text: index === 0 ? `Choose ${params.arg}` : `Choose ${params.arg} (${index + 1})`
-			},
-			options: buildSlackArgMenuOptions(choices)
-		}]
-	}));
+	}] : encodedChoices.length <= SLACK_COMMAND_ARG_BUTTON_ROW_SIZE || !canUseStaticSelect ? chunkItems(encodedChoices.filter((choice) => choice.value.length <= SLACK_COMMAND_ARG_BUTTON_VALUE_MAX), SLACK_COMMAND_ARG_BUTTON_ROW_SIZE).map((choices, rowIndex) => ({ elements: choices.map((choice, colIndex) => ({
+		type: "button",
+		action_id: `${SLACK_COMMAND_ARG_ACTION_ID}_${rowIndex}_${colIndex}`,
+		text: {
+			type: "plain_text",
+			text: truncateSlackText(choice.label, SLACK_COMMAND_ARG_BUTTON_TEXT_MAX)
+		},
+		value: choice.value,
+		confirm
+	})) })) : chunkItems(encodedChoices, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX).map((choices, index) => ({ elements: [{
+		...selectElement,
+		type: "static_select",
+		placeholder: {
+			type: "plain_text",
+			text: index === 0 ? `Choose ${params.arg}` : `Choose ${params.arg} (${index + 1})`
+		},
+		options: buildSlackArgMenuOptions(choices)
+	}] }));
 	const headerText = truncateSlackText(`/${params.command}: choose ${params.arg}`, SLACK_HEADER_TEXT_MAX);
 	const sectionText = truncateSlackText(params.title, 3e3);
 	const contextText = truncateSlackText(`Select one option to continue /${params.command} (${params.arg})`, 3e3);
@@ -3100,7 +3076,7 @@ function buildSlackCommandArgMenuBlocks(params) {
 				text: contextText
 			}]
 		},
-		...visibleRows
+		...visibleRows.map((row) => Object.assign({ type: "actions" }, row))
 	];
 }
 const NON_PLUGIN_COMMAND_DISPATCH = Object.freeze({ kind: "non-plugin" });
@@ -3185,35 +3161,16 @@ function createSlackCommandHandler(params) {
 					log: logVerbose
 				})) return false;
 			}
-			if (isRoom) {
-				channelConfig = resolveSlackChannelConfig({
-					teamId: eventScope?.teamId ?? ctx.teamId,
-					allowUnscoped: ctx.installationIdentity?.kind !== "enterprise",
-					channelId: command.channel_id,
-					channelName: channelInfo?.name,
-					channels: ctx.channelsConfig,
-					channelKeys: ctx.channelsConfigKeys,
-					defaultRequireMention: ctx.defaultRequireMention,
-					allowNameMatching: ctx.allowNameMatching
-				});
-				if (ctx.useAccessGroups) {
-					const channelAllowlistConfigured = (ctx.channelsConfigKeys?.length ?? 0) > 0;
-					const channelAllowed = channelConfig?.allowed !== false;
-					if (!isSlackChannelAllowedByPolicy({
-						groupPolicy: ctx.groupPolicy,
-						channelAllowlistConfigured,
-						channelAllowed
-					})) {
-						await respondEphemeral("This channel is not allowed.");
-						return false;
-					}
-					const hasExplicitConfig = Boolean(channelConfig?.matchSource);
-					if (!channelAllowed && (ctx.groupPolicy !== "open" || hasExplicitConfig)) {
-						await respondEphemeral("This channel is not allowed.");
-						return false;
-					}
-				}
-			}
+			if (isRoom) channelConfig = resolveSlackChannelConfig({
+				teamId: eventScope?.teamId ?? ctx.teamId,
+				allowUnscoped: ctx.installationIdentity?.kind !== "enterprise",
+				channelId: command.channel_id,
+				channelName: channelInfo?.name,
+				channels: ctx.channelsConfig,
+				channelKeys: ctx.channelsConfigKeys,
+				defaultRequireMention: ctx.defaultRequireMention,
+				allowNameMatching: ctx.allowNameMatching
+			});
 			const senderName = (await ctx.resolveUserName(command.user_id, eventScope))?.name ?? command.user_name ?? command.user_id;
 			const slashIngress = await resolveSlackCommandIngress({
 				ctx,
@@ -3268,10 +3225,7 @@ function createSlackCommandHandler(params) {
 							ts: p.eventTs,
 							thread_ts: p.threadTs
 						},
-						isDirectMessage,
-						isGroupDm,
-						isRoom,
-						isRoomish,
+						chatType,
 						channelConfig,
 						eventScope
 					});
@@ -3507,7 +3461,7 @@ function createSlackCommandHandler(params) {
 			return true;
 		} catch (err) {
 			runtime.error?.(danger(`slack slash handler failed: ${formatErrorMessage(err)}`));
-			if (!isSlackResponseAlreadyReportedError(err) && responseBudget.remaining() !== 0) await respondEphemeral("Sorry, something went wrong handling that command.");
+			if (!(err instanceof SlackResponseAlreadyReportedError) && responseBudget.remaining() !== 0) await respondEphemeral("Sorry, something went wrong handling that command.");
 		}
 		return false;
 	};
@@ -3568,7 +3522,6 @@ async function registerSlackMonitorSlashCommands(params) {
 	let nativeCommands = [];
 	let slashCommandsRuntime = null;
 	let pluginCommandRuntimeModule = null;
-	let pluginCommandRuntime = null;
 	if (registration.mode === "disabled" && resolveNativeCommandsEnabled({
 		providerId: "slack",
 		providerSetting: account.config.commands?.native,
@@ -3585,7 +3538,7 @@ async function registerSlackMonitorSlashCommands(params) {
 			provider: "slack"
 		});
 		pluginCommandRuntimeModule = await loadPluginCommandRuntime();
-		pluginCommandRuntime = pluginCommandRuntimeModule.createPluginCommandRuntime();
+		const pluginCommandRuntime = pluginCommandRuntimeModule.createPluginCommandRuntime();
 		nativeCommands = mergeNativeCommandSpecs({
 			primary: nativeCommands,
 			secondary: pluginCommandRuntime.listNativeCandidates("slack")
@@ -3594,7 +3547,7 @@ async function registerSlackMonitorSlashCommands(params) {
 	}
 	if (registration.mode === "single") registerCommand(buildSlackSlashCommandMatcher(registration.name));
 	else if (registration.mode === "native") {
-		if (!slashCommandsRuntime || !pluginCommandRuntimeModule || !pluginCommandRuntime) throw new Error("Missing command runtimes for native Slack commands.");
+		if (!slashCommandsRuntime || !pluginCommandRuntimeModule) throw new Error("Missing command runtimes for native Slack commands.");
 		for (const command of nativeCommands) {
 			const pluginCommandCandidate = "prepareDispatch" in command ? command : void 0;
 			registerCommand(`/${command.name}`, (cmd) => {
@@ -3666,18 +3619,19 @@ async function registerSlackMonitorSlashCommands(params) {
 		}
 		const respondFn = respond ?? (async (message) => {
 			if (!body.channel?.id || !body.user?.id) return new Response(null, { status: 204 });
-			const payload = typeof message === "string" ? { text: message } : message;
-			const threadTs = body.container?.thread_ts ?? body.message?.thread_ts;
-			await args.client.chat.postEphemeral({
+			return await deliverSlackSlashResponseWithWebApi({
+				client: args.client,
 				token: ctx.botToken,
-				channel: body.channel.id,
-				user: body.user.id,
-				text: payload.text ?? "",
-				...threadTs ? { thread_ts: threadTs } : {},
-				...payload.blocks ? { blocks: payload.blocks } : {},
-				...typeof payload.mrkdwn === "boolean" ? { mrkdwn: payload.mrkdwn } : {}
+				command: {
+					channel_id: body.channel.id,
+					user_id: body.user.id
+				},
+				threadTs: body.container?.thread_ts ?? body.message?.thread_ts,
+				message: {
+					...typeof message === "string" ? { text: message } : message,
+					response_type: "ephemeral"
+				}
 			});
-			return new Response(null, { status: 200 });
 		});
 		const parsed = parseSlackCommandArgValue(action?.value ?? action?.selected_option?.value);
 		if (!parsed) {
@@ -3745,6 +3699,7 @@ async function deliverSlackSlashResponseWithWebApi(params) {
 	const blocks = "blocks" in payload && Array.isArray(payload.blocks) ? payload.blocks : void 0;
 	const mrkdwn = "mrkdwn" in payload && typeof payload.mrkdwn === "boolean" ? payload.mrkdwn : void 0;
 	const message = {
+		...params.token !== void 0 ? { token: params.token } : {},
 		channel: params.command.channel_id,
 		...params.threadTs ? { thread_ts: params.threadTs } : {},
 		text,
@@ -3808,7 +3763,6 @@ function resolveSlackListenerEventScope(params) {
 //#region extensions/slack/src/monitor/events/agent.ts
 function registerSlackAgentEvents(params) {
 	const { ctx, trackEvent } = params;
-	const slackApp = ctx.app;
 	const handleCommand = createSlackCommandHandler({
 		ctx,
 		account: resolveSlackAccount({
@@ -3817,12 +3771,12 @@ function registerSlackAgentEvents(params) {
 		}),
 		trackEvent
 	});
-	slackApp.event("app_context_changed", async ({ body }) => {
+	ctx.app.event("app_context_changed", async ({ body }) => {
 		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
 		trackEvent?.();
 		await ctx.recordSlackAgentView();
 	});
-	slackApp.event("agent_session_stopped", async ({ event, body, context, client }) => {
+	ctx.app.event("agent_session_stopped", async ({ event, body, context, client }) => {
 		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
 		const eventScope = resolveSlackListenerEventScope({
 			ctx,
@@ -3882,7 +3836,7 @@ function registerSlackAgentEvents(params) {
 			eventScope
 		});
 	});
-	slackApp.event("agent_session_title_changed", async ({ event, body, context, client }) => {
+	ctx.app.event("agent_session_title_changed", async ({ event, body, context, client }) => {
 		const runtimeContext = await params.ctx.readRuntimeContext();
 		const runtimeAccount = resolveSlackAccount({
 			cfg: runtimeContext.cfg,
@@ -3905,9 +3859,6 @@ function registerSlackAgentEvents(params) {
 				eventScope
 			});
 			if (!auth.allowed) return;
-			const isDirectMessage = auth.channelType === "im";
-			const isGroupDm = auth.channelType === "mpim";
-			const isRoom = auth.channelType === "channel" || auth.channelType === "group";
 			const routing = await resolveSlackSessionEventRoutingContext({
 				intent: "title",
 				ctx: runtimeContext,
@@ -3919,10 +3870,7 @@ function registerSlackAgentEvents(params) {
 					ts: event.event_ts,
 					thread_ts: event.thread_ts
 				},
-				isDirectMessage,
-				isGroupDm,
-				isRoom,
-				isRoomish: isRoom || isGroupDm,
+				chatType: resolveSlackChatType(auth.channelType),
 				eventScope
 			});
 			if (!await getSlackRuntime().agent.session.patchSessionEntry({
@@ -3958,18 +3906,14 @@ function normalizeAssistantThread(event, getPrevious) {
 	const threadContext = thread.context;
 	const eventContext = event.context;
 	const resolveContextString = (key, previousValue) => threadContext?.[key]?.trim() || eventContext?.[key]?.trim() || previousValue;
-	const enterpriseId = (() => {
-		if (threadContext && "enterprise_id" in threadContext) return threadContext.enterprise_id === null ? null : threadContext.enterprise_id?.trim() || previous?.enterpriseId;
-		if (eventContext && "enterprise_id" in eventContext) return eventContext.enterprise_id === null ? null : eventContext.enterprise_id?.trim() || previous?.enterpriseId;
-		return previous?.enterpriseId;
-	})();
+	const enterpriseContext = threadContext && "enterprise_id" in threadContext ? threadContext : eventContext;
 	return {
 		assistantChannelId: channelId,
 		threadTs,
 		userId: thread.user_id?.trim() || previous?.userId,
 		channelId: resolveContextString("channel_id", previous?.channelId),
 		teamId: resolveContextString("team_id", previous?.teamId),
-		enterpriseId
+		enterpriseId: enterpriseContext?.enterprise_id === null ? null : enterpriseContext?.enterprise_id?.trim() || previous?.enterpriseId
 	};
 }
 async function persistAssistantThreadMetadata(params) {
@@ -4069,25 +4013,6 @@ function migrateSlackChannelConfig(params) {
 //#region extensions/slack/src/monitor/events/channels.ts
 function registerSlackChannelEvents(params) {
 	const { ctx, trackEvent } = params;
-	const enqueueChannelSystemEvent = async (paramsLocal) => {
-		const runtimeContext = await params.ctx.readRuntimeContext();
-		if (!runtimeContext.isChannelAllowed({
-			teamId: paramsLocal.eventScope?.teamId ?? runtimeContext.teamId,
-			channelId: paramsLocal.channelId,
-			channelName: paramsLocal.channelName,
-			channelType: "channel"
-		})) return;
-		const label = resolveSlackChannelLabel({
-			channelId: paramsLocal.channelId,
-			channelName: paramsLocal.channelName
-		});
-		const route = runtimeContext.resolveSlackSystemEventRoute({
-			channelId: paramsLocal.channelId,
-			channelType: "channel",
-			eventScope: paramsLocal.eventScope
-		});
-		enqueueRoutedSystemEvent(`Slack channel ${paramsLocal.kind}: ${label}.`, route, { contextKey: `slack:channel:${paramsLocal.eventScope ? `${paramsLocal.eventScope.teamId}:` : ""}${paramsLocal.kind}:${paramsLocal.channelId ?? paramsLocal.channelName ?? "unknown"}:${paramsLocal.eventId}` });
-	};
 	for (const [eventName, kind] of [["channel_created", "created"], ["channel_rename", "renamed"]]) ctx.app.event(eventName, async (args) => {
 		const { event, body, context, client } = args;
 		const eventScope = resolveSlackListenerEventScope({
@@ -4099,13 +4024,26 @@ function registerSlackChannelEvents(params) {
 		if (eventScope === null || ctx.shouldDropMismatchedSlackEvent(body)) return;
 		trackEvent?.();
 		const channel = event.channel;
-		await enqueueChannelSystemEvent({
-			kind,
-			channelId: channel?.id,
-			channelName: kind === "renamed" ? channel?.name_normalized ?? channel?.name : channel?.name,
-			eventId: body.event_id,
+		const channelId = channel?.id;
+		const channelName = kind === "renamed" ? channel?.name_normalized ?? channel?.name : channel?.name;
+		const eventId = body.event_id;
+		const runtimeContext = await params.ctx.readRuntimeContext();
+		if (!runtimeContext.isChannelAllowed({
+			teamId: eventScope?.teamId ?? runtimeContext.teamId,
+			channelId,
+			channelName,
+			channelType: "channel"
+		})) return;
+		const label = resolveSlackChannelLabel({
+			channelId,
+			channelName
+		});
+		const route = runtimeContext.resolveSlackSystemEventRoute({
+			channelId,
+			channelType: "channel",
 			eventScope
 		});
+		enqueueRoutedSystemEvent(`Slack channel ${kind}: ${label}.`, route, { contextKey: `slack:channel:${eventScope ? `${eventScope.teamId}:` : ""}${kind}:${channelId ?? channelName ?? "unknown"}:${eventId}` });
 	});
 }
 function registerSlackChannelIdChangedEvent(params) {
@@ -4289,9 +4227,7 @@ function summarizeRichTextPreview(value) {
 	collectRichTextFragments(value, fragments);
 	if (fragments.length === 0) return;
 	const joined = fragments.join(" ").replace(/\s+/g, " ").trim();
-	if (!joined) return;
-	const max = 120;
-	return joined.length <= max ? joined : truncateSlackText(joined, max);
+	return truncateSlackText(joined, 120);
 }
 function summarizeAction(action) {
 	const typed = action;
@@ -4355,7 +4291,7 @@ function formatInteractionSelectionLabel(params) {
 	return params.actionId;
 }
 function resolveSlackActionValue(summary) {
-	return normalizeOptionalString(summary.value) ?? summary.selectedValues?.map((value) => normalizeOptionalString(value)).find(Boolean);
+	return normalizeOptionalString(summary.value) ?? summary.selectedValues?.[0];
 }
 function buildSlackPluginInteractionData(params) {
 	const actionId = normalizeOptionalString(params.actionId) ?? "";
@@ -4413,13 +4349,14 @@ async function respondEphemeral(respond, text) {
 		});
 	} catch {}
 }
-async function updateSlackInteractionMessage(params) {
-	if (!params.channelId || !params.messageTs) return;
+async function updateSlackInteractionMessage(params, message) {
+	const { channelId, messageTs } = params.parsed;
+	if (!channelId || !messageTs) return;
 	await (params.eventScope?.client ?? params.ctx.app.client).chat.update({
-		channel: params.channelId,
-		ts: params.messageTs,
-		text: params.text,
-		...params.blocks ? { blocks: params.blocks } : {}
+		channel: channelId,
+		ts: messageTs,
+		text: message.text,
+		...message.blocks ? { blocks: message.blocks } : {}
 	});
 }
 function resolveSlackApprovalTerminalLabel(approval) {
@@ -4477,11 +4414,7 @@ async function handleSlackPluginBindingApproval(params) {
 		senderId: params.parsed.userId
 	});
 	try {
-		await updateSlackInteractionMessage({
-			ctx: params.ctx,
-			eventScope: params.eventScope,
-			channelId: params.parsed.channelId,
-			messageTs: params.parsed.messageTs,
+		await updateSlackInteractionMessage(params, {
 			text: params.parsed.typedBody.message?.text ?? "",
 			blocks: []
 		});
@@ -4525,7 +4458,7 @@ async function handleSlackApprovalInteraction(params) {
 				channelId,
 				messageTs
 			}, async () => {
-				const { readSlackMessages } = await import("./actions-Df0CzcDl.mjs").then((n) => n.t);
+				const { readSlackMessages } = await import("./actions-DDoAJnrH.mjs").then((n) => n.t);
 				const { messages } = await readSlackMessages(channelId, {
 					client: params.eventScope?.client ?? params.ctx.app.client,
 					messageId: messageTs,
@@ -4533,11 +4466,7 @@ async function handleSlackApprovalInteraction(params) {
 				});
 				const current = messages[0];
 				if (!hasSlackApprovalControl(current?.blocks, params.approval)) return false;
-				await updateSlackInteractionMessage({
-					ctx: params.ctx,
-					eventScope: params.eventScope,
-					channelId,
-					messageTs,
+				await updateSlackInteractionMessage(params, {
 					text: truncateSlackText(`${prefix}: ${terminalLabel}`, 4e3),
 					blocks: buildSlackApprovalTerminalBlocks({
 						blocks: current?.blocks,
@@ -4592,11 +4521,7 @@ async function handleSlackLegacyApprovalInteraction(params) {
 			resolveMethod
 		});
 		try {
-			await updateSlackInteractionMessage({
-				ctx: params.ctx,
-				eventScope: params.eventScope,
-				channelId: params.parsed.channelId,
-				messageTs: params.parsed.messageTs,
+			await updateSlackInteractionMessage(params, {
 				text: params.parsed.typedBody.message?.text ?? "",
 				blocks: []
 			});
@@ -4650,11 +4575,7 @@ async function dispatchSlackPluginInteraction(params) {
 			reply,
 			followUp: reply,
 			editMessage: async ({ text, blocks }) => {
-				await updateSlackInteractionMessage({
-					ctx: params.ctx,
-					eventScope: params.eventScope,
-					channelId: params.parsed.channelId,
-					messageTs: params.parsed.messageTs,
+				await updateSlackInteractionMessage(params, {
 					text: text ?? params.parsed.typedBody.message?.text ?? "",
 					blocks: Array.isArray(blocks) ? blocks : void 0
 				});
@@ -4785,11 +4706,7 @@ async function updateSlackLegacyBlockAction(params) {
 	const originalBlocks = params.parsed.typedBody.message?.blocks;
 	if (!Array.isArray(originalBlocks) || !params.parsed.channelId || !params.parsed.messageTs || !params.parsed.blockId) return;
 	try {
-		await updateSlackInteractionMessage({
-			ctx: params.ctx,
-			eventScope: params.eventScope,
-			channelId: params.parsed.channelId,
-			messageTs: params.parsed.messageTs,
+		await updateSlackInteractionMessage(params, {
 			text: params.parsed.typedBody.message?.text ?? "",
 			blocks: buildSlackConfirmationBlocks({
 				parsed: params.parsed,
@@ -4932,11 +4849,6 @@ function shouldHandleSlackModalLifecycleBody(body) {
 	const metadata = parseSlackModalPrivateMetadata(typed.view?.private_metadata);
 	return Boolean(metadata.pluginInteractiveData?.trim());
 }
-function resolveSlackModalPluginNamespace(data) {
-	if (!data) return;
-	const separatorIndex = data.indexOf(":");
-	return separatorIndex >= 0 ? data.slice(0, separatorIndex) : data;
-}
 function resolveSlackPluginSystemEventPayload(result) {
 	if (!result || typeof result !== "object") return;
 	const systemEvent = result.systemEvent;
@@ -5067,7 +4979,7 @@ async function dispatchSlackModalPluginInteractiveHandler(params) {
 	});
 	return {
 		...result,
-		namespace: result.matched ? resolveSlackModalPluginNamespace(params.data) : void 0,
+		namespace: result.matched ? params.data.split(":", 1)[0] : void 0,
 		systemEvent: result.matched ? resolveSlackPluginSystemEventPayload(result.result) : void 0
 	};
 }
@@ -5447,23 +5359,25 @@ function registerSlackInteractionEvents(params) {
 //#region extensions/slack/src/monitor/events/members.ts
 function registerSlackMemberEvents(params) {
 	const { ctx, trackEvent } = params;
-	const handleMemberChannelEvent = async (paramsLocal) => {
+	for (const verb of ["joined", "left"]) ctx.app.event(`member_${verb}_channel`, async (args) => {
+		const { event, body, context, client } = args;
+		const eventId = body.event_id;
 		try {
 			const runtimeContext = await params.ctx.readRuntimeContext();
 			const eventScope = resolveSlackListenerEventScope({
 				ctx: runtimeContext,
-				body: paramsLocal.body,
-				context: paramsLocal.context,
-				client: paramsLocal.client
+				body,
+				context,
+				client
 			});
 			if (eventScope === null) return;
-			if (runtimeContext.shouldDropMismatchedSlackEvent(paramsLocal.body)) return;
+			if (runtimeContext.shouldDropMismatchedSlackEvent(body)) return;
 			trackEvent?.();
-			const payload = paramsLocal.event;
+			const payload = event;
 			const channelId = payload.channel;
 			const channelInfo = channelId ? await runtimeContext.resolveChannelName(channelId, eventScope) : {};
 			const channelType = payload.channel_type ?? channelInfo?.type;
-			if (paramsLocal.verb === "joined" && payload.user === runtimeContext.botUserId && channelId) {
+			if (verb === "joined" && payload.user === runtimeContext.botUserId && channelId) {
 				const roomType = normalizeSlackChannelType(channelType, channelId);
 				if (roomType === "channel" || roomType === "group") {
 					const roomAllowed = runtimeContext.isChannelAllowed({
@@ -5517,23 +5431,16 @@ function registerSlackMemberEvents(params) {
 				senderId: payload.user,
 				channelId,
 				channelType,
-				eventKind: `member-${paramsLocal.verb}`,
+				eventKind: `member-${verb}`,
 				eventScope
 			});
 			if (!ingressContext) return;
 			const userLabel = (payload.user ? await runtimeContext.resolveUserName(payload.user, eventScope) : {})?.name ?? payload.user ?? "someone";
-			enqueueRoutedSystemEvent(`Slack: ${userLabel} ${paramsLocal.verb} ${ingressContext.channelLabel}.`, ingressContext.route, { contextKey: `slack:member:${eventScope ? `${eventScope.teamId}:` : ""}${paramsLocal.verb}:${channelId ?? "unknown"}:${payload.user ?? "unknown"}:${paramsLocal.eventId}` });
+			enqueueRoutedSystemEvent(`Slack: ${userLabel} ${verb} ${ingressContext.channelLabel}.`, ingressContext.route, { contextKey: `slack:member:${eventScope ? `${eventScope.teamId}:` : ""}${verb}:${channelId ?? "unknown"}:${payload.user ?? "unknown"}:${eventId}` });
 		} catch (err) {
-			ctx.runtime.error?.(danger(`slack ${paramsLocal.verb} handler failed: ${formatErrorMessage(err)}`));
+			ctx.runtime.error?.(danger(`slack ${verb} handler failed: ${formatErrorMessage(err)}`));
 			if (err instanceof SlackSystemEventAuthRetryError) throw err;
 		}
-	};
-	for (const verb of ["joined", "left"]) ctx.app.event(`member_${verb}_channel`, async (args) => {
-		await handleMemberChannelEvent({
-			verb,
-			...args,
-			eventId: args.body.event_id
-		});
 	});
 }
 //#endregion
@@ -5639,9 +5546,6 @@ function resolveSlackMessageSubtypeHandler(event) {
 //#endregion
 //#region extensions/slack/src/monitor/events/messages.ts
 const slackInboundLog = createSubsystemLogger("gateway/channels/slack").child("inbound");
-function formatSlackInboundLogLine(params) {
-	return `Inbound app_mention ${`slack:${params.workspaceId}:channel:${params.channelId}:user:${params.userId}`} -> bot:${params.botUserId} (${params.channelType}, ${params.bodyChars} chars)`;
-}
 function isBotAuthoredEnterpriseEvent(event) {
 	return Boolean(normalizeOptionalString(event.bot_id)) || event.subtype === "bot_message";
 }
@@ -5807,14 +5711,8 @@ function registerSlackMessageEvents(params) {
 				return;
 			}
 			if (channelType === "im" || channelType === "mpim") return;
-			slackInboundLog.info(formatSlackInboundLogLine({
-				workspaceId: eventScope?.teamId ?? ctx.teamId,
-				channelId: mention.channel,
-				channelType: channelType ?? "channel",
-				userId: normalizeOptionalString(mention.user) ?? "unknown",
-				botUserId: ctx.botUserId,
-				bodyChars: normalizeOptionalString(mention.text)?.length ?? 0
-			}));
+			const from = `slack:${eventScope?.teamId ?? ctx.teamId}:channel:${mention.channel}:user:${normalizeOptionalString(mention.user) ?? "unknown"}`;
+			slackInboundLog.info(`Inbound app_mention ${from} -> bot:${ctx.botUserId} (${channelType}, ${normalizeOptionalString(mention.text)?.length ?? 0} chars)`);
 			noteConversationMessage(mention, eventScope);
 			await handleSlackMessage(mention, {
 				source: "app_mention",
@@ -5890,7 +5788,17 @@ function shouldEmitSlackReactionNotification(params) {
 function registerSlackReactionEvents(params) {
 	const { ctx, trackEvent } = params;
 	const resolveUserName = (userId, eventScope) => eventScope ? ctx.resolveUserName(userId, eventScope) : ctx.resolveUserName(userId);
-	const handleReactionEvent = async (event, action, eventScope, eventId) => {
+	for (const action of ["added", "removed"]) ctx.app.event(`reaction_${action}`, async (args) => {
+		const { body, context, client } = args;
+		const event = args.event;
+		const eventScope = resolveSlackListenerEventScope({
+			ctx,
+			body,
+			context,
+			client
+		});
+		if (eventScope === null || ctx.shouldDropMismatchedSlackEvent(body)) return;
+		const eventId = body.event_id;
 		try {
 			const runtimeContext = await params.ctx.readRuntimeContext();
 			const item = event.item;
@@ -5906,9 +5814,7 @@ function registerSlackReactionEvents(params) {
 				eventScope
 			});
 			if (!ingressContext) return;
-			const actorInfoPromise = event.user ? resolveUserName(event.user, eventScope) : Promise.resolve(void 0);
-			const authorInfoPromise = event.item_user ? resolveUserName(event.item_user, eventScope) : Promise.resolve(void 0);
-			const [actorInfo, authorInfo] = await Promise.all([actorInfoPromise, authorInfoPromise]);
+			const [actorInfo, authorInfo] = await Promise.all([event.user, event.item_user].map((userId) => userId ? resolveUserName(userId, eventScope) : Promise.resolve(void 0)));
 			if (!shouldEmitSlackReactionNotification({
 				ctx: runtimeContext,
 				event,
@@ -5924,17 +5830,6 @@ function registerSlackReactionEvents(params) {
 		} catch (err) {
 			ctx.runtime.error?.(danger(`slack reaction handler failed: ${formatErrorMessage(err)}`));
 		}
-	};
-	for (const action of ["added", "removed"]) ctx.app.event(`reaction_${action}`, async (args) => {
-		const { event, body, context, client } = args;
-		const eventScope = resolveSlackListenerEventScope({
-			ctx,
-			body,
-			context,
-			client
-		});
-		if (eventScope === null || ctx.shouldDropMismatchedSlackEvent(body)) return;
-		await handleReactionEvent(event, action, eventScope, body.event_id);
 	});
 }
 //#endregion
@@ -6092,7 +5987,7 @@ function buildSlackDebounceKey(message, accountId, teamId) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-B1H63Frf.mjs"));
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-CIepKmZt.mjs"));
 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;
@@ -6207,6 +6102,7 @@ function createSlackMessageHandler(params) {
 							...last.message,
 							text: combinedText
 						};
+						const sourceMessageIds = surviving.flatMap((entry) => entry.message.ts ? [entry.message.ts] : []);
 						const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, turnAdoptionLifecycle, ...lastOpts } = last.opts;
 						let visibleDrop = false;
 						let settlementHandedOff = false;
@@ -6225,7 +6121,7 @@ function createSlackMessageHandler(params) {
 									...lastOpts,
 									senderAuthentication: surviving.every((entry) => entry.opts.senderAuthentication === "verified") ? "verified" : "asserted",
 									wasMentioned: combinedMentioned || last.opts.wasMentioned,
-									sourceMessageIds: surviving.flatMap((entry) => entry.message.ts ? [entry.message.ts] : []),
+									sourceMessageIds,
 									abortSignal: admissionLifecycle.abortSignal,
 									isRuntimePolicyCurrent: runtimeContext.isRuntimePolicyCurrent,
 									onVisibleDrop: () => {
@@ -6271,13 +6167,10 @@ function createSlackMessageHandler(params) {
 								}
 							};
 							onPrepared?.(prepared);
-							if (surviving.length > 1) {
-								const ids = surviving.map((entry) => entry.message.ts).filter(Boolean);
-								if (ids.length > 0) {
-									prepared.ctxPayload.MessageSids = ids;
-									prepared.ctxPayload.MessageSidFirst = ids[0];
-									prepared.ctxPayload.MessageSidLast = ids[ids.length - 1];
-								}
+							if (surviving.length > 1 && sourceMessageIds.length > 0) {
+								prepared.ctxPayload.MessageSids = sourceMessageIds;
+								prepared.ctxPayload.MessageSidFirst = sourceMessageIds[0];
+								prepared.ctxPayload.MessageSidLast = sourceMessageIds.at(-1);
 							}
 							await dispatchPreparedSlackMessage(prepared);
 							if (!turnAdoptionLifecycle && !settlementHandedOff) await commitClaims();
@@ -6445,14 +6338,13 @@ function createSlackPresenceMonitor(params) {
 	if (!params.client && !params.resolveClient) throw new Error("Slack presence monitor requires a client or client resolver");
 	const targets = /* @__PURE__ */ new Map();
 	const presenceByUser = /* @__PURE__ */ new Map();
-	const nowMs = params.nowMs ?? Date.now;
+	const nowMs = params.scheduler.now;
 	const enqueue = params.enqueue ?? enqueueRoutedSystemEvent;
 	const wake = params.wake ?? requestHeartbeat;
 	let pollOffset = 0;
-	let timer;
-	let activePoll;
+	const scheduler = params.scheduler.scope();
+	let started = false;
 	const rateLimitedUntilByWorkspace = /* @__PURE__ */ new Map();
-	let stopped = false;
 	const pruneTargets = (now) => {
 		for (const [key, target] of targets) if (!target.isPolicyCurrent() || now - target.lastActivityAtMs >= SLACK_PRESENCE_TARGET_TTL_MS) targets.delete(key);
 		pruneMapToMaxSize(targets, SLACK_PRESENCE_MAX_TARGETS);
@@ -6501,7 +6393,7 @@ function createSlackPresenceMonitor(params) {
 		}
 		if (!reserved) return;
 		pruneTargets(nowMs());
-		const target = stopped ? void 0 : resolveTarget();
+		const target = scheduler.signal.aborted ? void 0 : resolveTarget();
 		if (!target) {
 			await params.cooldownStore.deleteIfEqual?.(cooldownKey, now);
 			return;
@@ -6550,7 +6442,7 @@ function createSlackPresenceMonitor(params) {
 		const count = Math.min(candidates.length, SLACK_PRESENCE_MAX_POLLS_PER_INTERVAL);
 		const selected = Array.from({ length: count }, (_, index) => candidates[(pollOffset + index) % candidates.length]).filter((subject) => Boolean(subject));
 		for (const subject of selected) {
-			if (stopped) return;
+			if (scheduler.signal.aborted) return;
 			const { teamId, userId } = subject;
 			const workspaceKey = teamId ?? "workspace";
 			const rateLimitedUntilMs = rateLimitedUntilByWorkspace.get(workspaceKey) ?? 0;
@@ -6561,7 +6453,7 @@ function createSlackPresenceMonitor(params) {
 				const client = resolveClient(teamId);
 				if (!client) throw new Error("Slack presence client is unavailable");
 				const response = await withTimeout(client.getPresence({ user: userId }), SLACK_PRESENCE_REQUEST_TIMEOUT_MS, { message: `Slack presence request timed out after ${SLACK_PRESENCE_REQUEST_TIMEOUT_MS}ms` });
-				if (stopped) return;
+				if (scheduler.signal.aborted) return;
 				consumed = true;
 				const next = response.presence === "active" || response.presence === "away" ? response.presence : void 0;
 				if (!next) continue;
@@ -6578,7 +6470,7 @@ function createSlackPresenceMonitor(params) {
 					observedActiveAtMs: observedAtMs
 				});
 			} catch (err) {
-				if (stopped) return;
+				if (scheduler.signal.aborted) return;
 				if (err instanceof WebAPIRateLimitedError) {
 					rateLimitedUntilByWorkspace.set(workspaceKey, Math.max(rateLimitedUntilMs, nowMs() + Math.max(0, err.retryAfter) * 1e3));
 					params.error?.(`slack presence polling rate limited; retrying after ${err.retryAfter}s`);
@@ -6591,33 +6483,20 @@ function createSlackPresenceMonitor(params) {
 			}
 		}
 	};
-	const pollOnce = () => {
-		if (stopped) return Promise.resolve();
-		if (activePoll) return activePoll;
-		const run = performPoll().finally(() => {
-			if (activePoll === run) activePoll = void 0;
-		});
-		activePoll = run;
-		return run;
-	};
 	return {
 		observe,
-		pollOnce,
 		start: () => {
-			if (timer) return;
-			stopped = false;
+			if (started || scheduler.signal.aborted) return;
+			started = true;
 			params.log?.(`slack presence polling enabled for account ${params.accountId}`);
-			timer = setInterval(() => void pollOnce(), SLACK_PRESENCE_POLL_INTERVAL_MS);
-			timer.unref?.();
+			scheduler.schedule({
+				id: "presence",
+				delayMs: SLACK_PRESENCE_POLL_INTERVAL_MS,
+				everyMs: SLACK_PRESENCE_POLL_INTERVAL_MS,
+				run: performPoll
+			});
 		},
-		stop: async () => {
-			stopped = true;
-			if (timer) {
-				clearInterval(timer);
-				timer = void 0;
-			}
-			await activePoll;
-		}
+		stop: () => scheduler.stop()
 	};
 }
 function presenceSubjectKey(subject) {
@@ -6653,7 +6532,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-BpKdjsll.mjs"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-CC3h6M7y.mjs"));
 function resolveSlackRuntimeIdentity(params) {
 	const botUserId = normalizeOptionalString(params.botUserId);
 	const botId = normalizeOptionalString(params.botId);
@@ -6710,7 +6589,8 @@ function resolveSlackRelayConfig(params) {
 		gatewayId
 	};
 }
-async function monitorSlackProvider(opts = {}) {
+async function monitorSlackProvider(opts) {
+	const { scheduler } = opts;
 	const cfg = opts.config ?? getRuntimeConfig();
 	const runtime = opts.runtime ?? createNonExitingRuntime();
 	const account = resolveSlackAccount({
@@ -6907,13 +6787,7 @@ async function monitorSlackProvider(opts = {}) {
 	});
 	let presenceRequestAbort;
 	let presenceMonitor;
-	let presenceMonitorStarted = false;
 	let runtimeStarted = false;
-	const startPresenceMonitor = () => {
-		if (!presenceMonitor || presenceMonitorStarted) return;
-		presenceMonitor.start();
-		presenceMonitorStarted = true;
-	};
 	const installSlackPresenceRuntime = (identity) => {
 		if (!presenceEventsEnabled || presenceMonitor || identity.kind === "degraded" || opts.abortSignal?.aborted) return;
 		presenceRequestAbort = new AbortController();
@@ -6929,6 +6803,7 @@ async function monitorSlackProvider(opts = {}) {
 			installationIdentity: identity
 		});
 		presenceMonitor = createSlackPresenceMonitor({
+			scheduler,
 			accountId: account.accountId,
 			accountConfig: slackCfg.presenceEvents,
 			resolveClient: (workspaceTeamId) => resolveClient(workspaceTeamId).users,
@@ -6936,7 +6811,7 @@ async function monitorSlackProvider(opts = {}) {
 			log: runtime.log,
 			error: runtime.error
 		});
-		if (runtimeStarted) startPresenceMonitor();
+		if (runtimeStarted) presenceMonitor.start();
 	};
 	const handleSlackMessage = createSlackMessageHandler({
 		ctx,
@@ -6965,7 +6840,7 @@ async function monitorSlackProvider(opts = {}) {
 				trackEvent
 			});
 			ctx.readRuntimeContext();
-			if (runtimeStarted) startPresenceMonitor();
+			if (runtimeStarted) presenceMonitor?.start();
 		})();
 		return await workspaceRuntimePromise;
 	};
@@ -7043,7 +6918,7 @@ async function monitorSlackProvider(opts = {}) {
 		await installSlackRuntimeForIdentity(installationIdentity);
 		durableIngress.start();
 		runtimeStarted = true;
-		startPresenceMonitor();
+		presenceMonitor?.start();
 		if (slackMode === "http" && slackHttpHandler) {
 			unregisterHttpHandler = registerSlackHttpHandler({
 				path: slackWebhookPath,