@openclaw/slack 2026.8.1-beta.3 → 2026.8.1

package/dist/{provider-CUUiwsg2.js → provider-CN_8hFv2.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 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-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 { 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-BdwszjYn.js";
+import { D as resolveSlackWebClientOptions, E as resolveSlackProxyDispatcher, T as resolveSlackLookupClientOptions, _ as createSlackStartupAuthClient, a as slackIngressIdentity, c as normalizeAllowList, d as normalizeSlackSlug, f as resolveSlackAllowListMatch, i as createSlackIngressSubject, l as normalizeAllowListLower, o as formatSlackError, p as resolveSlackUserAllowListForTeam, s as allowListMatches, u as normalizeSlackAllowOwnerEntry, x as getSlackListenerUploadCompletionClient, y as createSlackWebClient } from "./probe-0usmAb0i.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-BI7JkfVm.js";
+import { i as setSlackDefaultSendIdentity, p as requireSlackPostMessageTimestamp } from "./send-DS9ICrBI.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-Czheznc8.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-BAOlNimr.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-CtQVbde1.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";
@@ -26,6 +26,7 @@ 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";
@@ -705,6 +706,7 @@ function createSlackMonitorContext(params) {
 		}
 		return false;
 	};
+	const channelRuntime = params.channelRuntime;
 	const ctx = {
 		cfg: params.cfg,
 		accountId: params.accountId,
@@ -712,7 +714,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 +1281,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 +1319,110 @@ 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 {
+				if (asOptionalRecord(raw.kind === "events-api" ? asOptionalRecord(raw.body)?.event : void 0)?.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 } : {}
@@ -1498,88 +1587,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 +1829,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({
@@ -2015,6 +2023,7 @@ async function authorizeAndResolveSlackSystemEventContext(params) {
 			channelId,
 			channelType: auth.channelType,
 			senderId,
+			threadTs: auth.channelType === "im" ? void 0 : params.threadTs,
 			eventScope: params.eventScope
 		})
 	};
@@ -3562,6 +3571,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,
@@ -3653,10 +3711,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 +3772,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 +3785,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) {
@@ -3827,12 +3929,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
 				});
@@ -4164,19 +4265,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-Bd22U0ga.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;
@@ -4243,6 +4332,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 +4398,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 +4430,7 @@ function createSlackMessageHandler(params) {
 							releaseClaims();
 							return;
 						}
+						await turnAdoptionLifecycle?.onSessionRouted?.(prepared.route.sessionKey);
 						prepared.turnAdoptionLifecycle = {
 							...turnAdoptionLifecycle,
 							admission: turnAdoptionLifecycle?.admission ?? "exclusive",
@@ -4353,6 +4446,10 @@ function createSlackMessageHandler(params) {
 								if (admissionLifecycle.onDeferred() === false) return false;
 								settlementHandedOff = true;
 							},
+							onDeferredHeartbeat: () => {
+								turnAdoptionLifecycle?.onDeferredHeartbeat?.();
+								admissionLifecycle.onDeferredHeartbeat?.();
+							},
 							onAbandoned: () => {
 								settlementHandedOff = true;
 								releaseClaims();
@@ -4416,7 +4513,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: {
@@ -5140,7 +5237,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-CilDmI0c.js"));
 const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
 function resolveSlackCommandMenuModelContext(params) {
@@ -5602,7 +5699,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 +5799,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 +6015,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 } : {}
 				});
@@ -6036,7 +6133,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-mhpMMRG-.js"));
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-BNGpsdwV.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveSlackRuntimeIdentity(params) {
@@ -6750,4 +6847,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 };

package/dist/{relay-source-mhpMMRG-.js → relay-source-BNGpsdwV.js}

@@ -1,4 +1,4 @@
-import { f as SLACK_SOCKET_RECONNECT_POLICY, p as formatUnknownError } from "./provider-CUUiwsg2.js";
+import { h as formatUnknownError, m as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-CN_8hFv2.js";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { isIP } from "node:net";

package/dist/{replies-SnWyXcsL.js → replies-BSiRQOJ1.js}

@@ -1,11 +1,12 @@
-import { A as isSlackInvalidBlocksResponse, E as buildSlackNativeDataAccessibilityText, I as buildSlackBlocksFallbackText, O as hasSlackNativeDataBlock, P as markdownToSlackMrkdwnChunks, U as SLACK_TEXT_LIMIT, _ as hasSlackReplyStructuredContent, b as resolveSlackReplyBlocks, j as isSlackNativeResponseUrlRejection, y as resolveSlackReplyBlockResolution } from "./group-policy-DyfB_ZIE.js";
-import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-CtnOxKCc.js";
-import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CUUiwsg2.js";
+import { C as isSlackNativeResponseUrlRejection, M as SLACK_TEXT_LIMIT, S as isSlackInvalidBlocksResponse, T as buildSlackBlocksFallbackText, Z as markdownToSlackMrkdwnChunks, b as hasSlackNativeDataBlock, d as resolveSlackReplyBlockResolution, f as resolveSlackReplyBlocks, l as hasSlackReplyStructuredContent, v as buildSlackNativeDataAccessibilityText } from "./group-policy-BdwszjYn.js";
+import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-DS9ICrBI.js";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CN_8hFv2.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
-import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 import { createChannelPartialDeliveryError } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
@@ -114,6 +115,15 @@ function compactSlackResponseUrlFallback(messages) {
 function readSlackReplyBlocks(payload) {
 	return resolveSlackReplyBlocks(payload);
 }
+function sanitizeSlackMonitorReplyPayload(payload) {
+	if (payload.isReasoning === true || typeof payload.text !== "string") return payload.isReasoning === true ? null : payload;
+	const text = sanitizeAssistantVisibleText(payload.text);
+	if (text === payload.text) return payload;
+	return text || resolveSendableOutboundReplyParts(payload).hasMedia || hasSlackReplyStructuredContent(payload) ? {
+		...payload,
+		text: text || void 0
+	} : null;
+}
 function resolveSlackMediaHookSpokenText(payload) {
 	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
 }
@@ -511,4 +521,4 @@ async function deliverSlackSlashReplies(params) {
 	}
 }
 //#endregion
-export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };
+export { resolveDeliveredSlackReplyThreadTs as a, emitSlackMessageSentHooks as c, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, sanitizeSlackMonitorReplyPayload as s, createSlackReplyDeliveryPlan as t };

package/dist/{resolve-channels-BSpqC8jU.js → resolve-channels-Czheznc8.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { i as createSlackLookupClient } from "./probe-BVA65leh.js";
+import { h as createSlackLookupClient } from "./probe-0usmAb0i.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";