@openclaw/slack 2026.8.1-beta.3 → 2026.8.2

package/dist/{provider-CUUiwsg2.js → provider-DW9YC_no.js}

@@ -1,15 +1,15 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as formatSlackBotTokenIdentityWarning } from "./accounts-BlzxuYle.js";
-import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { At as isSlackApprovalAuthorizedSender, J as truncateSlackText, Mt as isSlackExecApprovalAuthorizedSender, Ot as registerSlackInstallationState, U as SLACK_TEXT_LIMIT, a as qualifySlackConversationId, at as decodeSlackQuestionAction, c as allowListMatches, ct as escapeSlackMrkdwn, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, gt as isSlackAnyNativeApprovalClientEnabled, l as normalizeAllowList, m as resolveSlackUserAllowListForTeam, nt as isSlackCallbackActionId, o as qualifySlackRoutePeerId, ot as resolveSlackQuestionAction, p as resolveSlackAllowListMatch, rt as isSlackQuestionActionId, s as resolveSlackEnterpriseMainDmSessionKey, t as buildSlackChannelIdCandidates, tt as isSlackApprovalActionId, u as normalizeAllowListLower, ut as decodeSlackApprovalAction } from "./group-policy-DyfB_ZIE.js";
-import { c as createSlackWebClient, g as resolveSlackWebClientOptions, h as resolveSlackProxyDispatcher, m as resolveSlackLookupClientOptions, o as createSlackStartupAuthClient, r as formatSlackError, u as getSlackListenerUploadCompletionClient } from "./probe-BVA65leh.js";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as formatSlackBotTokenIdentityWarning } from "./accounts-Dm_H77gH.js";
+import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-PbxGDbr9.js";
+import { Ct as isSlackApprovalAuthorizedSender, G as isSlackCallbackActionId, J as decodeSlackQuestionAction, K as isSlackQuestionActionId, L as truncateSlackText, M as SLACK_TEXT_LIMIT, Tt as isSlackExecApprovalAuthorizedSender, W as isSlackApprovalActionId, Y as resolveSlackQuestionAction, a as qualifySlackConversationId, et as escapeSlackMrkdwn, lt as isSlackAnyNativeApprovalClientEnabled, nt as decodeSlackApprovalAction, o as qualifySlackRoutePeerId, s as resolveSlackEnterpriseMainDmSessionKey, t as buildSlackChannelIdCandidates, xt as registerSlackInstallationState } from "./group-policy-BYH74y50.js";
+import { C as normalizeAllowListLower, D as resolveSlackUserAllowListForTeam, E as resolveSlackAllowListMatch, S as normalizeAllowList, T as normalizeSlackSlug, _ as resolveSlackLookupClientOptions, a as slackIngressIdentity, d as createSlackWebClient, i as createSlackIngressSubject, l as createSlackStartupAuthClient, o as formatSlackError, p as getSlackListenerUploadCompletionClient, v as resolveSlackProxyDispatcher, w as normalizeSlackAllowOwnerEntry, x as allowListMatches, y as resolveSlackWebClientOptions } from "./probe-gj5yQgN2.js";
 import { n as getSlackRuntime, t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { i as hasSlackMessageTableBlock, r as saveRemoteMedia, t as isGovSlackClient } from "./slack-client-kind-BXyOOICI.js";
-import { i as setSlackDefaultSendIdentity, p as requireSlackPostMessageTimestamp } from "./send-CtnOxKCc.js";
+import { C as hasSlackMessageTableBlock, b as saveRemoteMedia, f as readSlackMessages, y as isGovSlackClient } from "./actions-BOxiu2Vy.js";
+import { i as setSlackDefaultSendIdentity, p as requireSlackPostMessageTimestamp } from "./send-GUz4_v2E.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-BSpqC8jU.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-Dvz9pDe0.js";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-BKXSxrIS.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Bv6IiGZ4.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-BXw2pA7y.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-CUpBeOt9.js";
 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";
@@ -20,12 +20,13 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { computeBackoff, createNonExitingRuntime, createSubsystemLogger, danger, getChildLogger, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { chunkItems } from "openclaw/plugin-sdk/text-chunking";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
 import { parseExecApprovalCommandText } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { WebAPIHTTPError, WebAPIPlatformError, WebAPIRateLimitedError, WebAPIRequestError, WebClient } from "@slack/web-api";
-import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
 import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, resolveConversationLabel as resolveConversationLabel$1, resolvePluginConversationBindingApproval, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
+import { createChannelIngressResolver, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, isApprovalNotFoundError, readErrorName, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { buildChannelMetadata } from "openclaw/plugin-sdk/security-runtime";
@@ -44,12 +45,12 @@ import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy as res
 import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
 import { mutateConfigFile, readConfigFileSnapshotForWrite } from "openclaw/plugin-sdk/config-mutation";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 import { formatCommandArgMenuTitle, resolveCommandAuthorization, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride } from "openclaw/plugin-sdk/command-auth-native";
 import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
 import { createChannelInteractiveDispatcher } from "openclaw/plugin-sdk/plugin-runtime";
+import { reportChannelRoomJoin } from "openclaw/plugin-sdk/channel-join-intro-runtime";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { createChannelReplayGuard, runClaimableDedupeClaimLoop } from "openclaw/plugin-sdk/persistent-dedupe";
 import { channelBlockedPatch, channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
@@ -236,8 +237,8 @@ function createSlackAgentViewState(params) {
 //#endregion
 //#region extensions/slack/src/monitor/assistant-thread-context.ts
 const SLACK_ASSISTANT_THREAD_CONTEXT_METADATA_EVENT = "assistant_thread_context";
-const SLACK_ASSISTANT_CONTEXT_TTL_MS = 1440 * 60 * 1e3;
-const SLACK_ASSISTANT_CONTEXT_CLEANUP_INTERVAL_MS = 600 * 1e3;
+const SLACK_ASSISTANT_CONTEXT_TTL_MS = 864e5;
+const SLACK_ASSISTANT_CONTEXT_CLEANUP_INTERVAL_MS = 6e5;
 function buildSlackAssistantThreadMetadata(context) {
 	const eventPayload = {};
 	if (context.channelId) eventPayload.channel_id = context.channelId;
@@ -476,12 +477,12 @@ function resolveSlackSystemEventRoute(params) {
 const SLACK_CHANNEL_CACHE_MAX_ENTRIES = 1024;
 const SLACK_USER_CACHE_MAX_ENTRIES = 2048;
 const SLACK_AVATAR_CACHE_MAX_ENTRIES = 128;
-const SLACK_AVATAR_MAX_BYTES = 256 * 1024;
+const SLACK_AVATAR_MAX_BYTES = 262144;
 const SLACK_AVATAR_SSRF_POLICY = {
 	allowedHostnames: ["avatars.slack-edge.com", "*.slack-edge.com"],
 	hostnameAllowlist: ["avatars.slack-edge.com", "*.slack-edge.com"]
 };
-const SLACK_CHANNEL_DENIAL_WARNING_TTL_MS = 5 * 6e4;
+const SLACK_CHANNEL_DENIAL_WARNING_TTL_MS = 3e5;
 const SLACK_CHANNEL_DENIAL_WARNING_MAX_ENTRIES = 1024;
 function createSlackMonitorContext(params) {
 	const channelHistories = /* @__PURE__ */ new Map();
@@ -586,7 +587,8 @@ function createSlackMonitorContext(params) {
 		}
 	};
 	const resolveUserAvatar = (userId, eventScope) => {
-		if (isGovSlackClient(eventScope?.client ?? params.app.client)) return;
+		const client = eventScope?.client ?? params.app.client;
+		if (isGovSlackClient(client)) return;
 		const imageUrl = readLruMapEntry(userCache, scopedKey(userId, eventScope))?.imageUrl;
 		if (!imageUrl) return;
 		const cacheKey = scopedKey(`${userId}\0${imageUrl}`, eventScope);
@@ -705,6 +707,7 @@ function createSlackMonitorContext(params) {
 		}
 		return false;
 	};
+	const channelRuntime = params.channelRuntime;
 	const ctx = {
 		cfg: params.cfg,
 		accountId: params.accountId,
@@ -712,7 +715,8 @@ function createSlackMonitorContext(params) {
 		app: params.app,
 		runtime: params.runtime,
 		channelRuntime: params.channelRuntime,
-		buildContext: params.channelRuntime?.inbound.buildContext,
+		buildContext: channelRuntime?.inbound.buildContext,
+		dispatchReplyFromConfig: channelRuntime?.reply?.dispatchReplyFromConfig,
 		botUserId: params.botUserId,
 		botId: params.botId,
 		identityHealth: params.identityHealth,
@@ -1278,6 +1282,8 @@ function resolveSlackIngressTurnLifecycle(context) {
 function createSlackDurableIngress(options) {
 	let app;
 	let relayDispatch;
+	const activeSessionTurns = /* @__PURE__ */ new Map();
+	const activeChannelTurns = /* @__PURE__ */ new Map();
 	const monitor = createChannelIngressMonitor({
 		queue: options.queue ?? (() => getSlackRuntime().state.openChannelIngressQueue({ accountId: options.accountId })),
 		inspect: inspectSlackIngress,
@@ -1314,26 +1320,111 @@ function createSlackDurableIngress(options) {
 		onDurableAdmission: async (raw) => {
 			if (raw.kind === "events-api") await raw.afterDurableAdmission?.();
 		},
-		deliver: async (raw, lifecycle) => {
-			if (raw.kind === "relay") {
-				if (!relayDispatch) throw new Error("Slack relay ingress dispatcher is not attached.");
-				await relayDispatch(raw.message, lifecycle);
-				return;
+		deliver: async (raw, lifecycle, claim) => {
+			const laneKey = claim.laneKey ?? inspectSlackIngress(raw).laneKey;
+			let releaseSession;
+			let releaseChannel;
+			let routedSession;
+			let adoptOnCompletion = false;
+			const settleSession = () => {
+				adoptOnCompletion = false;
+				releaseSession?.();
+			};
+			const settleTurn = () => {
+				settleSession();
+				releaseChannel?.();
+				lifecycle.abortSignal.removeEventListener("abort", settleTurn);
+			};
+			const routedLifecycle = {
+				...lifecycle,
+				onSessionRouted: async (sessionKey) => {
+					if (routedSession !== void 0) {
+						if (routedSession !== sessionKey) throw new Error("Slack ingress session ownership changed after routing.");
+						return;
+					}
+					lifecycle.abortSignal.throwIfAborted();
+					routedSession = sessionKey;
+					adoptOnCompletion = true;
+					const previousTurn = activeSessionTurns.get(sessionKey);
+					const releasedCurrentTurn = createDeferred();
+					const currentTurn = previousTurn ? previousTurn.then(() => releasedCurrentTurn.promise) : releasedCurrentTurn.promise;
+					activeSessionTurns.set(sessionKey, currentTurn);
+					const channelTurn = createDeferred();
+					const channelTurns = activeChannelTurns.get(laneKey) ?? /* @__PURE__ */ new Set();
+					channelTurns.add(channelTurn.promise);
+					activeChannelTurns.set(laneKey, channelTurns);
+					currentTurn.then(() => {
+						if (activeSessionTurns.get(sessionKey) === currentTurn) activeSessionTurns.delete(sessionKey);
+					});
+					channelTurn.promise.then(() => {
+						channelTurns.delete(channelTurn.promise);
+						if (channelTurns.size === 0 && activeChannelTurns.get(laneKey) === channelTurns) activeChannelTurns.delete(laneKey);
+					});
+					releaseSession = () => releasedCurrentTurn.resolve();
+					releaseChannel = () => channelTurn.resolve();
+					lifecycle.abortSignal.addEventListener("abort", settleTurn, { once: true });
+					lifecycle.onDeferred();
+					if (previousTurn) lifecycle.onAdoptionFinalizing();
+					monitor.requestDrain();
+					await previousTurn;
+					lifecycle.abortSignal.throwIfAborted();
+				},
+				onAdopted: async () => {
+					try {
+						await lifecycle.onAdopted();
+					} finally {
+						settleTurn();
+					}
+				},
+				onDeferred: () => {
+					lifecycle.onDeferred();
+					settleSession();
+					monitor.requestDrain();
+				},
+				onAbandoned: async () => {
+					try {
+						await lifecycle.onAbandoned();
+					} finally {
+						settleTurn();
+					}
+				}
+			};
+			try {
+				const event = raw.kind === "events-api" ? asOptionalRecord(raw.body)?.event : void 0;
+				if (asOptionalRecord(event)?.type === "channel_id_changed") {
+					const channelTurns = activeChannelTurns.get(laneKey);
+					if (channelTurns && channelTurns.size > 0) {
+						adoptOnCompletion = true;
+						lifecycle.onAdoptionFinalizing();
+						await Promise.all(channelTurns);
+						lifecycle.abortSignal.throwIfAborted();
+					}
+				}
+				if (raw.kind === "relay") {
+					if (!relayDispatch) throw new Error("Slack relay ingress dispatcher is not attached.");
+					await relayDispatch(raw.message, routedLifecycle);
+				} else {
+					if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
+					await app.processEvent({
+						body: raw.body,
+						ack: async () => {},
+						...raw.retryNum === void 0 ? {} : { retryNum: raw.retryNum },
+						...raw.retryReason === void 0 ? {} : { retryReason: raw.retryReason },
+						customProperties: { [SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY]: routedLifecycle }
+					});
+				}
+				if (adoptOnCompletion) await routedLifecycle.onAdopted();
+			} catch (error) {
+				settleTurn();
+				throw error;
 			}
-			if (!app) throw new Error("Slack ingress receiver is not attached to a Bolt app.");
-			await app.processEvent({
-				body: raw.body,
-				ack: async () => {},
-				...raw.retryNum === void 0 ? {} : { retryNum: raw.retryNum },
-				...raw.retryReason === void 0 ? {} : { retryReason: raw.retryReason },
-				customProperties: { [SLACK_INGRESS_LIFECYCLE_CONTEXT_KEY]: lifecycle }
-			});
 		},
 		pollIntervalMs: options.pollIntervalMs ?? SLACK_INGRESS_POLL_INTERVAL_MS,
 		retention: "standard",
 		appendRetryDelaysMs: [0],
 		drain: {
 			resolveNonRetryableFailure: resolveSlackIngressNonRetryableFailure,
+			deferredLaneOccupancy: "release",
 			deriveLaneKey: (record) => record.payload.kind === "relay" ? resolveSlackIngressLane({ event: record.payload.message }, record.id) : resolveSlackIngressLane(record.payload.body, record.id),
 			...options.adoptionStallTimeoutMs === void 0 ? {} : { adoptionStallTimeoutMs: options.adoptionStallTimeoutMs },
 			...options.onLog ? { onLog: options.onLog } : {}
@@ -1412,7 +1503,8 @@ async function resolveThreadTsFromHistory(params) {
 		inclusive: true,
 		limit: 1
 	});
-	return normalizeOptionalString((response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0])?.thread_ts);
+	const message = response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0];
+	return normalizeOptionalString(message?.thread_ts);
 }
 function createSlackThreadTsResolver(params) {
 	const ttlMs = Math.max(0, parseFiniteNumber(params.cacheTtlMs) ?? DEFAULT_THREAD_TS_CACHE_TTL_MS);
@@ -1498,88 +1590,7 @@ const slackChannelMembersCache = /* @__PURE__ */ new WeakMap();
 const DEFAULT_CHANNEL_MEMBERS_CACHE_TTL_MS = 6e4;
 const CHANNEL_MEMBERS_CACHE_MAX = 512;
 const SLACK_CHANNEL_ID = "slack";
-const SLACK_USER_NAME_KIND = "plugin:slack-user-name";
-const SLACK_WORKSPACE_USER_ID_KIND = "plugin:slack-workspace-user-id";
 var SlackSystemEventAuthRetryError = class extends Error {};
-function normalizeSlackUserId(raw) {
-	const value = (raw ?? "").trim().toLowerCase();
-	if (!value) return "";
-	const mention = value.match(/^<@([a-z0-9_]+)>$/i);
-	if (mention?.[1]) return mention[1];
-	return value.replace(/^(slack:|user:)/, "");
-}
-function isSlackStableUserId(value) {
-	return /^[ubw][a-z0-9_]+$/i.test(value);
-}
-function normalizeSlackWorkspaceUserEntry(entry) {
-	const normalized = entry.trim().toLowerCase();
-	if (!normalized) return null;
-	try {
-		const target = parseSlackTarget(normalized);
-		if (target?.kind === "user" && target.teamId) return target.normalized;
-	} catch {
-		return null;
-	}
-	return null;
-}
-function normalizeSlackBareUserEntry(entry) {
-	const normalized = entry.trim().toLowerCase();
-	if (!normalized || normalizeSlackWorkspaceUserEntry(normalized)) return null;
-	const userId = normalizeSlackUserId(normalized);
-	return isSlackStableUserId(userId) ? userId : null;
-}
-function normalizeSlackStableEntry(entry) {
-	return normalizeSlackBareUserEntry(entry) ?? normalizeSlackWorkspaceUserEntry(entry);
-}
-function normalizeSlackNameEntry(entry) {
-	const normalized = entry.trim().toLowerCase();
-	if (!normalized || normalizeSlackStableEntry(normalized)) return null;
-	return normalized.replace(/^slack:/, "") || null;
-}
-function normalizeSlackNameSubject(value) {
-	return value.trim().toLowerCase() || null;
-}
-function normalizeSlackNameSlugEntry(entry) {
-	const name = normalizeSlackNameEntry(entry);
-	if (!name) return null;
-	const slug = normalizeSlackSlug(name);
-	return slug && slug !== name ? slug : null;
-}
-const slackIngressIdentity = defineStableChannelIngressIdentity({
-	key: "senderId",
-	kind: "stable-id",
-	normalizeEntry: normalizeSlackBareUserEntry,
-	normalizeSubject: normalizeSlackUserId,
-	sensitivity: "pii",
-	aliases: [{
-		key: "workspaceSenderId",
-		kind: SLACK_WORKSPACE_USER_ID_KIND,
-		normalizeEntry: normalizeSlackWorkspaceUserEntry,
-		normalizeSubject: normalizeSlackWorkspaceUserEntry,
-		sensitivity: "pii"
-	}, ...[["senderName", normalizeSlackNameEntry], ["senderNameSlug", normalizeSlackNameSlugEntry]].map(([key, normalizeEntry]) => ({
-		key,
-		kind: SLACK_USER_NAME_KIND,
-		normalizeEntry,
-		normalizeSubject: normalizeSlackNameSubject,
-		dangerous: true,
-		sensitivity: "pii"
-	}))]
-});
-function createSlackIngressSubject(params) {
-	const senderId = normalizeSlackUserId(params.senderId);
-	const teamId = normalizeOptionalLowercaseString(params.teamId);
-	const senderName = params.senderName?.trim().toLowerCase();
-	const senderNameSlug = senderName ? normalizeSlackSlug(senderName) : void 0;
-	return {
-		stableId: senderId,
-		aliases: {
-			workspaceSenderId: teamId && senderId ? `team:${teamId}:user:${senderId}` : void 0,
-			senderName,
-			senderNameSlug
-		}
-	};
-}
 function createSlackIngressResolver(ctx) {
 	return createChannelIngressResolver({
 		channelId: SLACK_CHANNEL_ID,
@@ -1821,7 +1832,7 @@ async function decideSlackSystemIngress(params) {
 		} : void 0
 	};
 	const result = await resolver.message(input);
-	if (result.ingress.decision !== "allow" && params.retryNameLookup && result.state.allowlists[isDirectMessage ? "dm" : "group"].normalizedEntries.some((entry) => entry.kind === SLACK_USER_NAME_KIND)) {
+	if (result.ingress.decision !== "allow" && params.retryNameLookup && result.state.allowlists[isDirectMessage ? "dm" : "group"].normalizedEntries.some((entry) => entry.kind === "plugin:slack-user-name")) {
 		const lookup = await params.ctx.resolveUserName(params.senderId, params.eventScope);
 		if (lookup.error && isTransientSlackThreadLookupError(lookup.error)) throw new SlackSystemEventAuthRetryError(formatErrorMessage(lookup.error));
 		if (lookup.name) return (await resolver.message({
@@ -1949,7 +1960,8 @@ function resolveSlackEventScope(params) {
 		ok: false,
 		reason: "enterprise_event_for_workspace_account"
 	} : { ok: true };
-	const apiAppId = normalizeOptionalString((params.body && typeof params.body === "object" ? params.body : {}).api_app_id);
+	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"
@@ -2015,6 +2027,7 @@ async function authorizeAndResolveSlackSystemEventContext(params) {
 			channelId,
 			channelType: auth.channelType,
 			senderId,
+			threadTs: auth.channelType === "im" ? void 0 : params.threadTs,
 			eventScope: params.eventScope
 		})
 	};
@@ -2111,9 +2124,10 @@ function registerSlackChannelIdChangedEvent(params) {
 			const oldChannelId = payload.old_channel_id;
 			const newChannelId = payload.new_channel_id;
 			if (!oldChannelId || !newChannelId) return;
+			const channelInfo = await ctx.resolveChannelName(newChannelId);
 			const label = resolveSlackChannelLabel({
 				channelId: newChannelId,
-				channelName: (await ctx.resolveChannelName(newChannelId))?.name
+				channelName: channelInfo?.name
 			});
 			ctx.runtime.log?.(warn(`[slack] Channel ID changed: ${oldChannelId} → ${newChannelId} (${label})`));
 			if (!resolveChannelConfigWrites({
@@ -2366,7 +2380,8 @@ function isSlackReplyActionId(actionId) {
 	return actionId === "openclaw:reply_button" || actionId === "openclaw:reply_select" || actionId.startsWith(`openclaw:reply_button:`) || actionId.startsWith(`openclaw:reply_select:`);
 }
 function readSlackApprovalAction(parsed) {
-	return decodeSlackApprovalAction(normalizeOptionalString(parsed.actionSummary.value) ?? parsed.actionSummary.selectedValues?.map((entry) => normalizeOptionalString(entry)).find((entry) => Boolean(entry)));
+	const value = normalizeOptionalString(parsed.actionSummary.value) ?? parsed.actionSummary.selectedValues?.map((entry) => normalizeOptionalString(entry)).find((entry) => Boolean(entry));
+	return decodeSlackApprovalAction(value);
 }
 function isSlackReplyLinkAction(parsed) {
 	if (parsed.actionId === "openclaw:session_link") return true;
@@ -2491,11 +2506,19 @@ async function handleSlackPluginBindingApproval(params) {
 	await respondEphemeral(params.respond, buildPluginBindingResolvedText(resolved));
 	return true;
 }
+function formatSlackPluginApprovalSenderId(userId, eventScope) {
+	return formatSlackTarget({
+		kind: "user",
+		id: userId,
+		teamId: eventScope?.teamId
+	});
+}
 async function handleSlackApprovalInteraction(params) {
+	const pluginSenderId = formatSlackPluginApprovalSenderId(params.parsed.userId, params.eventScope);
 	const pluginApprovalAuthorizedSender = isSlackApprovalAuthorizedSender({
 		cfg: params.ctx.cfg,
 		accountId: params.ctx.accountId,
-		senderId: params.parsed.userId
+		senderId: pluginSenderId
 	});
 	const execApprovalAuthorizedSender = isSlackExecApprovalAuthorizedSender({
 		cfg: params.ctx.cfg,
@@ -2515,7 +2538,7 @@ async function handleSlackApprovalInteraction(params) {
 			decision: params.approval.decision,
 			channel: "slack",
 			accountId: params.ctx.accountId,
-			senderId: params.parsed.userId
+			senderId: params.approval.approvalKind === "plugin" ? pluginSenderId : params.parsed.userId
 		});
 		const terminalLabel = resolveSlackApprovalTerminalLabel(result.approval);
 		const prefix = result.applied ? "Resolved" : "Already resolved";
@@ -2551,10 +2574,11 @@ async function handleSlackApprovalInteraction(params) {
 async function handleSlackLegacyApprovalInteraction(params) {
 	const parsedApproval = parseExecApprovalCommandText(params.pluginInteractionData);
 	if (!parsedApproval) return false;
+	const pluginSenderId = formatSlackPluginApprovalSenderId(params.parsed.userId, params.eventScope);
 	const pluginAuthorized = isSlackApprovalAuthorizedSender({
 		cfg: params.ctx.cfg,
 		accountId: params.ctx.accountId,
-		senderId: params.parsed.userId
+		senderId: pluginSenderId
 	});
 	const execAuthorized = isSlackExecApprovalAuthorizedSender({
 		cfg: params.ctx.cfg,
@@ -2576,7 +2600,7 @@ async function handleSlackLegacyApprovalInteraction(params) {
 			decision: parsedApproval.decision,
 			channel: "slack",
 			accountId: params.ctx.accountId,
-			senderId: params.parsed.userId,
+			senderId: resolveMethod === "plugin" ? pluginSenderId : params.parsed.userId,
 			resolveMethod
 		});
 		try {
@@ -3562,6 +3586,55 @@ function registerSlackMemberEvents(params) {
 			const channelId = payload.channel;
 			const channelInfo = channelId ? await ctx.resolveChannelName(channelId, eventScope) : {};
 			const channelType = payload.channel_type ?? channelInfo?.type;
+			if (paramsLocal.verb === "joined" && payload.user === ctx.botUserId && channelId) {
+				const roomType = normalizeSlackChannelType(channelType, channelId);
+				if (roomType === "channel" || roomType === "group") {
+					const roomAllowed = ctx.isChannelAllowed({
+						teamId: eventScope?.teamId ?? ctx.teamId,
+						channelId,
+						channelName: channelInfo.name,
+						channelType: roomType
+					});
+					const inviterLabel = roomAllowed && payload.inviter ? (await ctx.resolveUserName(payload.inviter, eventScope)).name ?? payload.inviter : void 0;
+					await reportChannelRoomJoin({
+						cfg: ctx.cfg,
+						channel: "slack",
+						accountId: ctx.accountId,
+						conversationId: channelId,
+						deliverTo: `channel:${channelId}`,
+						route: ctx.resolveSlackSystemEventRoute({
+							channelId,
+							channelType: roomType,
+							eventScope
+						}),
+						inviterLabel,
+						roomAllowed,
+						resolveRoomContext: async ({ messageLimit }) => {
+							const purpose = [channelInfo.purpose, channelInfo.topic].filter((value) => Boolean(value?.trim())).join("\n");
+							const roomContext = {
+								title: channelInfo.name ? `#${channelInfo.name}` : void 0,
+								purpose: purpose || void 0
+							};
+							try {
+								const { messages } = await readSlackMessages(channelId, {
+									limit: messageLimit,
+									client: eventScope?.client ?? ctx.app.client
+								});
+								return {
+									...roomContext,
+									recentMessages: messages.toReversed().flatMap(({ user, text }) => text?.trim() ? [{
+										sender: user,
+										text
+									}] : [])
+								};
+							} catch {
+								return roomContext;
+							}
+						}
+					});
+					return;
+				}
+			}
 			const ingressContext = await authorizeAndResolveSlackSystemEventContext({
 				ctx,
 				senderId: payload.user,
@@ -3571,7 +3644,8 @@ function registerSlackMemberEvents(params) {
 				eventScope
 			});
 			if (!ingressContext) return;
-			enqueueRoutedSystemEvent(`Slack: ${(payload.user ? await ctx.resolveUserName(payload.user, eventScope) : {})?.name ?? payload.user ?? "someone"} ${paramsLocal.verb} ${ingressContext.channelLabel}.`, ingressContext.route, { contextKey: `slack:member:${eventScope ? `${eventScope.teamId}:` : ""}${paramsLocal.verb}:${channelId ?? "unknown"}:${payload.user ?? "unknown"}:${paramsLocal.eventId}` });
+			const userLabel = (payload.user ? await ctx.resolveUserName(payload.user, eventScope) : {})?.name ?? payload.user ?? "someone";
+			enqueueRoutedSystemEvent(`Slack: ${userLabel} ${paramsLocal.verb} ${ingressContext.channelLabel}.`, ingressContext.route, { contextKey: `slack:member:${eventScope ? `${eventScope.teamId}:` : ""}${paramsLocal.verb}:${channelId ?? "unknown"}:${payload.user ?? "unknown"}:${paramsLocal.eventId}` });
 		} catch (err) {
 			ctx.runtime.error?.(danger(`slack ${paramsLocal.verb} handler failed: ${formatErrorMessage(err)}`));
 			if (err instanceof SlackSystemEventAuthRetryError) throw err;
@@ -3653,10 +3727,57 @@ function noteSlackDraftConversationMessage(conversation) {
 	}
 }
 //#endregion
+//#region extensions/slack/src/threading.ts
+function resolveSlackThreadContext(params) {
+	const incomingThreadTs = params.message.thread_ts;
+	const eventTs = params.message.event_ts;
+	const messageTs = params.message.ts ?? eventTs;
+	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
+	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
+	const replyToId = isThreadReply ? incomingThreadTs : void 0;
+	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
+	return {
+		incomingThreadTs,
+		messageTs,
+		isThreadReply,
+		replyToId,
+		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
+	};
+}
+/**
+* Resolves Slack thread targeting for replies and status indicators.
+*
+* @returns replyThreadTs - Thread timestamp for reply messages
+* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
+* @returns isThreadReply - true if this is a genuine user reply in a thread,
+*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
+*/
+function resolveSlackThreadTargets(params) {
+	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
+	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
+	return {
+		replyThreadTs,
+		statusThreadTs: replyThreadTs,
+		isThreadReply
+	};
+}
+//#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: {
-		subtype: "message_changed",
 		eventKind: "message_changed",
 		describe: (channelLabel) => `Slack message edited in ${channelLabel}.`,
 		contextKey: (event) => {
@@ -3667,11 +3788,9 @@ const SUBTYPE_HANDLER_REGISTRY = {
 			const changed = event;
 			return changed.message?.user ?? changed.previous_message?.user ?? changed.message?.bot_id ?? changed.previous_message?.bot_id;
 		},
-		resolveChannelId: (event) => event.channel,
-		resolveChannelType: () => void 0
+		resolveThreadTs: resolveNestedThreadTs
 	},
 	message_deleted: {
-		subtype: "message_deleted",
 		eventKind: "message_deleted",
 		describe: (channelLabel) => `Slack message deleted in ${channelLabel}.`,
 		contextKey: (event) => {
@@ -3682,8 +3801,7 @@ const SUBTYPE_HANDLER_REGISTRY = {
 			const deleted = event;
 			return deleted.previous_message?.user ?? deleted.previous_message?.bot_id;
 		},
-		resolveChannelId: (event) => event.channel,
-		resolveChannelType: () => void 0
+		resolveThreadTs: resolveNestedThreadTs
 	}
 };
 function resolveSlackMessageSubtypeHandler(event) {
@@ -3717,7 +3835,8 @@ function addUserCandidate(candidates, value, botUserId) {
 	candidates.add(id);
 }
 function collectMetadataUserCandidates(candidates, value, botUserId) {
-	const payload = asOptionalRecord(asOptionalRecord(value)?.event_payload);
+	const metadata = asOptionalRecord(value);
+	const payload = asOptionalRecord(metadata?.event_payload);
 	if (!payload) return;
 	for (const key of [
 		"user",
@@ -3827,12 +3946,11 @@ function registerSlackMessageEvents(params) {
 			})) return;
 			const subtypeHandler = resolveSlackMessageSubtypeHandler(message);
 			if (subtypeHandler) {
-				const channelId = subtypeHandler.resolveChannelId(message);
 				const ingressContext = await authorizeAndResolveSlackSystemEventContext({
 					ctx,
 					senderId: subtypeHandler.resolveSenderId(message),
-					channelId,
-					channelType: subtypeHandler.resolveChannelType(message),
+					channelId: message.channel,
+					threadTs: subtypeHandler.resolveThreadTs(message),
 					eventKind: subtypeHandler.eventKind,
 					eventScope
 				});
@@ -4018,7 +4136,8 @@ function registerSlackReactionEvents(params) {
 			const emojiLabel = event.reaction ?? "emoji";
 			const authorLabel = authorInfo?.name ?? event.item_user;
 			const baseText = `Slack reaction ${action}: :${emojiLabel}: by ${actorLabel} in ${ingressContext.channelLabel} msg ${item.ts}`;
-			enqueueRoutedSystemEvent(authorLabel ? `${baseText} from ${authorLabel}` : baseText, ingressContext.route, { contextKey: `slack:reaction:${eventScope ? `${eventScope.teamId}:` : ""}${action}:${item.channel}:${item.ts}:${event.user}:${emojiLabel}:${eventId}` });
+			const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
+			enqueueRoutedSystemEvent(text, ingressContext.route, { contextKey: `slack:reaction:${eventScope ? `${eventScope.teamId}:` : ""}${action}:${item.channel}:${item.ts}:${event.user}:${emojiLabel}:${eventId}` });
 		} catch (err) {
 			ctx.runtime.error?.(danger(`slack reaction handler failed: ${formatErrorMessage(err)}`));
 		}
@@ -4097,7 +4216,7 @@ function registerSlackWorkspaceEvents(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-dispatch-dedupe.ts
-const SLACK_MESSAGE_DISPATCH_DEDUPE_TTL_MS = 1440 * 60 * 1e3;
+const SLACK_MESSAGE_DISPATCH_DEDUPE_TTL_MS = 864e5;
 const SLACK_MESSAGE_DISPATCH_DEDUPE_MEMORY_MAX_ENTRIES = 2e4;
 const SLACK_MESSAGE_DISPATCH_DEDUPE_STATE_MAX_ENTRIES = 2e4;
 const SLACK_MESSAGE_DISPATCH_DEDUPE_NAMESPACE = "global";
@@ -4164,19 +4283,7 @@ function buildSlackDebounceKey(message, accountId, teamId) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-Bbfd5VFW.js"));
-function createSlackDispatchCompletion() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((nextResolve, nextReject) => {
-			resolve = nextResolve;
-			reject = nextReject;
-		}),
-		resolve,
-		reject
-	};
-}
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-CcdujV99.js"));
 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;
@@ -4184,8 +4291,9 @@ function isRetryableSlackInboundError(error) {
 	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)));
 }
 function shouldDebounceSlackMessage(message, cfg) {
+	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
 	return shouldDebounceTextInbound({
-		text: stripSlackMentionsForCommandDetection(message.text ?? ""),
+		text: textForCommandDetection,
 		cfg,
 		hasMedia: Boolean(message.files && message.files.length > 0) || hasSlackMessageTableBlock(message)
 	});
@@ -4243,6 +4351,19 @@ function createSlackMessageHandler(params) {
 			const completions = entries.map((entry) => entry.opts.dispatchCompletion).filter((completion) => completion !== void 0);
 			try {
 				await (async () => {
+					const flushedEntry = entries.at(-1);
+					if (flushedEntry) {
+						const teamId = flushedEntry.opts.eventScope?.teamId;
+						const flushedKey = buildSlackDebounceKey(flushedEntry.message, ctx.accountId, teamId);
+						const topLevelConversationKey = buildTopLevelSlackConversationKey(flushedEntry.message, ctx.accountId, teamId);
+						if (flushedKey && topLevelConversationKey) {
+							const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
+							if (pendingKeys) {
+								pendingKeys.delete(flushedKey);
+								if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
+							}
+						}
+					}
 					const claims = [];
 					const claimedKeys = /* @__PURE__ */ new Map();
 					const surviving = [];
@@ -4296,16 +4417,6 @@ function createSlackMessageHandler(params) {
 						releaseClaims();
 						return;
 					}
-					const teamId = last.opts.eventScope?.teamId;
-					const flushedKey = buildSlackDebounceKey(last.message, ctx.accountId, teamId);
-					const topLevelConversationKey = buildTopLevelSlackConversationKey(last.message, ctx.accountId, teamId);
-					if (flushedKey && topLevelConversationKey) {
-						const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
-						if (pendingKeys) {
-							pendingKeys.delete(flushedKey);
-							if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
-						}
-					}
 					const combinedText = surviving.length === 1 ? last.message.text ?? "" : surviving.map((entry) => entry.message.text ?? "").filter(Boolean).join("\n");
 					const combinedMentioned = surviving.some((entry) => Boolean(entry.opts.wasMentioned));
 					const syntheticMessage = {
@@ -4338,6 +4449,7 @@ function createSlackMessageHandler(params) {
 							releaseClaims();
 							return;
 						}
+						await turnAdoptionLifecycle?.onSessionRouted?.(prepared.route.sessionKey);
 						prepared.turnAdoptionLifecycle = {
 							...turnAdoptionLifecycle,
 							admission: turnAdoptionLifecycle?.admission ?? "exclusive",
@@ -4353,6 +4465,10 @@ function createSlackMessageHandler(params) {
 								if (admissionLifecycle.onDeferred() === false) return false;
 								settlementHandedOff = true;
 							},
+							onDeferredHeartbeat: () => {
+								turnAdoptionLifecycle?.onDeferredHeartbeat?.();
+								admissionLifecycle.onDeferredHeartbeat?.();
+							},
 							onAbandoned: () => {
 								settlementHandedOff = true;
 								releaseClaims();
@@ -4416,7 +4532,7 @@ function createSlackMessageHandler(params) {
 			pendingKeys.add(debounceKey);
 			pendingTopLevelDebounceKeys.set(conversationKey, pendingKeys);
 		}
-		const dispatchCompletion = opts.awaitDispatch ? createSlackDispatchCompletion() : void 0;
+		const dispatchCompletion = opts.awaitDispatch ? createDeferred() : void 0;
 		await debouncer.enqueue({
 			message: resolvedMessage,
 			opts: {
@@ -4435,11 +4551,11 @@ function createSlackMessageHandler(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/presence-monitor.ts
-const SLACK_PRESENCE_GREETING_COOLDOWN_MS = 480 * 60 * 1e3;
+const SLACK_PRESENCE_GREETING_COOLDOWN_MS = 288e5;
 const SLACK_PRESENCE_REQUEST_TIMEOUT_MS = 3e4;
 const SLACK_PRESENCE_POLL_INTERVAL_MS = 6e4;
 const SLACK_PRESENCE_AUTO_MAX_PARTICIPANTS = 8;
-const SLACK_PRESENCE_TARGET_TTL_MS = 1440 * 60 * 1e3;
+const SLACK_PRESENCE_TARGET_TTL_MS = 864e5;
 const SLACK_PRESENCE_MAX_POLLS_PER_INTERVAL = 45;
 const SLACK_PRESENCE_MAX_TARGETS = 2e3;
 const DEFAULT_SLACK_PRESENCE_EVENT_PROMPT = ["Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time; if their timezone is unknown, do not guess.", "Send at most one short, natural greeting in this Slack conversation. Do not reveal private memory. If no greeting is appropriate, stay silent."];
@@ -5047,8 +5163,8 @@ async function authorizeSlackDirectMessage(params) {
 //#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(SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES * 8 / 6)}}$`);
-const SLACK_EXTERNAL_ARG_MENU_TTL_MS = 600 * 1e3;
+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);
@@ -5140,7 +5256,7 @@ const SLACK_COMMAND_ARG_CONFIRM_TEXT_MAX = 300;
 const SLACK_HEADER_TEXT_MAX = 150;
 const SLACK_COMMAND_ARG_ACTION_BLOCKS_MAX = 47;
 const loadSlashCommandsRuntime = createLazyRuntimeModule(() => import("./slash-commands.runtime-BTTMlmwy.js"));
-const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-Cf2FTrnf.js"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-C2015r6s.js"));
 const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
 function resolveSlackCommandMenuModelContext(params) {
@@ -5191,6 +5307,8 @@ function resolveSlackCommandMenuModelContext(params) {
 }
 const slackExternalArgMenuStore = createSlackExternalArgMenuStore();
 function buildSlackArgMenuConfirm(params) {
+	const command = escapeSlackMrkdwn(params.command);
+	const arg = escapeSlackMrkdwn(params.arg);
 	return {
 		title: {
 			type: "plain_text",
@@ -5198,7 +5316,7 @@ function buildSlackArgMenuConfirm(params) {
 		},
 		text: {
 			type: "mrkdwn",
-			text: truncateSlackText(`Run */${escapeSlackMrkdwn(params.command)}* with *${escapeSlackMrkdwn(params.arg)}* set to this value?`, SLACK_COMMAND_ARG_CONFIRM_TEXT_MAX)
+			text: truncateSlackText(`Run */${command}* with *${arg}* set to this value?`, SLACK_COMMAND_ARG_CONFIRM_TEXT_MAX)
 		},
 		confirm: {
 			type: "plain_text",
@@ -5602,7 +5720,7 @@ async function registerSlackMonitorSlashCommands(params) {
 			}
 			const channelName = channelInfo?.name;
 			const roomLabel = channelName ? `#${channelName}` : `#${command.channel_id}`;
-			const { deliverSlackSlashReplies, dispatchChannelInboundTurn, finalizeInboundContext, isChannelPartialDeliveryError, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode } = await loadSlashDispatchRuntime();
+			const { deliverSlackSlashReplies, dispatchChannelInboundTurn, finalizeInboundContext, isChannelPartialDeliveryError, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode, sanitizeSlackMonitorReplyPayload } = await loadSlashDispatchRuntime();
 			const route = resolvedSlashRoute ?? resolveAgentRoute({
 				cfg,
 				channel: "slack",
@@ -5702,10 +5820,8 @@ async function registerSlackMonitorSlashCommands(params) {
 					sessionKey: ctxPayload.SessionKey ?? route.sessionKey
 				},
 				ctxPayload,
-				replyPipeline: { transformReplyPayload: (payload) => {
-					if (payload.isReasoning === true) return null;
-					return payload;
-				} },
+				dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
+				replyPipeline: { transformReplyPayload: sanitizeSlackMonitorReplyPayload },
 				dispatcherOptions: { onSettled: async () => {
 					if (pendingSlashReplies.length === 0) return;
 					const pending = pendingSlashReplies.splice(0);
@@ -5920,11 +6036,13 @@ async function registerSlackMonitorSlashCommands(params) {
 			const respondFn = respond ?? (async (message) => {
 				if (!body.channel?.id || !body.user?.id) return new Response(null, { status: 204 });
 				const payload = typeof message === "string" ? { text: message } : message;
+				const threadTs = body.container?.thread_ts ?? body.message?.thread_ts;
 				await args.client.chat.postEphemeral({
 					token: ctx.botToken,
 					channel: body.channel.id,
 					user: body.user.id,
 					text: payload.text ?? "",
+					...threadTs ? { thread_ts: threadTs } : {},
 					...payload.blocks ? { blocks: payload.blocks } : {},
 					...typeof payload.mrkdwn === "boolean" ? { mrkdwn: payload.mrkdwn } : {}
 				});
@@ -5999,12 +6117,13 @@ async function deliverSlackSlashResponseWithWebApi(params) {
 	const mrkdwn = "mrkdwn" in payload && typeof payload.mrkdwn === "boolean" ? payload.mrkdwn : void 0;
 	if (payload.response_type === "in_channel") {
 		const postSlackMessage = params.client.chat.postMessage;
-		requireSlackPostMessageTimestamp(await postSlackMessage({
+		const response = await postSlackMessage({
 			channel: params.command.channel_id,
 			text,
 			...blocks ? { blocks } : {},
 			...mrkdwn !== void 0 ? { mrkdwn } : {}
-		}));
+		});
+		requireSlackPostMessageTimestamp(response);
 	} else await params.client.chat.postEphemeral({
 		channel: params.command.channel_id,
 		user: params.command.user_id,
@@ -6036,8 +6155,8 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-mhpMMRG-.js"));
-const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-BLMdBrAw.js"));
+const SLACK_WEBHOOK_MAX_BODY_BYTES = 1048576;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveSlackRuntimeIdentity(params) {
 	const botUserId = normalizeOptionalString(params.botUserId);
@@ -6178,8 +6297,9 @@ async function monitorSlackProvider(opts = {}) {
 	const groupDmChannels = dmConfig?.groupChannels;
 	let channelsConfig = slackCfg.channels;
 	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+	const providerConfigPresent = cfg.channels?.slack !== void 0;
 	const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy$1({
-		providerConfigPresent: cfg.channels?.slack !== void 0,
+		providerConfigPresent,
 		groupPolicy: slackCfg.groupPolicy,
 		defaultGroupPolicy
 	});
@@ -6480,10 +6600,11 @@ async function monitorSlackProvider(opts = {}) {
 				summarizeMapping("slack users", mapping, [], runtime);
 			}
 			if (allowNameMatching) try {
-				const { mapping, unresolved, additions } = buildAllowlistResolutionSummary(await resolveSlackUserAllowlist({
+				const resolvedUsers = await resolveSlackUserAllowlist({
 					token: resolveToken,
 					entries: allowEntries
-				}), { formatResolved: formatSlackUserResolved });
+				});
+				const { mapping, unresolved, additions } = buildAllowlistResolutionSummary(resolvedUsers, { formatResolved: formatSlackUserResolved });
 				allowFrom = mergeAllowlist({
 					existing: allowFrom,
 					additions
@@ -6510,10 +6631,11 @@ async function monitorSlackProvider(opts = {}) {
 					summarizeMapping("slack channel users", mapping, [], runtime);
 				}
 				if (allowNameMatching) try {
-					const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(await resolveSlackUserAllowlist({
+					const resolvedUsers = await resolveSlackUserAllowlist({
 						token: resolveToken,
 						entries: Array.from(userEntries)
-					}), { formatResolved: formatSlackUserResolved });
+					});
+					const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers, { formatResolved: formatSlackUserResolved });
 					const nextChannels = patchAllowlistUsersInConfigEntries({
 						entries: channelsConfig,
 						resolvedMap
@@ -6750,4 +6872,4 @@ function createSlackWorkspaceClientResolver(params) {
 }
 const resolveSlackRuntimeGroupPolicy = resolveOpenProviderRuntimeGroupPolicy$1;
 //#endregion
-export { buildSlackSlashCommandMatcher as C, updateLastRoute as S, parseSlackAssistantThreadMetadata as _, createSlackResponseUrlBudget as a, resolveChannelResetConfig as b, resolveConversationLabel$1 as c, resolveSlackEffectiveAllowFrom as d, SLACK_SOCKET_RECONNECT_POLICY as f, buildSlackAssistantThreadMetadata as g, resolveSlackChatType as h, SlackResponseAlreadyReportedError as i, authorizeSlackBotRoomMessage as l, normalizeSlackChannelType as m, resolveSlackRuntimeGroupPolicy as n, authorizeSlackDirectMessage as o, formatUnknownError as p, resolveSlackRoomContextHints as r, trackSlackDraftMessage as s, monitorSlackProvider as t, resolveSlackCommandIngress as u, readSessionUpdatedAt as v, stripSlackMentionsForCommandDetection as w, resolveStorePath$1 as x, resolveChannelContextVisibilityMode as y };
+export { resolveStorePath$1 as C, stripSlackMentionsForCommandDetection as E, resolveChannelResetConfig as S, buildSlackSlashCommandMatcher as T, resolveSlackChatType as _, createSlackResponseUrlBudget as a, readSessionUpdatedAt as b, resolveSlackThreadTargets as c, authorizeSlackBotRoomMessage as d, resolveSlackCommandIngress as f, normalizeSlackChannelType as g, formatUnknownError as h, SlackResponseAlreadyReportedError as i, trackSlackDraftMessage as l, SLACK_SOCKET_RECONNECT_POLICY as m, resolveSlackRuntimeGroupPolicy as n, authorizeSlackDirectMessage as o, resolveSlackEffectiveAllowFrom as p, resolveSlackRoomContextHints as r, resolveSlackThreadContext as s, monitorSlackProvider as t, resolveConversationLabel$1 as u, buildSlackAssistantThreadMetadata as v, updateLastRoute as w, resolveChannelContextVisibilityMode as x, parseSlackAssistantThreadMetadata as y };