@openclaw/slack 2026.10.1 → 2026.10.5-beta.1

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

@@ -1,20 +1,20 @@
 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-CDgkV7Cm.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-BMg9YLIv.mjs";
 import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-FFE26kOV.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 { A as SLACK_TEXT_LIMIT, Dt as isSlackPluginApprovalAuthorizedSender, G as decodeSlackQuestionAction, H as isSlackCallbackActionId, M as truncateSlackText, Nt as isSlackExecApprovalAuthorizedSender, U as isSlackQuestionActionId, V as isSlackApprovalActionId, at as escapeSlackMrkdwn, c as qualifySlackRoutePeerId, d as resolveSlackConversationBindingRoute, ht as isSlackAnyNativeApprovalClientEnabled, jt as registerSlackInstallationState, l as resolveSlackAgentRoute, n as setSlackSessionStatus, q as resolveSlackQuestionAction, r as buildSlackChannelIdCandidates, s as qualifySlackConversationId, st as decodeSlackApprovalAction, t as renameSlackSession, u as normalizeSlackRouteBindingConfig } from "./session-status-CcXe10zN.mjs";
+import { A as resolveSlackAllowListMatch, C as resolveSlackLookupClientOptions, D as allowListMatches, O as normalizeSlackAllowOwnerEntry, T as resolveSlackWebClientOptions, a as slackIngressIdentity, b as writeLruMapEntry, c as collectSlackCursorPages, f as createSlackStartupAuthClient, g as getSlackListenerWriteClient, i as createSlackIngressSubject, j as resolveSlackUserAllowListForTeam, k as normalizeSlackSlug, m as createSlackWebClient, o as formatSlackError, v as pruneExpiredMapEntries, w as resolveSlackMonitorDispatchers, y as readLruMapEntry } from "./probe-CyX52GtD.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-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 { S as hasSlackMessageTableBlock, f as readSlackMessages, v as isGovSlackClient, y as saveRemoteMedia } from "./actions-KGKwTAKO.mjs";
+import { d as requireSlackPostMessageTimestamp, f as buildSlackMessageIdentityPayload, r as setSlackDefaultSendIdentity } from "./send-CLmsR42r.mjs";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-BaY9_eh1.mjs";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-B96cgprw.mjs";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-Xz9aPdns.mjs";
+import { n as runSlackApprovalMessageUpdate, t as hasSlackApprovalControl } from "./approval-message-updates-CwdDew9i.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";
+import { asNonArrayRecord, asOptionalObjectRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId as normalizeAccountId$1, normalizeMainKey, resolveAgentIdFromSessionKey, resolveAgentRoute, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { createChannelIngressError, createChannelIngressMonitor, waitUntilAbort } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
@@ -27,7 +27,7 @@ import { normalizeStringEntries as normalizeStringEntries$1, normalizeStringEntr
 import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { parseExecApprovalCommandText } from "openclaw/plugin-sdk/approval-reply-runtime";
-import { asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, resolvePromptHistoryLimit, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { asDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, resolvePromptHistoryLimit, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { WebAPIHTTPError, WebAPIPlatformError, WebAPIRateLimitedError, WebAPIRequestError, WebClient } from "@slack/web-api";
 import { classifyTransientNetworkErrorCode } from "openclaw/plugin-sdk/retry-runtime";
 import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, resolvePluginConversationBindingApproval, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
@@ -44,8 +44,9 @@ import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runti
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { channelBlockedPatch, channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { getConversationSession, getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { captureSessionEntryCurrentCheck } from "openclaw/plugin-sdk/session-binding-runtime";
 import { loadPreparedModelCatalog, resolveAgentDir, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
-import { formatCommandArgMenuTitle, resolveCommandAuthorization, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride } from "openclaw/plugin-sdk/command-auth-native";
+import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, parseCommandArgs, resolveCommandArgMenu, resolveCommandAuthorization, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride } from "openclaw/plugin-sdk/command-auth-native";
 import { mergeNativeCommandSpecs } from "openclaw/plugin-sdk/native-command-registry";
 import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
 import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
@@ -140,19 +141,20 @@ function createSlackAgentViewState(params) {
 	};
 	const openWorkspaceStore = createStoreOpener(SLACK_AGENT_VIEW_STATE_NAMESPACE, SLACK_AGENT_VIEW_STATE_MAX_ENTRIES);
 	const openThreadStore = createStoreOpener(SLACK_AGENT_VIEW_THREAD_STATE_NAMESPACE, SLACK_AGENT_VIEW_THREAD_STATE_MAX_ENTRIES);
-	const workspaceStateKey = () => {
+	const resolveStateKey = (thread) => {
 		const apiAppId = params.getApiAppId();
 		return apiAppId ? JSON.stringify([
-			"workspace",
+			thread ? "thread" : "workspace",
 			params.accountId,
 			params.getTeamId(),
-			apiAppId
+			apiAppId,
+			...thread ?? []
 		]) : void 0;
 	};
 	const record = async () => {
 		enabled = true;
 		loaded = true;
-		const stateKey = workspaceStateKey();
+		const stateKey = resolveStateKey();
 		if (persisted || !stateKey) return;
 		const openedStore = openWorkspaceStore();
 		if (!openedStore) return;
@@ -169,7 +171,7 @@ function createSlackAgentViewState(params) {
 	const isEnabled = async () => {
 		if (enabled) return true;
 		if (loaded) return false;
-		const stateKey = workspaceStateKey();
+		const stateKey = resolveStateKey();
 		if (!stateKey) return false;
 		const openedStore = openWorkspaceStore();
 		if (!openedStore) return false;
@@ -185,24 +187,13 @@ function createSlackAgentViewState(params) {
 		}
 	};
 	const managedThreadKey = (channelId, threadTs) => JSON.stringify([channelId, threadTs]);
-	const managedThreadStateKey = (channelId, threadTs) => {
-		const apiAppId = params.getApiAppId();
-		return apiAppId ? JSON.stringify([
-			"thread",
-			params.accountId,
-			params.getTeamId(),
-			apiAppId,
-			channelId,
-			threadTs
-		]) : void 0;
-	};
 	const rememberManagedThread = (key) => {
 		writeLruMapEntry(managedThreads, key, true, SLACK_MANAGED_THREAD_CACHE_MAX_ENTRIES);
 	};
 	const recordManagedThread = async (channelId, threadTs) => {
 		const key = managedThreadKey(channelId, threadTs);
 		rememberManagedThread(key);
-		const stateKey = managedThreadStateKey(channelId, threadTs);
+		const stateKey = resolveStateKey([channelId, threadTs]);
 		const openedStore = stateKey ? openThreadStore() : void 0;
 		if (!openedStore || !stateKey) return;
 		try {
@@ -217,7 +208,7 @@ function createSlackAgentViewState(params) {
 	const isManagedThread = async (channelId, threadTs) => {
 		const key = managedThreadKey(channelId, threadTs);
 		if (managedThreads.has(key)) return true;
-		const stateKey = managedThreadStateKey(channelId, threadTs);
+		const stateKey = resolveStateKey([channelId, threadTs]);
 		const openedStore = stateKey ? openThreadStore() : void 0;
 		if (!openedStore || !stateKey) return false;
 		try {
@@ -323,13 +314,14 @@ function inferSlackChannelType(channelId) {
 	if (trimmed.startsWith("C")) return "channel";
 	if (trimmed.startsWith("G")) return "group";
 }
-function normalizeSlackChannelType(channelType, channelId) {
+function parseSlackChannelType(channelType) {
 	const normalized = normalizeOptionalLowercaseString(channelType);
+	if (normalized === "im" || normalized === "mpim" || normalized === "channel" || normalized === "group") return normalized;
+}
+function normalizeSlackChannelType(channelType, channelId) {
+	const normalized = parseSlackChannelType(channelType);
 	const inferred = inferSlackChannelType(channelId);
-	if (normalized === "im" || normalized === "mpim" || normalized === "channel" || normalized === "group") {
-		if (inferred === "im" && normalized !== "im") return "im";
-		return normalized;
-	}
+	if (normalized && inferred !== "im") return normalized;
 	return inferred ?? "channel";
 }
 function resolveSlackChatType(channelType) {
@@ -617,13 +609,13 @@ const OPENCLAW_SLACK_NATIVE_RECONNECT_OBSERVER_KEY = "__openclawNativeReconnectF
 const SLACK_SOCKET_PONG_TIMEOUT_WARNING_PREFIX = "A pong wasn't received from the server";
 const SLACK_SOCKET_PING_TIMEOUT_WARNING_PREFIX = "A ping wasn't received from the server";
 const SLACK_SOCKET_LOG_LEVEL_IGNORED_WARNING_RE = /^The logLevel given to .+ was ignored as you also gave logger$/;
+const SLACK_SOCKET_FOREIGN_DIAGNOSTICS_WARNING_RE = /^Received unexpected (?:ping|pong) diagnostics message format$/;
 function isConstructorFunction(value) {
 	return typeof value === "function";
 }
 function installSlackNativeReconnectFailureObserver(receiver) {
-	if (!receiver || typeof receiver !== "object") return;
-	const client = Reflect.get(receiver, "client");
-	if (!client || typeof client !== "object") return;
+	const client = asOptionalObjectRecord(asOptionalObjectRecord(receiver)?.client);
+	if (!client) return;
 	if (Reflect.get(client, OPENCLAW_SLACK_NATIVE_RECONNECT_OBSERVER_KEY)) return;
 	const delayReconnectAttempt = Reflect.get(client, "delayReconnectAttempt");
 	const emit = Reflect.get(client, "emit");
@@ -681,10 +673,11 @@ function resolveSlackBoltModule(value) {
 }
 function resolveSlackBoltInterop(params) {
 	const { defaultImport, namespaceImport } = params;
-	const nestedDefault = defaultImport && typeof defaultImport === "object" ? Reflect.get(defaultImport, "default") : void 0;
-	const namespaceDefault = namespaceImport && typeof namespaceImport === "object" ? Reflect.get(namespaceImport, "default") : void 0;
-	const namespaceReceiver = namespaceImport && typeof namespaceImport === "object" ? Reflect.get(namespaceImport, "HTTPReceiver") : void 0;
-	const namespaceSocketModeReceiver = namespaceImport && typeof namespaceImport === "object" ? Reflect.get(namespaceImport, "SocketModeReceiver") : void 0;
+	const nestedDefault = asOptionalObjectRecord(defaultImport)?.default;
+	const namespace = asOptionalObjectRecord(namespaceImport);
+	const namespaceDefault = namespace?.default;
+	const namespaceReceiver = namespace?.HTTPReceiver;
+	const namespaceSocketModeReceiver = namespace?.SocketModeReceiver;
 	const directModule = resolveSlackBoltModule(defaultImport) ?? resolveSlackBoltModule(nestedDefault) ?? resolveSlackBoltModule(namespaceDefault) ?? resolveSlackBoltModule(namespaceImport);
 	if (directModule) return directModule;
 	if (isConstructorFunction(defaultImport) && isConstructorFunction(namespaceReceiver) && isConstructorFunction(namespaceSocketModeReceiver)) return {
@@ -723,11 +716,9 @@ function publishSlackDisconnectedStatus(setStatus, error) {
 		lastError: message ?? null
 	});
 }
-function isSlackSocketHeartbeatTimeoutWarning(args) {
-	return typeof args[0] === "string" && (args[0].startsWith(SLACK_SOCKET_PONG_TIMEOUT_WARNING_PREFIX) || args[0].startsWith(SLACK_SOCKET_PING_TIMEOUT_WARNING_PREFIX));
-}
-function isSlackSocketSelfInflictedLoggerWarning(args) {
-	return typeof args[0] === "string" && SLACK_SOCKET_LOG_LEVEL_IGNORED_WARNING_RE.test(args[0]);
+function isSlackSocketNoiseWarning(args) {
+	const message = args[0];
+	return typeof message === "string" && (message.startsWith(SLACK_SOCKET_PONG_TIMEOUT_WARNING_PREFIX) || message.startsWith(SLACK_SOCKET_PING_TIMEOUT_WARNING_PREFIX) || SLACK_SOCKET_LOG_LEVEL_IGNORED_WARNING_RE.test(message) || SLACK_SOCKET_FOREIGN_DIAGNOSTICS_WARNING_RE.test(message));
 }
 function formatSlackSdkLogArgs(args) {
 	return args.map((arg) => formatSlackError(arg, "")).filter(Boolean).join(" ");
@@ -745,7 +736,7 @@ function createSlackSocketModeLogger() {
 		debug: () => {},
 		info: () => {},
 		warn: (...args) => {
-			if (isSlackSocketHeartbeatTimeoutWarning(args) || isSlackSocketSelfInflictedLoggerWarning(args)) return;
+			if (isSlackSocketNoiseWarning(args)) return;
 			remember(args);
 			console.warn(prefix(), ...args);
 		},
@@ -853,16 +844,9 @@ async function startSlackSocketAndWaitForDisconnect(params) {
 function isMissingSocketStartErrorDetail(err) {
 	return err === void 0 || err === null || err === "" || err instanceof Error && err.message === "";
 }
-function resolveSlackSocketShutdownClient(app) {
-	if (!app || typeof app !== "object") return;
-	const receiver = Reflect.get(app, "receiver");
-	if (!receiver || typeof receiver !== "object") return;
-	const client = Reflect.get(receiver, "client");
-	if (!client || typeof client !== "object") return;
-	return client;
-}
 async function gracefulStopSlackApp(app) {
-	const socketClient = resolveSlackSocketShutdownClient(app);
+	const receiver = asOptionalObjectRecord(asOptionalObjectRecord(app)?.receiver);
+	const socketClient = asOptionalObjectRecord(receiver?.client);
 	if (socketClient) socketClient.shuttingDown = true;
 	await Promise.resolve(app.stop()).catch(() => void 0);
 }
@@ -911,32 +895,16 @@ function createSlackSystemEventRouteResolver(params) {
 		};
 		const peerId = isDirectMessage ? senderId : channelId;
 		if (!peerId) throw new Error("Slack system event route requires a peer");
-		let route = resolveAgentRoute({
+		const route = resolveSlackAgentRoute({
 			cfg: params.cfg,
-			channel: "slack",
 			accountId: params.accountId,
 			teamId: event.eventScope?.teamId ?? params.getTeamId(),
 			peer: {
 				kind: resolveSlackChatType(channelType),
-				id: qualifySlackRoutePeerId({
-					id: peerId,
-					kind: isDirectMessage ? "user" : "channel",
-					eventScope: event.eventScope
-				})
-			}
+				id: peerId
+			},
+			eventScope: event.eventScope
 		});
-		if (event.eventScope && isDirectMessage && route.dmScope === "main") {
-			const sessionKey = resolveSlackEnterpriseMainDmSessionKey({
-				baseSessionKey: route.sessionKey,
-				accountId: params.accountId,
-				eventScope: event.eventScope
-			});
-			route = {
-				...route,
-				sessionKey,
-				mainSessionKey: sessionKey
-			};
-		}
 		const threadTs = normalizeOptionalString(event.threadTs);
 		const baseConversationId = qualifySlackConversationId(isDirectMessage ? `user:${senderId}` : channelId, event.eventScope);
 		const threadBindingRoute = !event.eventScope && threadTs ? resolveRuntimeConversationBindingRoute({
@@ -1108,7 +1076,7 @@ async function resolveWorkspacePolicy(ctx, resolveToken) {
 	} catch (err) {
 		runtime.log?.(`slack channel resolve failed; using config entries. ${formatSlackError(err)}`);
 	}
-	const dmEntries = new Set(normalizeStringEntries(allowFrom).filter((entry) => entry !== "*"));
+	const dmEntries = new Set(allowFrom.filter((entry) => entry !== "*"));
 	const userEntries = new Set(dmEntries);
 	for (const channel of Object.values(channelsConfig ?? {})) addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
 	const entries = [...userEntries];
@@ -1129,10 +1097,10 @@ async function resolveWorkspacePolicy(ctx, resolveToken) {
 		runtime.log?.(`slack user resolve failed; using config entries. ${formatSlackError(err)}`);
 	}
 	const { additions } = buildAllowlistResolutionSummary(resolved.filter((entry) => dmEntries.has(entry.input)), { formatResolved: formatSlackUserResolved });
-	ctx.allowFrom = normalizeStringEntries(mergeAllowlist({
+	ctx.allowFrom = mergeAllowlist({
 		existing: allowFrom,
 		additions
-	}));
+	});
 	const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolved, { formatResolved: formatSlackUserResolved });
 	if (channelsConfig) ctx.channelsConfig = patchAllowlistUsersInConfigEntries({
 		entries: channelsConfig,
@@ -1170,6 +1138,17 @@ async function updateSlackSuggestedPrompts(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/context.ts
+function classifySlackChannelLookupFailure(error) {
+	if (error instanceof WebAPIRateLimitedError) return "rate_limited";
+	if (error instanceof WebAPIHTTPError) return error.statusCode === 429 ? "rate_limited" : error.statusCode === 404 ? "not_found" : "other";
+	if (error instanceof WebAPIPlatformError) {
+		if (error.data.error === "ratelimited") return "rate_limited";
+		if (error.data.error === "channel_not_found" || error.data.error === "not_found") return "not_found";
+		if (error.data.error === "missing_scope" || error.data.error === "not_in_channel") return "permission";
+	}
+	if (error instanceof WebAPIRequestError) return /^A rate limit was exceeded \(url: .+, retry-after: \d+\)$/.test(error.original.message) ? "rate_limited" : "network";
+	return "other";
+}
 const SLACK_CHANNEL_CACHE_MAX_ENTRIES = 1024;
 const SLACK_USER_CACHE_MAX_ENTRIES = 2048;
 const SLACK_AVATAR_CACHE_MAX_ENTRIES = 128;
@@ -1208,8 +1187,8 @@ function createSlackMonitorContextFields(params) {
 	const scopedKey = (key, eventScope) => eventScope ? `${params.accountId}:${eventScope.teamId}:${key}` : key;
 	const rememberSlackChannelType = (channelId, channelType, eventScope) => {
 		const id = normalizeOptionalString(channelId);
-		const normalizedType = normalizeOptionalString(channelType)?.toLowerCase();
-		if (!id || normalizedType !== "im" && normalizedType !== "mpim" && normalizedType !== "channel" && normalizedType !== "group") return;
+		const normalizedType = parseSlackChannelType(channelType);
+		if (!id || !normalizedType) return;
 		const cacheKey = scopedKey(id, eventScope);
 		const cached = readLruMapEntry(channelCache, cacheKey);
 		const type = normalizeSlackChannelType(normalizedType, id);
@@ -1259,8 +1238,11 @@ function createSlackMonitorContextFields(params) {
 			};
 			writeLruMapEntry(channelCache, cacheKey, entry, SLACK_CHANNEL_CACHE_MAX_ENTRIES);
 			return entry.info;
-		} catch {
-			return cached?.info ?? {};
+		} catch (error) {
+			return {
+				...cached?.info,
+				lookupFailureCategory: classifySlackChannelLookupFailure(error)
+			};
 		}
 	};
 	const resolveUserName = async (userId, eventScope) => {
@@ -1682,26 +1664,22 @@ async function resolveThreadTsFromHistory(params) {
 	return normalizeOptionalString(message?.thread_ts);
 }
 function createSlackThreadTsResolver(params) {
-	const ttlMs = Math.max(0, parseFiniteNumber(params.cacheTtlMs) ?? DEFAULT_THREAD_TS_CACHE_TTL_MS);
-	const maxSize = Math.max(0, parseFiniteNumber(params.maxSize) ?? DEFAULT_THREAD_TS_CACHE_MAX);
 	const cache = /* @__PURE__ */ new Map();
 	const inflight = /* @__PURE__ */ new Map();
 	const getCached = (key, now) => {
 		const entry = cache.get(key);
 		if (!entry) 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;
-			}
+		const normalizedNow = asDateTimestampMs(now);
+		if (normalizedNow === void 0 || entry.expiresAt <= normalizedNow) {
+			cache.delete(key);
+			return;
 		}
 		cache.delete(key);
 		cache.set(key, entry);
 		return entry.threadTs;
 	};
 	const setCached = (key, threadTs, now) => {
-		const expiresAt = ttlMs > 0 ? resolveExpiresAtMsFromDurationMs(ttlMs, { nowMs: now }) : 0;
+		const expiresAt = resolveExpiresAtMsFromDurationMs(DEFAULT_THREAD_TS_CACHE_TTL_MS, { nowMs: now });
 		if (expiresAt === void 0) {
 			cache.delete(key);
 			return;
@@ -1711,7 +1689,7 @@ function createSlackThreadTsResolver(params) {
 			threadTs,
 			expiresAt
 		});
-		pruneMapToMaxSize(cache, maxSize);
+		pruneMapToMaxSize(cache, DEFAULT_THREAD_TS_CACHE_MAX);
 	};
 	return { resolve: async (request) => {
 		const { message } = request;
@@ -1759,7 +1737,7 @@ function createSlackThreadTsResolver(params) {
 //#endregion
 //#region extensions/slack/src/monitor/auth.ts
 const slackChannelMembersCache = /* @__PURE__ */ new WeakMap();
-const DEFAULT_CHANNEL_MEMBERS_CACHE_TTL_MS = 6e4;
+const CHANNEL_MEMBERS_CACHE_TTL_MS = 6e4;
 const CHANNEL_MEMBERS_CACHE_MAX = 512;
 const SLACK_CHANNEL_ID = "slack";
 var SlackSystemEventAuthRetryError = class extends Error {};
@@ -1771,12 +1749,6 @@ function createSlackIngressResolver(ctx) {
 		cfg: ctx.cfg
 	});
 }
-function readSlackCacheTtlMs(envName, fallback) {
-	const raw = process.env[envName]?.trim();
-	if (!raw) return fallback;
-	const parsed = /^\d+$/.test(raw) ? Number(raw) : NaN;
-	return Number.isSafeInteger(parsed) ? parsed : fallback;
-}
 function getChannelMembersCache(ctx) {
 	const existing = slackChannelMembersCache.get(ctx);
 	if (existing) return existing;
@@ -1822,17 +1794,16 @@ async function fetchSlackChannelMemberIds(ctx, channelId, eventScope) {
 async function resolveSlackChannelMemberIds(ctx, channelId, eventScope) {
 	const cache = getChannelMembersCache(ctx);
 	const key = `${ctx.accountId}:${eventScope ? `${eventScope.teamId}:` : ""}${channelId}`;
-	const ttlMs = readSlackCacheTtlMs("OPENCLAW_SLACK_CHANNEL_MEMBERS_CACHE_TTL_MS", DEFAULT_CHANNEL_MEMBERS_CACHE_TTL_MS);
 	const rawNowMs = Date.now();
 	const nowMs = asDateTimestampMs(rawNowMs);
 	const cached = cache.get(key);
 	if (cached?.members) {
-		if (ttlMs > 0 && nowMs !== void 0 && cached.expiresAtMs >= nowMs) return cached.members;
+		if (nowMs !== void 0 && cached.expiresAtMs >= nowMs) return cached.members;
 		cache.delete(key);
 	}
 	if (cached?.pending) return await cached.pending;
 	const pending = fetchSlackChannelMemberIds(ctx, channelId, eventScope);
-	const pendingExpiresAtMs = ttlMs > 0 ? resolveExpiresAtMsFromDurationMs(ttlMs, { nowMs: rawNowMs }) : void 0;
+	const pendingExpiresAtMs = resolveExpiresAtMsFromDurationMs(CHANNEL_MEMBERS_CACHE_TTL_MS, { nowMs: rawNowMs });
 	cache.set(key, {
 		expiresAtMs: pendingExpiresAtMs ?? 0,
 		pending
@@ -1840,7 +1811,7 @@ async function resolveSlackChannelMemberIds(ctx, channelId, eventScope) {
 	pruneMapToMaxSize(cache, CHANNEL_MEMBERS_CACHE_MAX);
 	try {
 		const members = await pending;
-		const membersExpiresAtMs = ttlMs > 0 ? resolveExpiresAtMsFromDurationMs(ttlMs) : void 0;
+		const membersExpiresAtMs = resolveExpiresAtMsFromDurationMs(CHANNEL_MEMBERS_CACHE_TTL_MS);
 		if (membersExpiresAtMs !== void 0) {
 			cache.set(key, {
 				expiresAtMs: membersExpiresAtMs,
@@ -2037,9 +2008,7 @@ async function authorizeSlackSystemEventSender(params) {
 			channelName
 		};
 		if (params.interactiveEvent) {
-			const inferredFromId = inferSlackChannelType(channelId);
-			const sourceNormalized = typeof resolvedTypeSource === "string" ? resolvedTypeSource.toLowerCase().trim() : void 0;
-			if (inferredFromId === void 0 && !(sourceNormalized === "im" || sourceNormalized === "mpim" || sourceNormalized === "channel" || sourceNormalized === "group")) return {
+			if (inferSlackChannelType(channelId) === void 0 && !parseSlackChannelType(resolvedTypeSource)) return {
 				allowed: false,
 				reason: "ambiguous-channel-type",
 				channelType,
@@ -2105,6 +2074,39 @@ async function authorizeSlackSystemEventSender(params) {
 	};
 }
 //#endregion
+//#region extensions/slack/src/monitor/event-scope.ts
+function resolveSlackMonitorEventScope(params) {
+	const identity = params.ctx.installationIdentity;
+	const clientOptions = params.ctx.app.webClientOptions;
+	const onDrop = params.onDrop ?? ((reason) => logVerbose(`slack: drop listener event (${reason})`));
+	const drop = (reason) => {
+		onDrop(reason);
+		return null;
+	};
+	const context = params.context ?? {};
+	if (identity.kind !== "enterprise") return context.isEnterpriseInstall === true ? drop("enterprise_event_for_workspace_account") : void 0;
+	const body = params.body && typeof params.body === "object" ? params.body : {};
+	const apiAppId = normalizeOptionalString(body.api_app_id);
+	if (apiAppId && identity.apiAppId && apiAppId !== identity.apiAppId) return drop("wrong_app");
+	if (context.isEnterpriseInstall !== true) return drop("not_enterprise_install");
+	const enterpriseId = normalizeOptionalString(context.enterpriseId);
+	if (!enterpriseId) return drop("missing_enterprise_id");
+	if (enterpriseId !== identity.enterpriseId) return drop("wrong_enterprise");
+	const teamId = normalizeOptionalString(context.teamId);
+	if (!teamId) return drop("missing_team_id");
+	if (!params.client) return drop("missing_listener_client");
+	const writeClient = getSlackListenerWriteClient({
+		listenerClient: params.client,
+		teamId,
+		clientOptions
+	});
+	return {
+		teamId,
+		client: params.client,
+		...writeClient ? { writeClient } : {}
+	};
+}
+//#endregion
 //#region extensions/slack/src/types.ts
 function parseSlackMessageEvent(value) {
 	const record = asOptionalRecord(value);
@@ -2464,17 +2466,14 @@ function resolveSlackThreadContext(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/session-run-targets.ts
-function captureSlackSessionTargetGuard(ctx, route, isActive) {
-	const scope = {
+async function captureSlackSessionTargetGuard(ctx, route, isActive) {
+	const { isCurrent } = await captureSessionEntryCurrentCheck({
 		agentId: route.agentId,
 		sessionKey: route.sessionKey,
-		storePath: resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId })
-	};
-	const selected = getSessionEntry(scope);
-	return () => {
-		const current = getSessionEntry(scope);
-		return isActive?.() !== false && current?.sessionId === selected?.sessionId && current?.lifecycleRevision === selected?.lifecycleRevision;
-	};
+		storePath: resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId }),
+		isActive
+	});
+	return isCurrent;
 }
 const runs = /* @__PURE__ */ new WeakMap();
 function addressKey(address) {
@@ -2511,34 +2510,6 @@ function getSlackSessionRuns(ctx, address) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-routing.ts
-function resolveSlackInitialAgentRoute(params) {
-	const route = resolveAgentRoute({
-		cfg: params.boundAgentId || !params.bindingOwnerAvailable ? { session: params.ctx.cfg.session } : normalizeSlackRouteBindingConfig(params.ctx.cfg),
-		defaultAgentId: params.boundAgentId,
-		channel: "slack",
-		accountId: params.account.accountId,
-		teamId: params.eventScope?.teamId || params.ctx.teamId || void 0,
-		peer: {
-			kind: params.chatType,
-			id: qualifySlackRoutePeerId({
-				id: params.chatType === "direct" ? params.message.user ?? "unknown" : params.message.channel,
-				kind: params.chatType === "direct" ? "user" : "channel",
-				eventScope: params.eventScope
-			})
-		}
-	});
-	if (!params.eventScope || params.chatType !== "direct" || route.dmScope !== "main") return route;
-	const sessionKey = resolveSlackEnterpriseMainDmSessionKey({
-		baseSessionKey: route.sessionKey,
-		accountId: params.account.accountId,
-		eventScope: params.eventScope
-	});
-	return {
-		...route,
-		sessionKey,
-		mainSessionKey: sessionKey
-	};
-}
 function resolveSlackRoutingContext(params) {
 	const { ctx, account, message, chatType, channelConfig, seedTopLevelRoomThread, assistantThreadTs, agentViewThreadTs, eventScope } = params;
 	const isDirectMessage = chatType === "direct";
@@ -2557,12 +2528,15 @@ function resolveSlackRoutingContext(params) {
 	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
 	const bindingRoute = resolveSlackConversationBindingRoute({
 		cfg: ctx.cfg,
-		resolveRoute: (selection) => resolveSlackInitialAgentRoute({
-			...selection,
-			ctx,
-			account,
-			message,
-			chatType,
+		resolveRoute: ({ boundAgentId, bindingOwnerAvailable }) => resolveSlackAgentRoute({
+			cfg: boundAgentId || !bindingOwnerAvailable ? { session: ctx.cfg.session } : normalizeSlackRouteBindingConfig(ctx.cfg),
+			defaultAgentId: boundAgentId,
+			accountId: account.accountId,
+			teamId: eventScope?.teamId || ctx.teamId || void 0,
+			peer: {
+				kind: chatType,
+				id: isDirectMessage ? message.user ?? "unknown" : message.channel
+			},
 			eventScope
 		}),
 		accountId: account.accountId,
@@ -2663,12 +2637,44 @@ async function resolveSlackSessionEventRoutingContext(params) {
 	}
 	if (!owner) throw new Error("No recorded session owns this Slack conversation");
 	const { route } = owner;
-	const isCurrentIncarnation = params.intent === "stop" ? captureSlackSessionTargetGuard(ctx, route, owner.isActive) : void 0;
+	const readLiveOwner = () => getSlackSessionRuns(ctx, liveAddress).at(-1);
+	const current = await captureSessionEntryCurrentCheck({
+		agentId: route.agentId,
+		sessionKey: route.sessionKey,
+		storePath: resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId }),
+		isActive: params.intent === "stop" ? owner.isActive : void 0,
+		matchGeneration: params.intent === "stop",
+		errorMessage: params.intent === "title" ? "Slack conversation owner changed before the title update" : "The selected session changed before it could be stopped.",
+		alternatives: [
+			{ conversations: [{
+				...threadAddress,
+				sessionKey: route.sessionKey
+			}] },
+			{
+				conversations: [{
+					...threadAddress,
+					sessionKey: null
+				}],
+				isActive: () => readLiveOwner()?.route.sessionKey === route.sessionKey
+			},
+			...allowDirectParent ? [{
+				conversations: [{
+					...threadAddress,
+					sessionKey: null
+				}, {
+					...address,
+					sessionKey: route.sessionKey
+				}],
+				isActive: () => !readLiveOwner()
+			}] : []
+		]
+	});
 	return {
 		...routing,
 		route,
 		sessionKey: route.sessionKey,
-		isCurrentSession: () => readOwner()?.route.sessionKey === route.sessionKey && isCurrentIncarnation?.() !== false
+		isCurrentSession: current.isCurrent,
+		assertCurrentSession: current.assertCurrent
 	};
 }
 //#endregion
@@ -2743,77 +2749,11 @@ async function authorizeSlackDirectMessage(params) {
 	return false;
 }
 //#endregion
-//#region extensions/slack/src/monitor/event-scope.ts
-function resolveSlackListenerEventScope$1(params) {
-	const resolved = resolveSlackEventScope(params);
-	if (!resolved.ok) {
-		params.onDrop?.(resolved.reason);
-		return null;
-	}
-	return resolved.scope;
-}
-function resolveSlackEventScope(params) {
-	const context = params.context ?? {};
-	if (params.identity.kind !== "enterprise") return context.isEnterpriseInstall === true ? {
-		ok: false,
-		reason: "enterprise_event_for_workspace_account"
-	} : { ok: true };
-	const body = params.body && typeof params.body === "object" ? params.body : {};
-	const apiAppId = normalizeOptionalString(body.api_app_id);
-	if (apiAppId && params.identity.apiAppId && apiAppId !== params.identity.apiAppId) return {
-		ok: false,
-		reason: "wrong_app"
-	};
-	if (context.isEnterpriseInstall !== true) return {
-		ok: false,
-		reason: "not_enterprise_install"
-	};
-	const enterpriseId = normalizeOptionalString(context.enterpriseId);
-	if (!enterpriseId) return {
-		ok: false,
-		reason: "missing_enterprise_id"
-	};
-	if (enterpriseId !== params.identity.enterpriseId) return {
-		ok: false,
-		reason: "wrong_enterprise"
-	};
-	const teamId = normalizeOptionalString(context.teamId);
-	if (!teamId) return {
-		ok: false,
-		reason: "missing_team_id"
-	};
-	if (!params.client) return {
-		ok: false,
-		reason: "missing_listener_client"
-	};
-	const writeClient = getSlackListenerWriteClient({
-		listenerClient: params.client,
-		teamId,
-		clientOptions: params.clientOptions
-	});
-	return {
-		ok: true,
-		scope: {
-			teamId,
-			client: params.client,
-			...writeClient ? { writeClient } : {}
-		}
-	};
-}
-//#endregion
 //#region extensions/slack/src/monitor/external-arg-menu-store.ts
 const SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES = 18;
 const SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN = new RegExp(`^[A-Za-z0-9_-]{${Math.ceil(24)}}$`);
 const SLACK_EXTERNAL_ARG_MENU_TTL_MS = 6e5;
 const SLACK_EXTERNAL_ARG_MENU_PREFIX = "openclaw_cmdarg_ext:";
-function pruneSlackExternalArgMenuStore(store, rawNow) {
-	const now = asDateTimestampMs(rawNow);
-	if (now === void 0) {
-		store.clear();
-		return;
-	}
-	for (const [token, entry] of store.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) store.delete(token);
-}
 function createSlackExternalArgMenuToken(store) {
 	let token;
 	do
@@ -2825,7 +2765,7 @@ function createSlackExternalArgMenuStore() {
 	const store = /* @__PURE__ */ new Map();
 	return {
 		create(params, now = Date.now()) {
-			pruneSlackExternalArgMenuStore(store, now);
+			pruneExpiredMapEntries(store, now);
 			const token = createSlackExternalArgMenuToken(store);
 			const expiresAt = resolveExpiresAtMsFromDurationMs(SLACK_EXTERNAL_ARG_MENU_TTL_MS, { nowMs: now });
 			if (expiresAt !== void 0) store.set(token, {
@@ -2841,7 +2781,7 @@ function createSlackExternalArgMenuStore() {
 			return SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN.test(token) ? token : void 0;
 		},
 		get(token, now = Date.now()) {
-			pruneSlackExternalArgMenuStore(store, now);
+			pruneExpiredMapEntries(store, now);
 			return store.get(token);
 		}
 	};
@@ -2890,8 +2830,7 @@ const SLACK_COMMAND_ARG_BUTTON_VALUE_MAX = 2e3;
 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-gBj_uaLM.mjs"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-Dzwj6TPI.mjs"));
 const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
 function resolveSlackCommandMenuModelContext(params) {
 	if (!params.sessionKey.trim()) return {};
@@ -3211,7 +3150,7 @@ function createSlackCommandHandler(params) {
 				if (p.threadTs) {
 					if (p.sessionTarget) {
 						resolvedSlashRoute = p.sessionTarget;
-						isCurrentSession = captureSlackSessionTargetGuard(ctx, p.sessionTarget, p.isSessionTargetCurrent);
+						isCurrentSession = await captureSlackSessionTargetGuard(ctx, p.sessionTarget, p.isSessionTargetCurrent);
 						return resolvedSlashRoute;
 					}
 					const routing = await resolveSlackSessionEventRoutingContext({
@@ -3247,7 +3186,6 @@ function createSlackCommandHandler(params) {
 				return resolvedSlashRoute;
 			};
 			if (commandDefinition && supportsInteractiveArgMenus) {
-				const { resolveCommandArgMenu } = await loadSlashCommandsRuntime();
 				const menuNeedsModelContext = !(commandArgs?.raw && !commandArgs.values) && commandDefinition.args?.some((arg) => typeof arg.choices === "function" && commandArgs?.values?.[arg.name] == null);
 				const menuRoute = menuNeedsModelContext || commandDefinition.key === "verbose" ? await resolveSlashRoute() : void 0;
 				const menuModelContext = menuNeedsModelContext && menuRoute ? resolveSlackCommandMenuModelContext({
@@ -3407,12 +3345,10 @@ function createSlackCommandHandler(params) {
 				dispatcherOptions: { onSettled: async () => {
 					if (pendingSlashReplies.length === 0) return;
 					const pending = pendingSlashReplies.splice(0);
-					const settled = /* @__PURE__ */ new Set();
 					try {
 						await deliverSlashPayloads(pending.map((entry) => entry.payload), ({ replyIndex, visibleReplySent, error }) => {
 							const entry = pending[replyIndex];
-							if (!entry || settled.has(replyIndex)) return;
-							settled.add(replyIndex);
+							if (!entry) return;
 							if (error !== void 0) {
 								entry.finalization.reject(error);
 								return;
@@ -3421,7 +3357,7 @@ function createSlackCommandHandler(params) {
 						});
 					} catch (error) {
 						const unsettledError = isChannelPartialDeliveryError(error) ? error.cause ?? error : error;
-						for (const [replyIndex, entry] of pending.entries()) if (!settled.has(replyIndex)) entry.finalization.reject(unsettledError);
+						for (const entry of pending) entry.finalization.reject(unsettledError);
 						throw error;
 					}
 				} },
@@ -3470,12 +3406,9 @@ async function registerSlackMonitorSlashCommands(params) {
 	const { ctx, account, trackEvent } = params;
 	const startupCfg = ctx.cfg;
 	const runtime = ctx.runtime;
-	const resolveEventScope = (args) => resolveSlackListenerEventScope$1({
-		identity: ctx.installationIdentity,
-		body: args.body,
-		context: args.context,
-		client: args.client,
-		clientOptions: ctx.app.webClientOptions,
+	const resolveEventScope = (args) => resolveSlackMonitorEventScope({
+		...args,
+		ctx,
 		onDrop: (reason) => runtime.log?.(`slack: drop slash payload (${reason})`)
 	});
 	const supportsInteractiveArgMenus = typeof ctx.app.action === "function";
@@ -3520,20 +3453,18 @@ async function registerSlackMonitorSlashCommands(params) {
 		});
 	};
 	let nativeCommands = [];
-	let slashCommandsRuntime = null;
 	let pluginCommandRuntimeModule = null;
 	if (registration.mode === "disabled" && resolveNativeCommandsEnabled({
 		providerId: "slack",
 		providerSetting: account.config.commands?.native,
 		globalSetting: startupCfg.commands?.native
 	})) {
-		slashCommandsRuntime = await loadSlashCommandsRuntime();
 		const skillCommands = resolveNativeSkillsEnabled({
 			providerId: "slack",
 			providerSetting: account.config.commands?.nativeSkills,
 			globalSetting: startupCfg.commands?.nativeSkills
-		}) ? slashCommandsRuntime.listSkillCommandsForAgents({ cfg: startupCfg }) : [];
-		nativeCommands = slashCommandsRuntime.listNativeCommandSpecsForConfig(startupCfg, {
+		}) ? listSkillCommandsForAgents({ cfg: startupCfg }) : [];
+		nativeCommands = listNativeCommandSpecsForConfig(startupCfg, {
 			skillCommands,
 			provider: "slack"
 		});
@@ -3547,16 +3478,16 @@ async function registerSlackMonitorSlashCommands(params) {
 	}
 	if (registration.mode === "single") registerCommand(buildSlackSlashCommandMatcher(registration.name));
 	else if (registration.mode === "native") {
-		if (!slashCommandsRuntime || !pluginCommandRuntimeModule) throw new Error("Missing command runtimes for native Slack commands.");
+		if (!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) => {
-				const commandDefinition = pluginCommandCandidate ? void 0 : slashCommandsRuntime.findCommandByNativeName(command.name, "slack");
+				const commandDefinition = pluginCommandCandidate ? void 0 : findCommandByNativeName(command.name, "slack");
 				const rawText = cmd.text?.trim() ?? "";
 				const pluginCommandDispatch = pluginCommandCandidate?.prepareDispatch(rawText) ?? NON_PLUGIN_COMMAND_DISPATCH;
-				const commandArgs = commandDefinition ? slashCommandsRuntime.parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
+				const commandArgs = commandDefinition ? parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
 				return {
-					prompt: commandDefinition ? slashCommandsRuntime.buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`,
+					prompt: commandDefinition ? buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`,
 					commandArgs,
 					commandDefinition: commandDefinition ?? void 0,
 					pluginCommandReplyOptions: { [pluginCommandRuntimeModule.PLUGIN_COMMAND_DISPATCH]: pluginCommandDispatch }
@@ -3648,7 +3579,6 @@ async function registerSlackMonitorSlashCommands(params) {
 			});
 			return;
 		}
-		const { buildCommandTextFromArgs, findCommandByNativeName } = await loadSlashCommandsRuntime();
 		const commandDefinition = findCommandByNativeName(parsed.command, "slack");
 		const commandArgs = { values: { [parsed.arg]: parsed.value } };
 		const prompt = commandDefinition ? buildCommandTextFromArgs(commandDefinition, commandArgs) : `/${parsed.command} ${parsed.value}`;
@@ -3719,47 +3649,6 @@ function isSlackBoltRespondError(error) {
 	return Boolean(error) && typeof error === "object" && error.code === "slack_bolt_respond_error";
 }
 //#endregion
-//#region extensions/slack/src/monitor/events/system-event-context.ts
-async function authorizeAndResolveSlackSystemEventContext(params) {
-	const { senderId, channelId, channelType, eventKind } = params;
-	const ctx = await params.ctx.readRuntimeContext();
-	const auth = await authorizeSlackSystemEventSender({
-		ctx,
-		senderId,
-		channelId,
-		channelType,
-		eventScope: params.eventScope,
-		retryNameLookup: eventKind.startsWith("member-")
-	});
-	if (!auth.allowed) {
-		logVerbose(`slack: drop ${eventKind} sender ${senderId ?? "unknown"} channel=${channelId ?? "unknown"} reason=${auth.reason ?? "unauthorized"}`);
-		return;
-	}
-	return {
-		channelLabel: resolveSlackChannelLabel({
-			channelId,
-			channelName: auth.channelName
-		}),
-		route: ctx.resolveSlackSystemEventRoute({
-			channelId,
-			channelType: auth.channelType,
-			senderId,
-			threadTs: auth.channelType === "im" ? void 0 : params.threadTs,
-			eventScope: params.eventScope
-		})
-	};
-}
-function resolveSlackListenerEventScope(params) {
-	return resolveSlackListenerEventScope$1({
-		identity: params.ctx.installationIdentity,
-		body: params.body,
-		context: params.context,
-		client: params.client,
-		clientOptions: params.ctx.app.webClientOptions,
-		onDrop: (reason) => logVerbose(`slack: drop listener event (${reason})`)
-	});
-}
-//#endregion
 //#region extensions/slack/src/monitor/events/agent.ts
 function registerSlackAgentEvents(params) {
 	const { ctx, trackEvent } = params;
@@ -3778,7 +3667,7 @@ function registerSlackAgentEvents(params) {
 	});
 	ctx.app.event("agent_session_stopped", async ({ event, body, context, client }) => {
 		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
-		const eventScope = resolveSlackListenerEventScope({
+		const eventScope = resolveSlackMonitorEventScope({
 			ctx,
 			body,
 			context,
@@ -3843,7 +3732,7 @@ function registerSlackAgentEvents(params) {
 			accountId: runtimeContext.accountId
 		});
 		if (runtimeContext.shouldDropMismatchedSlackEvent(body)) return;
-		const eventScope = resolveSlackListenerEventScope({
+		const eventScope = resolveSlackMonitorEventScope({
 			ctx: runtimeContext,
 			body,
 			context,
@@ -3878,9 +3767,7 @@ function registerSlackAgentEvents(params) {
 				storePath: resolveStorePath(runtimeContext.cfg.session?.store, { agentId: routing.route.agentId }),
 				sessionKey: routing.sessionKey,
 				preserveActivity: true,
-				assertCommitAllowed: () => {
-					if (!routing.isCurrentSession()) throw new Error("Slack conversation owner changed before the title update");
-				},
+				assertCommitAllowed: routing.assertCurrentSession,
 				update: () => ({ displayName: event.title })
 			})) throw new Error("Slack conversation session disappeared before the title update");
 			runtimeContext.recordSlackSessionTitle({
@@ -4015,7 +3902,7 @@ function registerSlackChannelEvents(params) {
 	const { ctx, trackEvent } = params;
 	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({
+		const eventScope = resolveSlackMonitorEventScope({
 			ctx,
 			body,
 			context,
@@ -4180,18 +4067,117 @@ async function dispatchSlackPluginInteractiveHandler(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/interaction-event.ts
-function enqueueSlackInteractionEvent(...args) {
-	if (enqueueRoutedSystemEvent(...args)) {
-		const route = args[1];
-		requestHeartbeat({
-			source: "hook",
-			intent: "immediate",
-			reason: "hook:slack-interaction",
-			agentId: route.agentId,
-			sessionKey: route.sessionKey,
-			heartbeat: { target: "last" }
-		});
+const SLACK_INTERACTION_EVENT_PREFIX = "Slack interaction: ";
+const REDACTED_INTERACTION_VALUE = "[redacted]";
+const SLACK_INTERACTION_EVENT_MAX_CHARS = 2400;
+const SLACK_INTERACTION_STRING_MAX_CHARS = 160;
+const SLACK_INTERACTION_ARRAY_MAX_ITEMS = 64;
+const SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS = 3;
+const SLACK_INTERACTION_REDACTED_KEYS = /* @__PURE__ */ new Set([
+	"triggerId",
+	"responseUrl",
+	"workflowTriggerUrl",
+	"privateMetadata",
+	"viewHash"
+]);
+function sanitizeSlackInteractionPayloadValue(value, key) {
+	if (value === void 0) return;
+	if (key && SLACK_INTERACTION_REDACTED_KEYS.has(key)) {
+		if (typeof value !== "string" || value.trim().length === 0) return;
+		return REDACTED_INTERACTION_VALUE;
+	}
+	if (typeof value === "string") return truncateSlackText(value, SLACK_INTERACTION_STRING_MAX_CHARS);
+	if (Array.isArray(value)) {
+		const sanitized = value.slice(0, SLACK_INTERACTION_ARRAY_MAX_ITEMS).map((entry) => sanitizeSlackInteractionPayloadValue(entry)).filter((entry) => entry !== void 0);
+		if (value.length > SLACK_INTERACTION_ARRAY_MAX_ITEMS) sanitized.push(`…+${value.length - SLACK_INTERACTION_ARRAY_MAX_ITEMS} more`);
+		return sanitized;
+	}
+	if (!value || typeof value !== "object") return value;
+	const output = {};
+	for (const [entryKey, entryValue] of Object.entries(value)) {
+		const sanitized = sanitizeSlackInteractionPayloadValue(entryValue, entryKey);
+		if (sanitized === void 0) continue;
+		if (typeof sanitized === "string" && sanitized.length === 0) continue;
+		if (Array.isArray(sanitized) && sanitized.length === 0) continue;
+		output[entryKey] = sanitized;
 	}
+	return output;
+}
+function buildCompactSlackInteractionPayload(payload) {
+	const rawInputs = Array.isArray(payload.inputs) ? payload.inputs : [];
+	const compactInputs = rawInputs.slice(0, SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS).flatMap((entry) => {
+		const typed = asOptionalObjectRecord(entry);
+		if (!typed) return [];
+		return [{
+			actionId: typed.actionId,
+			blockId: typed.blockId,
+			actionType: typed.actionType,
+			inputKind: typed.inputKind,
+			selectedValues: typed.selectedValues,
+			selectedLabels: typed.selectedLabels,
+			inputValue: typed.inputValue,
+			inputNumber: typed.inputNumber,
+			selectedDate: typed.selectedDate,
+			selectedTime: typed.selectedTime,
+			selectedDateTime: typed.selectedDateTime,
+			richTextPreview: typed.richTextPreview
+		}];
+	});
+	return {
+		interactionType: payload.interactionType,
+		actionId: payload.actionId,
+		callbackId: payload.callbackId,
+		actionType: payload.actionType,
+		actionTs: payload.actionTs,
+		userId: payload.userId,
+		teamId: payload.teamId,
+		channelId: payload.channelId ?? payload.routedChannelId,
+		messageTs: payload.messageTs,
+		threadTs: payload.threadTs,
+		messageUserId: payload.messageUserId,
+		messageText: payload.messageText,
+		viewId: payload.viewId,
+		isCleared: payload.isCleared,
+		selectedValues: payload.selectedValues,
+		selectedLabels: payload.selectedLabels,
+		selectedDate: payload.selectedDate,
+		selectedTime: payload.selectedTime,
+		selectedDateTime: payload.selectedDateTime,
+		workflowId: payload.workflowId,
+		routedChannelType: payload.routedChannelType,
+		pluginHandled: payload.pluginHandled,
+		pluginNamespace: payload.pluginNamespace,
+		pluginDuplicate: payload.pluginDuplicate,
+		pluginSystemEvent: payload.pluginSystemEvent,
+		inputs: compactInputs.length > 0 ? compactInputs : void 0,
+		inputsOmitted: rawInputs.length > SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS ? rawInputs.length - SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS : void 0,
+		payloadTruncated: true
+	};
+}
+function formatSlackInteractionSystemEvent(payload) {
+	const toEventText = (value) => `${SLACK_INTERACTION_EVENT_PREFIX}${JSON.stringify(value)}`;
+	const sanitizedPayload = sanitizeSlackInteractionPayloadValue(payload) ?? {};
+	let eventText = toEventText(sanitizedPayload);
+	if (eventText.length <= SLACK_INTERACTION_EVENT_MAX_CHARS) return eventText;
+	eventText = toEventText(sanitizeSlackInteractionPayloadValue(buildCompactSlackInteractionPayload(sanitizedPayload)));
+	if (eventText.length <= SLACK_INTERACTION_EVENT_MAX_CHARS) return eventText;
+	return toEventText({
+		interactionType: sanitizedPayload.interactionType,
+		actionId: sanitizedPayload.actionId ?? "unknown",
+		userId: sanitizedPayload.userId,
+		channelId: sanitizedPayload.channelId ?? sanitizedPayload.routedChannelId,
+		payloadTruncated: true
+	});
+}
+function enqueueSlackInteractionEvent(payload, route, options) {
+	if (enqueueRoutedSystemEvent(formatSlackInteractionSystemEvent(payload), route, options)) requestHeartbeat({
+		source: "hook",
+		intent: "immediate",
+		reason: "hook:slack-interaction",
+		agentId: route.agentId,
+		sessionKey: route.sessionKey,
+		heartbeat: { target: "last" }
+	});
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/interactions.approval-sender.ts
@@ -4211,14 +4197,14 @@ function resolveSlackPluginApprovalSender(params) {
 	};
 }
 //#endregion
-//#region extensions/slack/src/monitor/events/interactions.block-actions.ts
+//#region extensions/slack/src/monitor/events/modal-input-summary.ts
 function readOptionStrings(options, read) {
 	if (!Array.isArray(options)) return [];
 	return options.map((option) => option && typeof option === "object" ? read(option) : void 0).filter((value) => typeof value === "string" && value.trim().length > 0);
 }
 function collectRichTextFragments(value, out) {
-	if (!value || typeof value !== "object") return;
-	const typed = value;
+	const typed = asOptionalObjectRecord(value);
+	if (!typed) return;
 	if (typeof typed.text === "string" && typed.text.trim().length > 0) out.push(typed.text.trim());
 	if (Array.isArray(typed.elements)) for (const child of typed.elements) collectRichTextFragments(child, out);
 }
@@ -4246,12 +4232,7 @@ function summarizeAction(action) {
 	const inputValue = typeof typed.value === "string" ? typed.value : void 0;
 	const inputNumber = actionType === "number_input" && inputValue != null ? parseStrictFiniteNumber(inputValue) : void 0;
 	const inputEmail = actionType === "email_text_input" && inputValue?.includes("@") ? inputValue : void 0;
-	let inputUrl;
-	if (actionType === "url_text_input" && inputValue) try {
-		inputUrl = new URL(inputValue).toString();
-	} catch {
-		inputUrl = void 0;
-	}
+	const inputUrl = actionType === "url_text_input" && inputValue ? URL.parse(inputValue)?.toString() : void 0;
 	const richTextValue = actionType === "rich_text_input" ? typed.rich_text_value : void 0;
 	const richTextPreview = summarizeRichTextPreview(richTextValue);
 	return {
@@ -4276,10 +4257,32 @@ function summarizeAction(action) {
 		workflowId: typed.workflow?.workflow_id
 	};
 }
-function formatInteractionSelectionLabel(params) {
-	if (params.summary.actionType === "button" && params.buttonText?.trim()) return params.buttonText.trim();
-	const selected = params.summary.selectedLabels?.length ? params.summary.selectedLabels : params.summary.selectedValues;
-	if (selected?.length) return selected.length <= 3 ? selected.join(", ") : `${selected.slice(0, 3).join(", ")} +${selected.length - 3}`;
+function summarizeSlackViewState(values) {
+	const blocks = asOptionalObjectRecord(values);
+	if (!blocks) return [];
+	const entries = [];
+	for (const [blockId, blockValue] of Object.entries(blocks)) {
+		const actions = asOptionalObjectRecord(blockValue);
+		if (!actions) continue;
+		for (const [actionId, rawAction] of Object.entries(actions)) {
+			const action = asOptionalObjectRecord(rawAction);
+			if (!action) continue;
+			const actionSummary = summarizeAction(action);
+			entries.push({
+				blockId,
+				actionId,
+				...actionSummary
+			});
+		}
+	}
+	return entries;
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/interactions.block-actions.ts
+function formatInteractionSelectionLabel(params) {
+	if (params.summary.actionType === "button" && params.buttonText?.trim()) return params.buttonText.trim();
+	const selected = params.summary.selectedLabels?.length ? params.summary.selectedLabels : params.summary.selectedValues;
+	if (selected?.length) return selected.length <= 3 ? selected.join(", ") : `${selected.slice(0, 3).join(", ")} +${selected.length - 3}`;
 	if (params.summary.selectedDate) return params.summary.selectedDate;
 	if (params.summary.selectedTime) return params.summary.selectedTime;
 	if (typeof params.summary.selectedDateTime === "number") {
@@ -4458,7 +4461,7 @@ async function handleSlackApprovalInteraction(params) {
 				channelId,
 				messageTs
 			}, async () => {
-				const { readSlackMessages } = await import("./actions-DDoAJnrH.mjs").then((n) => n.t);
+				const { readSlackMessages } = await import("./actions-KGKwTAKO.mjs").then((n) => n.t);
 				const { messages } = await readSlackMessages(channelId, {
 					client: params.eventScope?.client ?? params.ctx.app.client,
 					messageId: messageTs,
@@ -4657,23 +4660,21 @@ function enqueueSlackBlockActionEvent(params) {
 		threadTs: params.parsed.threadTs
 	};
 	params.ctx.runtime.log?.(`slack:interaction action=${params.parsed.actionId} type=${params.parsed.actionSummary.actionType ?? "unknown"} user=${params.parsed.userId} channel=${params.parsed.channelId}`);
-	const route = params.ctx.resolveSlackSystemEventRoute({
+	enqueueSlackInteractionEvent(eventPayload, params.ctx.resolveSlackSystemEventRoute({
 		channelId: params.parsed.channelId,
 		channelType: params.auth.channelType,
 		senderId: params.parsed.userId,
 		threadTs: params.parsed.threadTs,
 		eventScope: params.eventScope
-	});
-	const contextParts = [
-		"slack:interaction",
-		params.teamId,
-		params.parsed.channelId,
-		params.parsed.messageTs,
-		params.parsed.actionId,
-		normalizeOptionalString(params.parsed.typedActionWithText.action_ts) ?? params.parsed.typedBody.trigger_id
-	].filter(Boolean);
-	enqueueSlackInteractionEvent(params.formatSystemEvent(eventPayload), route, {
-		contextKey: contextParts.join(":"),
+	}), {
+		contextKey: [
+			"slack:interaction",
+			params.teamId,
+			params.parsed.channelId,
+			params.parsed.messageTs,
+			params.parsed.actionId,
+			normalizeOptionalString(params.parsed.typedActionWithText.action_ts) ?? params.parsed.typedBody.trigger_id
+		].filter(Boolean).join(":"),
 		deliveryContext: {
 			channel: "slack",
 			to: deferredTarget?.target,
@@ -4723,12 +4724,11 @@ function registerSlackBlockActionHandler(params) {
 		const { ack, body, action, respond } = args;
 		await ack();
 		const runtimeContext = await params.ctx.readRuntimeContext();
-		const eventScope = resolveSlackListenerEventScope$1({
-			identity: runtimeContext.installationIdentity,
+		const eventScope = resolveSlackMonitorEventScope({
+			ctx: runtimeContext,
 			body,
 			context: args.context,
 			client: args.client,
-			clientOptions: runtimeContext.app.webClientOptions,
 			onDrop: (reason) => runtimeContext.runtime.log?.(`slack:interaction drop action ${reason}`)
 		});
 		if (eventScope === null) return;
@@ -4811,8 +4811,7 @@ function registerSlackBlockActionHandler(params) {
 		enqueueSlackBlockActionEvent({
 			...actionContext,
 			teamId: args.context.teamId,
-			auth,
-			formatSystemEvent: params.formatSystemEvent
+			auth
 		});
 		await updateSlackLegacyBlockAction(actionContext);
 	});
@@ -4850,14 +4849,12 @@ function shouldHandleSlackModalLifecycleBody(body) {
 	return Boolean(metadata.pluginInteractiveData?.trim());
 }
 function resolveSlackPluginSystemEventPayload(result) {
-	if (!result || typeof result !== "object") return;
-	const systemEvent = result.systemEvent;
-	if (!systemEvent || typeof systemEvent !== "object") return;
-	const typed = systemEvent;
+	const systemEvent = asOptionalObjectRecord(asOptionalObjectRecord(result)?.systemEvent);
+	if (!systemEvent) return;
 	const output = {};
-	if (typeof typed.summary === "string" && typed.summary.trim()) output.summary = typed.summary;
-	if (typeof typed.reference === "string" && typed.reference.trim()) output.reference = typed.reference;
-	if (typed.data && typeof typed.data === "object" && !Array.isArray(typed.data)) output.data = typed.data;
+	if (typeof systemEvent.summary === "string" && systemEvent.summary.trim()) output.summary = systemEvent.summary;
+	if (typeof systemEvent.reference === "string" && systemEvent.reference.trim()) output.reference = systemEvent.reference;
+	if (systemEvent.data && typeof systemEvent.data === "object" && !Array.isArray(systemEvent.data)) output.data = systemEvent.data;
 	return Object.keys(output).length > 0 ? output : void 0;
 }
 function resolveModalSessionRouting(params) {
@@ -4869,22 +4866,19 @@ function resolveModalSessionRouting(params) {
 		channelId: metadata.channelId,
 		channelType: metadata.channelType
 	};
-	const routing = metadata.channelId ? {
-		...params.ctx.resolveSlackSystemEventRoute({
-			channelId: metadata.channelId,
-			channelType: metadata.channelType,
-			senderId: params.userId,
-			eventScope: params.eventScope
-		}),
-		channelId: metadata.channelId,
-		channelType: metadata.channelType
-	} : {
+	const routing = {
 		...params.ctx.resolveSlackSystemEventRoute({
-			channelType: "im",
+			...metadata.channelId ? {
+				channelId: metadata.channelId,
+				channelType: metadata.channelType
+			} : { channelType: "im" },
 			senderId: params.userId,
 			eventScope: params.eventScope
 		}),
-		channelType: params.eventScope ? "im" : void 0
+		...metadata.channelId ? {
+			channelId: metadata.channelId,
+			channelType: metadata.channelType
+		} : { channelType: params.eventScope ? "im" : void 0 }
 	};
 	if (metadata.sessionKey && (metadata.sessionKey === routing.sessionKey || metadata.sessionKey.startsWith(`${routing.sessionKey}:thread:`))) return {
 		...routing,
@@ -4892,105 +4886,35 @@ function resolveModalSessionRouting(params) {
 	};
 	return routing;
 }
-function resolveSlackModalEventBase(params) {
+async function emitSlackModalLifecycleEvent(params) {
 	const metadata = parseSlackModalPrivateMetadata(params.body.view?.private_metadata);
 	const callbackId = params.body.view?.callback_id ?? "unknown";
 	const userId = params.body.user?.id ?? "unknown";
 	const viewId = params.body.view?.id;
-	const inputs = params.summarizeViewState(params.body.view?.state?.values);
+	const inputs = summarizeSlackViewState(params.body.view?.state?.values);
 	const sessionRouting = resolveModalSessionRouting({
 		ctx: params.ctx,
 		metadata,
 		userId,
 		eventScope: params.eventScope
 	});
-	return {
+	const stateValues = params.body.view?.state?.values;
+	const payload = {
+		actionId: `view:${callbackId}`,
 		callbackId,
-		userId,
-		metadata,
 		viewId,
-		sessionRouting,
-		stateValues: params.body.view?.state?.values,
-		payload: {
-			actionId: `view:${callbackId}`,
-			callbackId,
-			viewId,
-			userId,
-			teamId: params.teamId,
-			rootViewId: params.body.view?.root_view_id,
-			previousViewId: params.body.view?.previous_view_id,
-			externalId: params.body.view?.external_id,
-			viewHash: params.body.view?.hash,
-			isStackedView: Boolean(params.body.view?.previous_view_id),
-			privateMetadata: params.body.view?.private_metadata,
-			routedChannelId: sessionRouting.channelId,
-			routedChannelType: sessionRouting.channelType,
-			inputs
-		}
-	};
-}
-async function dispatchSlackModalPluginInteractiveHandler(params) {
-	if (!params.data) return {
-		matched: false,
-		handled: false,
-		duplicate: false
-	};
-	const isViewClosed = params.interactionType === "view_closed";
-	const interactionId = [
-		params.interactionType,
-		params.payload.callbackId,
-		params.payload.viewId,
-		params.payload.userId
-	].filter(Boolean).join(":");
-	const result = await dispatchSlackPluginInteractiveHandler({
-		data: params.data,
-		interactionId,
-		teamId: params.eventScope?.teamId,
-		channelType: params.channelType,
-		ctx: {
-			accountId: params.ctx.accountId,
-			interactionId,
-			conversationId: params.sessionRouting.channelId ?? "",
-			parentConversationId: void 0,
-			threadId: void 0,
-			senderId: params.payload.userId,
-			senderUsername: void 0,
-			auth: params.auth,
-			interaction: {
-				kind: params.interactionType,
-				callbackId: params.payload.callbackId,
-				viewId: params.payload.viewId,
-				rootViewId: params.payload.rootViewId,
-				previousViewId: params.payload.previousViewId,
-				externalId: params.payload.externalId,
-				isStackedView: params.payload.isStackedView,
-				isCleared: isViewClosed ? params.body.is_cleared === true : void 0,
-				inputs: params.payload.inputs,
-				stateValues: params.stateValues,
-				triggerId: params.body.trigger_id
-			}
-		},
-		respond: {
-			acknowledge: async () => {},
-			reply: async () => {},
-			followUp: async () => {},
-			editMessage: async () => {}
-		}
-	});
-	return {
-		...result,
-		namespace: result.matched ? params.data.split(":", 1)[0] : void 0,
-		systemEvent: result.matched ? resolveSlackPluginSystemEventPayload(result.result) : void 0
-	};
-}
-async function emitSlackModalLifecycleEvent(params) {
-	const { callbackId, userId, metadata, viewId, sessionRouting, stateValues, payload } = resolveSlackModalEventBase({
-		ctx: params.ctx,
-		body: params.body,
-		eventScope: params.eventScope,
+		userId,
 		teamId: params.teamId,
-		summarizeViewState: params.summarizeViewState
-	});
+		rootViewId: params.body.view?.root_view_id,
+		previousViewId: params.body.view?.previous_view_id,
+		externalId: params.body.view?.external_id,
+		viewHash: params.body.view?.hash,
+		isStackedView: Boolean(params.body.view?.previous_view_id),
+		privateMetadata: params.body.view?.private_metadata,
+		routedChannelId: sessionRouting.channelId,
+		routedChannelType: sessionRouting.channelType,
+		inputs
+	};
 	const pluginInteractiveData = resolveSlackModalPluginInteractiveData({
 		callbackId,
 		metadata
@@ -5006,18 +4930,53 @@ async function emitSlackModalLifecycleEvent(params) {
 	else params.ctx.runtime.log?.(`slack:interaction view_submission callback=${callbackId} user=${userId} inputs=${payload.inputs.length}`);
 	const dispatchPlugin = async (isAuthorizedSender, channelType) => {
 		try {
-			return await dispatchSlackModalPluginInteractiveHandler({
-				ctx: params.ctx,
-				body: params.body,
-				eventScope: params.eventScope,
-				interactionType: params.interactionType,
+			if (!pluginInteractiveData) return;
+			const interactionId = [
+				params.interactionType,
+				payload.callbackId,
+				payload.viewId,
+				payload.userId
+			].filter(Boolean).join(":");
+			const result = await dispatchSlackPluginInteractiveHandler({
 				data: pluginInteractiveData,
-				auth: { isAuthorizedSender },
+				interactionId,
+				teamId: params.eventScope?.teamId,
 				channelType,
-				payload,
-				stateValues,
-				sessionRouting
+				ctx: {
+					accountId: params.ctx.accountId,
+					interactionId,
+					conversationId: sessionRouting.channelId ?? "",
+					parentConversationId: void 0,
+					threadId: void 0,
+					senderId: payload.userId,
+					senderUsername: void 0,
+					auth: { isAuthorizedSender },
+					interaction: {
+						kind: params.interactionType,
+						callbackId: payload.callbackId,
+						viewId: payload.viewId,
+						rootViewId: payload.rootViewId,
+						previousViewId: payload.previousViewId,
+						externalId: payload.externalId,
+						isStackedView: payload.isStackedView,
+						isCleared: isViewClosed ? params.body.is_cleared === true : void 0,
+						inputs: payload.inputs,
+						stateValues,
+						triggerId: params.body.trigger_id
+					}
+				},
+				respond: {
+					acknowledge: async () => {},
+					reply: async () => {},
+					followUp: async () => {},
+					editMessage: async () => {}
+				}
 			});
+			return {
+				...result,
+				namespace: result.matched ? pluginInteractiveData.split(":", 1)[0] : void 0,
+				systemEvent: result.matched ? resolveSlackPluginSystemEventPayload(result.result) : void 0
+			};
 		} catch (error) {
 			params.ctx.runtime.log?.(`slack:interaction modal plugin dispatch failed callback=${callbackId} error=${error instanceof Error ? error.message : String(error)}`);
 			return;
@@ -5055,12 +5014,12 @@ async function emitSlackModalLifecycleEvent(params) {
 		kind: targetKind,
 		id: targetId
 	}) : void 0;
-	enqueueSlackInteractionEvent(params.formatSystemEvent({
+	enqueueSlackInteractionEvent({
 		...eventPayload,
 		...pluginEventFields
-	}), sessionRouting, {
+	}, sessionRouting, {
 		contextKey: [
-			params.contextPrefix,
+			isViewClosed ? "slack:interaction:view-closed" : "slack:interaction:view",
 			params.teamId,
 			callbackId,
 			viewId,
@@ -5074,16 +5033,18 @@ async function emitSlackModalLifecycleEvent(params) {
 	});
 }
 function registerModalLifecycleHandler(params) {
-	params.register(params.matcher, async (args) => {
+	params.ctx.app.view({
+		callback_id: /.*/,
+		type: params.interactionType
+	}, async (args) => {
 		const { ack, body } = args;
 		if (!shouldHandleSlackModalLifecycleBody(body)) return;
 		await ack();
-		const eventScope = resolveSlackListenerEventScope$1({
-			identity: params.ctx.installationIdentity,
+		const eventScope = resolveSlackMonitorEventScope({
+			ctx: params.ctx,
 			body,
 			context: args.context,
 			client: args.client,
-			clientOptions: params.ctx.app.webClientOptions,
 			onDrop: (reason) => params.ctx.runtime.log?.(`slack:interaction drop ${params.interactionType} ${reason}`)
 		});
 		if (eventScope === null) return;
@@ -5098,10 +5059,7 @@ function registerModalLifecycleHandler(params) {
 			body: typedBody,
 			eventScope,
 			teamId: args.context.teamId,
-			interactionType: params.interactionType,
-			contextPrefix: params.contextPrefix,
-			summarizeViewState: params.summarizeViewState,
-			formatSystemEvent: params.formatSystemEvent
+			interactionType: params.interactionType
 		});
 	});
 }
@@ -5113,12 +5071,11 @@ function registerSlackShortcutHandler(params) {
 		const { ack, body } = args;
 		await ack();
 		const runtimeContext = await params.ctx.readRuntimeContext();
-		const eventScope = resolveSlackListenerEventScope$1({
-			identity: runtimeContext.installationIdentity,
+		const eventScope = resolveSlackMonitorEventScope({
+			ctx: runtimeContext,
 			body,
 			context: args.context,
 			client: args.client,
-			clientOptions: runtimeContext.app.webClientOptions,
 			onDrop: (reason) => runtimeContext.runtime.log?.(`slack:interaction drop shortcut ${reason}`)
 		});
 		if (eventScope === null) return;
@@ -5195,7 +5152,7 @@ function registerSlackShortcutHandler(params) {
 			body.action_ts
 		].filter(Boolean).join(":");
 		runtimeContext.runtime.log?.(`slack:interaction ${interactionType} callback=${callbackId} user=${userId} channel=${channelId ?? "direct"}`);
-		enqueueSlackInteractionEvent(params.formatSystemEvent(eventPayload), route, {
+		enqueueSlackInteractionEvent(eventPayload, route, {
 			contextKey,
 			deliveryContext: {
 				channel: "slack",
@@ -5208,152 +5165,47 @@ function registerSlackShortcutHandler(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/interactions.ts
-const SLACK_INTERACTION_EVENT_PREFIX = "Slack interaction: ";
-const REDACTED_INTERACTION_VALUE = "[redacted]";
-const SLACK_INTERACTION_EVENT_MAX_CHARS = 2400;
-const SLACK_INTERACTION_STRING_MAX_CHARS = 160;
-const SLACK_INTERACTION_ARRAY_MAX_ITEMS = 64;
-const SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS = 3;
-const SLACK_INTERACTION_REDACTED_KEYS = /* @__PURE__ */ new Set([
-	"triggerId",
-	"responseUrl",
-	"workflowTriggerUrl",
-	"privateMetadata",
-	"viewHash"
-]);
-function sanitizeSlackInteractionPayloadValue(value, key) {
-	if (value === void 0) return;
-	if (key && SLACK_INTERACTION_REDACTED_KEYS.has(key)) {
-		if (typeof value !== "string" || value.trim().length === 0) return;
-		return REDACTED_INTERACTION_VALUE;
-	}
-	if (typeof value === "string") return truncateSlackText(value, SLACK_INTERACTION_STRING_MAX_CHARS);
-	if (Array.isArray(value)) {
-		const sanitized = value.slice(0, SLACK_INTERACTION_ARRAY_MAX_ITEMS).map((entry) => sanitizeSlackInteractionPayloadValue(entry)).filter((entry) => entry !== void 0);
-		if (value.length > SLACK_INTERACTION_ARRAY_MAX_ITEMS) sanitized.push(`…+${value.length - SLACK_INTERACTION_ARRAY_MAX_ITEMS} more`);
-		return sanitized;
-	}
-	if (!value || typeof value !== "object") return value;
-	const output = {};
-	for (const [entryKey, entryValue] of Object.entries(value)) {
-		const sanitized = sanitizeSlackInteractionPayloadValue(entryValue, entryKey);
-		if (sanitized === void 0) continue;
-		if (typeof sanitized === "string" && sanitized.length === 0) continue;
-		if (Array.isArray(sanitized) && sanitized.length === 0) continue;
-		output[entryKey] = sanitized;
-	}
-	return output;
-}
-function buildCompactSlackInteractionPayload(payload) {
-	const rawInputs = Array.isArray(payload.inputs) ? payload.inputs : [];
-	const compactInputs = rawInputs.slice(0, SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS).flatMap((entry) => {
-		if (!entry || typeof entry !== "object") return [];
-		const typed = entry;
-		return [{
-			actionId: typed.actionId,
-			blockId: typed.blockId,
-			actionType: typed.actionType,
-			inputKind: typed.inputKind,
-			selectedValues: typed.selectedValues,
-			selectedLabels: typed.selectedLabels,
-			inputValue: typed.inputValue,
-			inputNumber: typed.inputNumber,
-			selectedDate: typed.selectedDate,
-			selectedTime: typed.selectedTime,
-			selectedDateTime: typed.selectedDateTime,
-			richTextPreview: typed.richTextPreview
-		}];
-	});
-	return {
-		interactionType: payload.interactionType,
-		actionId: payload.actionId,
-		callbackId: payload.callbackId,
-		actionType: payload.actionType,
-		actionTs: payload.actionTs,
-		userId: payload.userId,
-		teamId: payload.teamId,
-		channelId: payload.channelId ?? payload.routedChannelId,
-		messageTs: payload.messageTs,
-		threadTs: payload.threadTs,
-		messageUserId: payload.messageUserId,
-		messageText: payload.messageText,
-		viewId: payload.viewId,
-		isCleared: payload.isCleared,
-		selectedValues: payload.selectedValues,
-		selectedLabels: payload.selectedLabels,
-		selectedDate: payload.selectedDate,
-		selectedTime: payload.selectedTime,
-		selectedDateTime: payload.selectedDateTime,
-		workflowId: payload.workflowId,
-		routedChannelType: payload.routedChannelType,
-		pluginHandled: payload.pluginHandled,
-		pluginNamespace: payload.pluginNamespace,
-		pluginDuplicate: payload.pluginDuplicate,
-		pluginSystemEvent: payload.pluginSystemEvent,
-		inputs: compactInputs.length > 0 ? compactInputs : void 0,
-		inputsOmitted: rawInputs.length > SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS ? rawInputs.length - SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS : void 0,
-		payloadTruncated: true
-	};
-}
-function formatSlackInteractionSystemEvent(payload) {
-	const toEventText = (value) => `${SLACK_INTERACTION_EVENT_PREFIX}${JSON.stringify(value)}`;
-	const sanitizedPayload = sanitizeSlackInteractionPayloadValue(payload) ?? {};
-	let eventText = toEventText(sanitizedPayload);
-	if (eventText.length <= SLACK_INTERACTION_EVENT_MAX_CHARS) return eventText;
-	eventText = toEventText(sanitizeSlackInteractionPayloadValue(buildCompactSlackInteractionPayload(sanitizedPayload)));
-	if (eventText.length <= SLACK_INTERACTION_EVENT_MAX_CHARS) return eventText;
-	return toEventText({
-		interactionType: sanitizedPayload.interactionType,
-		actionId: sanitizedPayload.actionId ?? "unknown",
-		userId: sanitizedPayload.userId,
-		channelId: sanitizedPayload.channelId ?? sanitizedPayload.routedChannelId,
-		payloadTruncated: true
-	});
-}
-function summarizeViewState(values) {
-	if (!values || typeof values !== "object") return [];
-	const entries = [];
-	for (const [blockId, blockValue] of Object.entries(values)) {
-		if (!blockValue || typeof blockValue !== "object") continue;
-		for (const [actionId, rawAction] of Object.entries(blockValue)) {
-			if (!rawAction || typeof rawAction !== "object") continue;
-			const actionSummary = summarizeAction(rawAction);
-			entries.push({
-				blockId,
-				actionId,
-				...actionSummary
-			});
-		}
-	}
-	return entries;
-}
 function registerSlackInteractionEvents(params) {
 	const { ctx, trackEvent } = params;
-	registerSlackBlockActionHandler({
-		ctx,
-		trackEvent,
-		formatSystemEvent: formatSlackInteractionSystemEvent
-	});
-	registerSlackShortcutHandler({
+	registerSlackBlockActionHandler(params);
+	registerSlackShortcutHandler(params);
+	if (typeof ctx.app.view !== "function") return;
+	for (const interactionType of ["view_submission", "view_closed"]) registerModalLifecycleHandler({
 		ctx,
 		trackEvent,
-		formatSystemEvent: formatSlackInteractionSystemEvent
+		interactionType
 	});
-	if (typeof ctx.app.view !== "function") return;
-	const modalMatcher = /.*/;
-	for (const [interactionType, contextPrefix] of [["view_submission", "slack:interaction:view"], ["view_closed", "slack:interaction:view-closed"]]) registerModalLifecycleHandler({
-		register: (matcher, handler) => ctx.app.view({
-			callback_id: matcher,
-			type: interactionType
-		}, handler),
-		matcher: modalMatcher,
+}
+//#endregion
+//#region extensions/slack/src/monitor/events/system-event-context.ts
+async function authorizeAndResolveSlackSystemEventContext(params) {
+	const { senderId, channelId, channelType, eventKind } = params;
+	const ctx = await params.ctx.readRuntimeContext();
+	const auth = await authorizeSlackSystemEventSender({
 		ctx,
-		trackEvent,
-		interactionType,
-		contextPrefix,
-		summarizeViewState,
-		formatSystemEvent: formatSlackInteractionSystemEvent
+		senderId,
+		channelId,
+		channelType,
+		eventScope: params.eventScope,
+		retryNameLookup: eventKind.startsWith("member-")
 	});
+	if (!auth.allowed) {
+		logVerbose(`slack: drop ${eventKind} sender ${senderId ?? "unknown"} channel=${channelId ?? "unknown"} reason=${auth.reason ?? "unauthorized"}`);
+		return;
+	}
+	return {
+		channelLabel: resolveSlackChannelLabel({
+			channelId,
+			channelName: auth.channelName
+		}),
+		route: ctx.resolveSlackSystemEventRoute({
+			channelId,
+			channelType: auth.channelType,
+			senderId,
+			threadTs: auth.channelType === "im" ? void 0 : params.threadTs,
+			eventScope: params.eventScope
+		})
+	};
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/members.ts
@@ -5364,7 +5216,7 @@ function registerSlackMemberEvents(params) {
 		const eventId = body.event_id;
 		try {
 			const runtimeContext = await params.ctx.readRuntimeContext();
-			const eventScope = resolveSlackListenerEventScope({
+			const eventScope = resolveSlackMonitorEventScope({
 				ctx: runtimeContext,
 				body,
 				context,
@@ -5497,51 +5349,28 @@ function noteSlackDraftConversationMessage(conversation) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/message-subtype-handlers.ts
-function resolveNestedThreadTs(event) {
-	const changed = event;
-	const message = changed.message?.thread_ts ? changed.message : changed.previous_message;
-	if (!message) return;
-	return resolveSlackThreadContext({
-		message: {
-			type: "message",
-			channel: event.channel,
-			...message
-		},
-		replyToMode: "off"
-	}).replyToId;
-}
-const SUBTYPE_HANDLER_REGISTRY = {
-	message_changed: {
-		eventKind: "message_changed",
-		describe: (channelLabel) => `Slack message edited in ${channelLabel}.`,
-		contextKey: (event) => {
-			const changed = event;
-			return `slack:message:changed:${changed.channel ?? "unknown"}:${changed.message?.ts ?? changed.previous_message?.ts ?? changed.event_ts ?? "unknown"}`;
-		},
-		resolveSenderId: (event) => {
-			const changed = event;
-			return changed.message?.user ?? changed.previous_message?.user ?? changed.message?.bot_id ?? changed.previous_message?.bot_id;
-		},
-		resolveThreadTs: resolveNestedThreadTs
-	},
-	message_deleted: {
-		eventKind: "message_deleted",
-		describe: (channelLabel) => `Slack message deleted in ${channelLabel}.`,
-		contextKey: (event) => {
-			const deleted = event;
-			return `slack:message:deleted:${deleted.channel ?? "unknown"}:${deleted.deleted_ts ?? deleted.event_ts ?? "unknown"}`;
-		},
-		resolveSenderId: (event) => {
-			const deleted = event;
-			return deleted.previous_message?.user ?? deleted.previous_message?.bot_id;
-		},
-		resolveThreadTs: resolveNestedThreadTs
-	}
-};
 function resolveSlackMessageSubtypeHandler(event) {
 	const subtype = event.subtype;
 	if (subtype !== "message_changed" && subtype !== "message_deleted") return;
-	return SUBTYPE_HANDLER_REGISTRY[subtype];
+	const changed = event;
+	const message = changed.message?.thread_ts ? changed.message : changed.previous_message;
+	const isChanged = subtype === "message_changed";
+	const senderId = isChanged ? changed.message?.user ?? changed.previous_message?.user ?? changed.message?.bot_id ?? changed.previous_message?.bot_id : changed.previous_message?.user ?? changed.previous_message?.bot_id;
+	const messageId = isChanged ? changed.message?.ts ?? changed.previous_message?.ts ?? changed.event_ts : event.deleted_ts ?? event.event_ts;
+	return {
+		eventKind: subtype,
+		describe: (channelLabel) => `Slack message ${isChanged ? "edited" : "deleted"} in ${channelLabel}.`,
+		contextKey: `slack:message:${isChanged ? "changed" : "deleted"}:${event.channel ?? "unknown"}:${messageId ?? "unknown"}`,
+		senderId,
+		threadTs: message ? resolveSlackThreadContext({
+			message: {
+				type: "message",
+				channel: event.channel,
+				...message
+			},
+			replyToMode: "off"
+		}).replyToId : void 0
+	};
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/messages.ts
@@ -5551,11 +5380,17 @@ function isBotAuthoredEnterpriseEvent(event) {
 }
 async function resolveSlackAppMentionChannelType(params) {
 	const explicitType = normalizeOptionalString(params.mention.channel_type);
-	if (explicitType) return normalizeSlackChannelType(explicitType, params.mention.channel);
+	if (explicitType) return { type: normalizeSlackChannelType(explicitType, params.mention.channel) };
 	const rememberedType = params.ctx.recallSlackChannelType(params.mention.channel, params.eventScope);
-	if (rememberedType) return normalizeSlackChannelType(rememberedType, params.mention.channel);
-	const resolved = await params.ctx.resolveChannelName(params.mention.channel, params.eventScope).catch(() => ({ type: void 0 }));
-	return resolved.type ? normalizeSlackChannelType(resolved.type, params.mention.channel) : void 0;
+	if (rememberedType) return { type: normalizeSlackChannelType(rememberedType, params.mention.channel) };
+	const resolved = await params.ctx.resolveChannelName(params.mention.channel, params.eventScope).catch(() => ({
+		type: void 0,
+		lookupFailureCategory: "other"
+	}));
+	return {
+		type: resolved.type ? normalizeSlackChannelType(resolved.type, params.mention.channel) : void 0,
+		lookupFailureCategory: resolved.lookupFailureCategory
+	};
 }
 function resolveAssistantMessageChangedSender(params) {
 	const payload = asOptionalRecord(asOptionalRecord(params.message?.metadata)?.event_payload);
@@ -5614,14 +5449,6 @@ function resolveAssistantMessageChangedInbound(params) {
 }
 function registerSlackMessageEvents(params) {
 	const { ctx, handleSlackMessage } = params;
-	const resolveEventScope = (args) => resolveSlackListenerEventScope$1({
-		identity: ctx.installationIdentity,
-		body: args.body,
-		context: args.context,
-		client: args.client,
-		clientOptions: ctx.app.webClientOptions,
-		onDrop: (reason) => logVerbose(`slack: drop event (${reason})`)
-	});
 	const noteConversationMessage = (message, eventScope) => {
 		noteSlackDraftConversationMessage({
 			accountId: ctx.accountId,
@@ -5635,96 +5462,82 @@ function registerSlackMessageEvents(params) {
 			subtype: "subtype" in message ? normalizeOptionalString(message.subtype) : void 0
 		});
 	};
-	const handleIncomingMessageEvent = async ({ event, body, context, client }) => {
+	for (const source of ["message", "app_mention"]) ctx.app.event(source, async ({ event, body, context, client }) => {
 		const turnAdoptionLifecycle = resolveSlackIngressTurnLifecycle(context);
 		try {
-			const eventScope = resolveEventScope({
+			const eventScope = resolveSlackMonitorEventScope({
+				ctx,
 				body,
 				context,
-				client
+				client,
+				onDrop: (reason) => logVerbose(`slack: drop event (${reason})`)
 			});
-			if (eventScope === null) return;
-			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			if (eventScope === null || ctx.shouldDropMismatchedSlackEvent(body)) return;
 			const message = event;
-			ctx.rememberSlackChannelType(message.channel, message.channel_type, eventScope);
-			const assistantChangedInbound = resolveAssistantMessageChangedInbound({
-				event: message,
-				ctx
-			});
-			if (!assistantChangedInbound && message.subtype === "message_changed" && isSelfAttributedMessageChange({
-				event: message,
-				message: asOptionalRecord(message.message),
-				ctx
-			})) return;
-			const subtypeHandler = assistantChangedInbound ? void 0 : resolveSlackMessageSubtypeHandler(message);
-			if (subtypeHandler) {
-				const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+			let assistantChangedInbound;
+			if (source === "message") {
+				ctx.rememberSlackChannelType(message.channel, message.channel_type, eventScope);
+				assistantChangedInbound = resolveAssistantMessageChangedInbound({
+					event: message,
+					ctx
+				});
+				if (!assistantChangedInbound && message.subtype === "message_changed" && isSelfAttributedMessageChange({
+					event: message,
+					message: asOptionalRecord(message.message),
+					ctx
+				})) return;
+				const subtypeHandler = assistantChangedInbound ? void 0 : resolveSlackMessageSubtypeHandler(message);
+				if (subtypeHandler) {
+					const ingressContext = await authorizeAndResolveSlackSystemEventContext({
+						ctx,
+						senderId: subtypeHandler.senderId,
+						channelId: message.channel,
+						threadTs: subtypeHandler.threadTs,
+						eventKind: subtypeHandler.eventKind,
+						eventScope
+					});
+					if (!ingressContext) return;
+					enqueueRoutedSystemEvent(subtypeHandler.describe(ingressContext.channelLabel), ingressContext.route, { contextKey: `${subtypeHandler.contextKey}:${body.event_id}` });
+					return;
+				}
+			} else {
+				const mention = event;
+				if (eventScope && isBotAuthoredEnterpriseEvent(mention)) {
+					logVerbose("slack: drop enterprise bot-authored app_mention");
+					return;
+				}
+				const { type: channelType, lookupFailureCategory } = await resolveSlackAppMentionChannelType({
 					ctx,
-					senderId: subtypeHandler.resolveSenderId(message),
-					channelId: message.channel,
-					threadTs: subtypeHandler.resolveThreadTs(message),
-					eventKind: subtypeHandler.eventKind,
+					mention,
 					eventScope
 				});
-				if (!ingressContext) return;
-				enqueueRoutedSystemEvent(subtypeHandler.describe(ingressContext.channelLabel), ingressContext.route, { contextKey: `${subtypeHandler.contextKey(message)}:${body.event_id}` });
-				return;
+				if (!channelType) {
+					const channelId = /^[CDG][A-Z0-9]{1,32}$/.test(mention.channel) ? mention.channel : "unrecognized";
+					const category = lookupFailureCategory ?? "missing_type";
+					slackInboundLog.info(`Slack app_mention skipped: conversation type unresolved; channelId=${channelId} lookupFailureCategory=${category}; waiting for message event`, {
+						channelId,
+						lookupFailureCategory: category
+					});
+					return;
+				}
+				if (channelType === "im" || channelType === "mpim") return;
+				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)`);
 			}
 			const inbound = assistantChangedInbound ?? message;
 			noteConversationMessage(inbound, eventScope);
 			await handleSlackMessage(inbound, {
-				source: "message",
+				source,
 				senderAuthentication: assistantChangedInbound ? void 0 : resolveSlackSenderAuthentication(context),
+				...source === "app_mention" ? { wasMentioned: true } : {},
 				eventScope,
 				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
 				...eventScope || turnAdoptionLifecycle ? { awaitDispatch: true } : {}
 			});
 		} catch (err) {
 			if (turnAdoptionLifecycle) throw err;
-			ctx.runtime.error?.(danger(`slack handler failed: ${formatErrorMessage(err)}`));
-		}
-	};
-	ctx.app.event("message", handleIncomingMessageEvent);
-	ctx.app.event("app_mention", async (args) => {
-		const { event, body, context, client } = args;
-		const turnAdoptionLifecycle = resolveSlackIngressTurnLifecycle(context);
-		try {
-			const eventScope = resolveEventScope({
-				body,
-				context,
-				client
-			});
-			if (eventScope === null) return;
-			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
-			const mention = event;
-			if (eventScope && isBotAuthoredEnterpriseEvent(mention)) {
-				logVerbose("slack: drop enterprise bot-authored app_mention");
-				return;
-			}
-			const channelType = await resolveSlackAppMentionChannelType({
-				ctx,
-				mention,
-				eventScope
-			});
-			if (!channelType) {
-				logVerbose(`slack: drop typeless app_mention channel=${mention.channel} (conversation type unresolved; waiting for message event)`);
-				return;
-			}
-			if (channelType === "im" || channelType === "mpim") return;
-			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",
-				senderAuthentication: resolveSlackSenderAuthentication(context),
-				wasMentioned: true,
-				eventScope,
-				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
-				...eventScope || turnAdoptionLifecycle ? { awaitDispatch: true } : {}
-			});
-		} catch (err) {
-			if (turnAdoptionLifecycle) throw err;
-			ctx.runtime.error?.(danger(`slack mention handler failed: ${formatErrorMessage(err)}`));
+			const handler = source === "app_mention" ? "mention handler" : "handler";
+			ctx.runtime.error?.(danger(`slack ${handler} failed: ${formatErrorMessage(err)}`));
 		}
 	});
 }
@@ -5737,7 +5550,7 @@ function registerSlackPinEvents(params) {
 		ctx.app.event(`pin_${contextKeySuffix}`, async (args) => {
 			const { event, body, context, client } = args;
 			try {
-				const eventScope = resolveSlackListenerEventScope({
+				const eventScope = resolveSlackMonitorEventScope({
 					ctx,
 					body,
 					context,
@@ -5791,7 +5604,7 @@ function registerSlackReactionEvents(params) {
 	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({
+		const eventScope = resolveSlackMonitorEventScope({
 			ctx,
 			body,
 			context,
@@ -5987,7 +5800,7 @@ function buildSlackDebounceKey(message, accountId, teamId) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-CIepKmZt.mjs"));
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-ByPbC6MN.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;
@@ -6345,14 +6158,26 @@ function createSlackPresenceMonitor(params) {
 	const scheduler = params.scheduler.scope();
 	let started = false;
 	const rateLimitedUntilByWorkspace = /* @__PURE__ */ new Map();
+	const collectEligibleSubjects = () => {
+		const subjects = /* @__PURE__ */ new Map();
+		for (const target of targets.values()) {
+			if (!isTargetEligible(target)) continue;
+			for (const userId of target.participants.keys()) {
+				const subject = {
+					teamId: target.teamId,
+					userId
+				};
+				subjects.set(presenceSubjectKey(subject), subject);
+			}
+		}
+		return subjects;
+	};
 	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);
-		const eligibleUsers = new Set(Array.from(targets.values()).filter(isTargetEligible).flatMap((target) => Array.from(target.participants.keys()).map((userId) => presenceSubjectKey({
-			teamId: target.teamId,
-			userId
-		}))));
-		for (const userId of presenceByUser.keys()) if (!eligibleUsers.has(userId)) presenceByUser.delete(userId);
+		const eligibleSubjects = collectEligibleSubjects();
+		for (const userId of presenceByUser.keys()) if (!eligibleSubjects.has(userId)) presenceByUser.delete(userId);
+		return eligibleSubjects;
 	};
 	const observe = (prepared) => {
 		const now = nowMs();
@@ -6425,19 +6250,7 @@ function createSlackPresenceMonitor(params) {
 	};
 	const performPoll = async () => {
 		const now = nowMs();
-		pruneTargets(now);
-		const candidatesByKey = /* @__PURE__ */ new Map();
-		for (const target of targets.values()) {
-			if (!isTargetEligible(target)) continue;
-			for (const userId of target.participants.keys()) {
-				const subject = {
-					teamId: target.teamId,
-					userId
-				};
-				candidatesByKey.set(presenceSubjectKey(subject), subject);
-			}
-		}
-		const candidates = Array.from(candidatesByKey.entries()).toSorted(([left], [right]) => left.localeCompare(right)).map(([, subject]) => subject);
+		const candidates = Array.from(pruneTargets(now).entries()).toSorted(([left], [right]) => left.localeCompare(right)).map(([, subject]) => subject);
 		if (candidates.length === 0) return;
 		const count = Math.min(candidates.length, SLACK_PRESENCE_MAX_POLLS_PER_INTERVAL);
 		const selected = Array.from({ length: count }, (_, index) => candidates[(pollOffset + index) % candidates.length]).filter((subject) => Boolean(subject));
@@ -6532,7 +6345,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-CC3h6M7y.mjs"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-CVfH-fBO.mjs"));
 function resolveSlackRuntimeIdentity(params) {
 	const botUserId = normalizeOptionalString(params.botUserId);
 	const botId = normalizeOptionalString(params.botId);
@@ -6832,8 +6645,7 @@ async function monitorSlackProvider(opts) {
 	const appHomeSlashCommandName = commandRegistration.mode === "single" ? commandRegistration.name : void 0;
 	let workspaceRuntimePromise;
 	const installSlackWorkspaceRuntime = async () => {
-		if (workspaceRuntimePromise) return await workspaceRuntimePromise;
-		workspaceRuntimePromise = (async () => {
+		workspaceRuntimePromise ??= (async () => {
 			registerSlackWorkspaceEvents({
 				ctx,
 				appHomeSlashCommandName,
@@ -6931,63 +6743,60 @@ async function monitorSlackProvider(opts) {
 		if (slackMode === "socket") {
 			let reconnectAttempts = 0;
 			let hasLoggedSocketConnected = false;
-			while (!opts.abortSignal?.aborted) try {
-				const disconnect = await startSlackSocketAndWaitForDisconnect({
-					app,
-					abortSignal: opts.abortSignal,
-					onStarted: async () => {
-						reconnectAttempts = 0;
-						await recoverSlackIdentity();
-						publishSlackConnectedStatus(opts.setStatus, ctx.identityHealth);
-						if (!hasLoggedSocketConnected) {
-							hasLoggedSocketConnected = true;
-							runtime.log?.(ctx.identityHealth.lifecycle === "blocked" ? "slack socket mode connected (degraded identity)" : "slack socket mode connected");
+			while (!opts.abortSignal?.aborted) {
+				let delayMs;
+				try {
+					const disconnect = await startSlackSocketAndWaitForDisconnect({
+						app,
+						abortSignal: opts.abortSignal,
+						onStarted: async () => {
+							reconnectAttempts = 0;
+							await recoverSlackIdentity();
+							publishSlackConnectedStatus(opts.setStatus, ctx.identityHealth);
+							if (!hasLoggedSocketConnected) {
+								hasLoggedSocketConnected = true;
+								runtime.log?.(ctx.identityHealth.lifecycle === "blocked" ? "slack socket mode connected (degraded identity)" : "slack socket mode connected");
+							}
 						}
+					});
+					if (!disconnect) break;
+					if (opts.abortSignal?.aborted) break;
+					publishSlackDisconnectedStatus(opts.setStatus, disconnect.error);
+					if (disconnect.error && isNonRecoverableSlackAuthError(disconnect.error)) {
+						publishSlackBlockedStatus(opts.setStatus, disconnect.error);
+						runtime.error?.(`slack socket mode disconnected due to non-recoverable auth error — skipping channel (${formatSlackError(disconnect.error)})`);
+						throw disconnect.error instanceof Error ? disconnect.error : new Error(formatSlackError(disconnect.error));
 					}
-				});
-				if (!disconnect) break;
-				if (opts.abortSignal?.aborted) break;
-				publishSlackDisconnectedStatus(opts.setStatus, disconnect.error);
-				if (disconnect.error && isNonRecoverableSlackAuthError(disconnect.error)) {
-					publishSlackBlockedStatus(opts.setStatus, disconnect.error);
-					runtime.error?.(`slack socket mode disconnected due to non-recoverable auth error — skipping channel (${formatSlackError(disconnect.error)})`);
-					throw disconnect.error instanceof Error ? disconnect.error : new Error(formatSlackError(disconnect.error));
-				}
-				reconnectAttempts += 1;
-				const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
-				runtime.log?.(warn(formatSlackSocketReconnectMessage({
-					event: disconnect.event,
-					attempt: reconnectAttempts,
-					delayMs,
-					error: disconnect.error
-				})));
-				await gracefulStopSlackApp(app);
-				try {
-					await sleepWithAbort(delayMs, opts.abortSignal);
-				} catch {
-					break;
-				}
-			} catch (err) {
-				if (isNonRecoverableSlackAuthError(err)) {
-					publishSlackBlockedStatus(opts.setStatus, err);
-					runtime.error?.(`slack socket mode failed to start due to non-recoverable auth error — skipping channel (${formatSlackError(err)})`);
-					throw err;
+					reconnectAttempts += 1;
+					delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+					runtime.log?.(warn(formatSlackSocketReconnectMessage({
+						event: disconnect.event,
+						attempt: reconnectAttempts,
+						delayMs,
+						error: disconnect.error
+					})));
+					await gracefulStopSlackApp(app);
+				} catch (err) {
+					if (isNonRecoverableSlackAuthError(err)) {
+						publishSlackBlockedStatus(opts.setStatus, err);
+						runtime.error?.(`slack socket mode failed to start due to non-recoverable auth error — skipping channel (${formatSlackError(err)})`);
+						throw err;
+					}
+					publishSlackDisconnectedStatus(opts.setStatus, err);
+					reconnectAttempts += 1;
+					delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+					runtime.error?.(formatSlackSocketStartRetryMessage({
+						attempt: reconnectAttempts,
+						delayMs,
+						error: err,
+						sdkContext: socketModeLogger.getLastMessage()
+					}));
 				}
-				publishSlackDisconnectedStatus(opts.setStatus, err);
-				reconnectAttempts += 1;
-				const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
-				runtime.error?.(formatSlackSocketStartRetryMessage({
-					attempt: reconnectAttempts,
-					delayMs,
-					error: err,
-					sdkContext: socketModeLogger.getLastMessage()
-				}));
 				try {
 					await sleepWithAbort(delayMs, opts.abortSignal);
 				} catch {
 					break;
 				}
-				continue;
 			}
 		} else if (slackMode === "relay" && relayConfig) {
 			const relaySource = await loadSlackRelaySource();
@@ -7030,8 +6839,7 @@ async function monitorSlackProvider(opts) {
 function createSlackWorkspaceClientResolver(params) {
 	if (params.installationIdentity.kind !== "enterprise") return () => params.appClient;
 	const clients = /* @__PURE__ */ new Map();
-	return (rawTeamId) => {
-		const teamId = rawTeamId;
+	return (teamId) => {
 		if (!teamId || !/^T[A-Z0-9]+$/.test(teamId)) throw new Error("Slack Enterprise Grid workspace client requires a valid teamId");
 		const cached = clients.get(teamId);
 		if (cached) return cached;