@openclaw/slack 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{send-Dg6U9K7_.js → send-DKDXoeoV.js}

@@ -1,22 +1,24 @@
-import { a as resolveSlackAccount, d as resolveSlackBotToken } from "./accounts-BPCiCe8y.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken, p as resolveSlackBotToken } from "./accounts-BOJJiHSr.js";
 import { r as parseSlackTarget } from "./target-parsing-3jYH8LfB.js";
 import "./targets-Dll4NJgs.js";
-import { a as SLACK_TEXT_LIMIT, i as validateSlackBlocksArray, v as truncateSlackText } from "./reply-blocks-CfJqf7eq.js";
-import { t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { a as getSlackWriteClient, n as createSlackTokenCacheKey } from "./client-DG9cyk55.js";
+import { a as SLACK_TEXT_LIMIT, b as truncateSlackText, i as validateSlackBlocksArray } from "./reply-blocks-BGQ6zSqM.js";
+import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
+import { a as getSlackWriteClient, n as createSlackTokenCacheKey, r as createSlackWebClient } from "./client-DGxwSL7f.js";
 import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-DHJ8ntLr.js";
+import { t as markdownToSlackMrkdwnChunks } from "./format-YCNoNkM2.js";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-CEmqYxR-.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { markdownToIR, renderMarkdownIRChunksWithinLimit, renderMarkdownWithMarkers } from "openclaw/plugin-sdk/text-chunking";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
 import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { chunkMarkdownTextWithMode, isSilentReplyText, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
-import { resolveGlobalDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
+import { createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 //#region extensions/slack/src/blocks-fallback.ts
 function cleanCandidate(value) {
 	if (typeof value !== "string") return;
@@ -76,185 +78,33 @@ function buildSlackBlocksFallbackText(blocks) {
 	return "Shared a Block Kit message";
 }
 //#endregion
-//#region extensions/slack/src/format.ts
-function escapeSlackMrkdwnSegment(text) {
-	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-const SLACK_ANGLE_TOKEN_RE = /<[^>\n]+>/g;
-function isAllowedSlackAngleToken(token) {
-	if (!token.startsWith("<") || !token.endsWith(">")) return false;
-	const inner = token.slice(1, -1);
-	return inner.startsWith("@") || inner.startsWith("#") || inner.startsWith("!") || inner.startsWith("mailto:") || inner.startsWith("tel:") || inner.startsWith("http://") || inner.startsWith("https://") || inner.startsWith("slack://");
-}
-function escapeSlackMrkdwnContent(text) {
-	if (!text) return "";
-	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
-	SLACK_ANGLE_TOKEN_RE.lastIndex = 0;
-	const out = [];
-	let lastIndex = 0;
-	for (let match = SLACK_ANGLE_TOKEN_RE.exec(text); match; match = SLACK_ANGLE_TOKEN_RE.exec(text)) {
-		const matchIndex = match.index ?? 0;
-		out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex, matchIndex)));
-		const token = match[0] ?? "";
-		out.push(isAllowedSlackAngleToken(token) ? token : escapeSlackMrkdwnSegment(token));
-		lastIndex = matchIndex + token.length;
-	}
-	out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex)));
-	return out.join("");
-}
-function escapeSlackMrkdwnText(text) {
-	if (!text) return "";
-	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
-	return text.split("\n").map((line) => {
-		if (line.startsWith("> ")) return `> ${escapeSlackMrkdwnContent(line.slice(2))}`;
-		return escapeSlackMrkdwnContent(line);
-	}).join("\n");
-}
-function buildSlackLink(link, text) {
-	const href = link.href.trim();
-	if (!href) return null;
-	const trimmedLabel = text.slice(link.start, link.end).trim();
-	const comparableHref = href.startsWith("mailto:") ? href.slice(7) : href;
-	if (!(trimmedLabel.length > 0 && trimmedLabel !== href && trimmedLabel !== comparableHref)) return null;
-	const safeHref = escapeSlackMrkdwnSegment(href);
-	return {
-		start: link.start,
-		end: link.end,
-		open: `<${safeHref}|`,
-		close: ">"
-	};
-}
-function buildSlackRenderOptions() {
-	return {
-		styleMarkers: {
-			bold: {
-				open: "*",
-				close: "*"
-			},
-			italic: {
-				open: "_",
-				close: "_"
-			},
-			strikethrough: {
-				open: "~",
-				close: "~"
-			},
-			code: {
-				open: "`",
-				close: "`"
-			},
-			code_block: {
-				open: "```\n",
-				close: "```"
-			}
-		},
-		escapeText: escapeSlackMrkdwnText,
-		buildLink: buildSlackLink
-	};
-}
-function markdownToSlackMrkdwn(markdown, options = {}) {
-	return renderMarkdownWithMarkers(markdownToIR(markdown ?? "", {
-		linkify: false,
-		autolink: false,
-		headingStyle: "bold",
-		blockquotePrefix: "> ",
-		tableMode: options.tableMode
-	}), buildSlackRenderOptions());
-}
-function normalizeSlackOutboundText(markdown) {
-	return markdownToSlackMrkdwn(markdown ?? "");
-}
-function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
-	const ir = markdownToIR(markdown ?? "", {
-		linkify: false,
-		autolink: false,
-		headingStyle: "bold",
-		blockquotePrefix: "> ",
-		tableMode: options.tableMode
-	});
-	const renderOptions = buildSlackRenderOptions();
-	return renderMarkdownIRChunksWithinLimit({
-		ir,
-		limit,
-		renderChunk: (chunk) => renderMarkdownWithMarkers(chunk, renderOptions),
-		measureRendered: (rendered) => rendered.length
-	}).map(({ rendered }) => rendered);
-}
-//#endregion
 //#region extensions/slack/src/sent-thread-cache.ts
-/**
-* In-memory cache of Slack threads the bot has participated in.
-* Used to auto-respond in threads without requiring @mention after the first reply.
-* Follows a similar TTL pattern to the MS Teams and Telegram sent-message caches.
-*/
-const TTL_MS = 1440 * 60 * 1e3;
-const MAX_ENTRIES = 5e3;
-const PERSISTENT_MAX_ENTRIES = 1e3;
-const PERSISTENT_NAMESPACE = "slack.thread-participation";
-const threadParticipation = resolveGlobalDedupeCache(Symbol.for("openclaw.slackThreadParticipation"), {
-	ttlMs: TTL_MS,
-	maxSize: MAX_ENTRIES
+const threadParticipation = createPersistentDedupeCache({
+	globalKey: Symbol.for("openclaw.slackThreadParticipation"),
+	ttlMs: 1440 * 60 * 1e3,
+	maxSize: 5e3,
+	persistent: {
+		namespace: "slack.thread-participation",
+		maxEntries: 1e3,
+		openStore: (options) => getOptionalSlackRuntime()?.state.openKeyedStore(options),
+		logError: (error) => {
+			try {
+				getOptionalSlackRuntime()?.logging.getChildLogger({
+					plugin: "slack",
+					feature: "thread-participation-state"
+				}).warn("Slack persistent thread participation state failed", { error: String(error) });
+			} catch {}
+		}
+	}
 });
-let persistentStore;
-let persistentStoreDisabled = false;
 function makeKey(accountId, channelId, threadTs) {
 	return `${accountId}:${channelId}:${threadTs}`;
 }
-function reportPersistentThreadParticipationError(error) {
-	try {
-		getOptionalSlackRuntime()?.logging.getChildLogger({
-			plugin: "slack",
-			feature: "thread-participation-state"
-		}).warn("Slack persistent thread participation state failed", { error: String(error) });
-	} catch {}
-}
-function disablePersistentThreadParticipation(error) {
-	persistentStoreDisabled = true;
-	persistentStore = void 0;
-	reportPersistentThreadParticipationError(error);
-}
-function getPersistentThreadParticipationStore() {
-	if (persistentStoreDisabled) return;
-	if (persistentStore) return persistentStore;
-	const runtime = getOptionalSlackRuntime();
-	if (!runtime) return;
-	try {
-		persistentStore = runtime.state.openKeyedStore({
-			namespace: PERSISTENT_NAMESPACE,
-			maxEntries: PERSISTENT_MAX_ENTRIES,
-			defaultTtlMs: TTL_MS
-		});
-		return persistentStore;
-	} catch (error) {
-		disablePersistentThreadParticipation(error);
-		return;
-	}
-}
-function rememberPersistentThreadParticipation(params) {
-	const store = getPersistentThreadParticipationStore();
-	if (!store) return;
-	store.register(params.key, {
-		...params.agentId ? { agentId: params.agentId } : {},
-		repliedAt: Date.now()
-	}).catch(disablePersistentThreadParticipation);
-}
-async function lookupPersistentThreadParticipation(key) {
-	const store = getPersistentThreadParticipationStore();
-	if (!store) return false;
-	try {
-		return Boolean(await store.lookup(key));
-	} catch (error) {
-		disablePersistentThreadParticipation(error);
-		return false;
-	}
-}
 function recordSlackThreadParticipation(accountId, channelId, threadTs, opts) {
 	if (!accountId || !channelId || !threadTs) return;
-	const key = makeKey(accountId, channelId, threadTs);
-	threadParticipation.check(key);
-	rememberPersistentThreadParticipation({
-		key,
-		agentId: opts?.agentId
+	threadParticipation.register(makeKey(accountId, channelId, threadTs), {
+		...opts?.agentId ? { agentId: opts.agentId } : {},
+		repliedAt: Date.now()
 	});
 }
 function hasSlackThreadParticipation(accountId, channelId, threadTs) {
@@ -263,16 +113,10 @@ function hasSlackThreadParticipation(accountId, channelId, threadTs) {
 }
 async function hasSlackThreadParticipationWithPersistence(params) {
 	if (!params.accountId || !params.channelId || !params.threadTs) return false;
-	const key = makeKey(params.accountId, params.channelId, params.threadTs);
-	if (threadParticipation.peek(key)) return true;
-	const found = await lookupPersistentThreadParticipation(key);
-	if (found) threadParticipation.check(key);
-	return found;
+	return await threadParticipation.lookup(makeKey(params.accountId, params.channelId, params.threadTs));
 }
 function clearSlackThreadParticipationCache() {
-	threadParticipation.clear();
-	persistentStore = void 0;
-	persistentStoreDisabled = false;
+	threadParticipation.clearForTest();
 }
 //#endregion
 //#region extensions/slack/src/send.ts
@@ -285,15 +129,24 @@ const SLACK_UPLOAD_SSRF_POLICY = {
 	allowRfc2544BenchmarkRange: true
 };
 const SLACK_DM_CHANNEL_CACHE_MAX = 1024;
-const SLACK_DNS_RETRY_CODES = new Set([
+const SLACK_DNS_RETRY_CODES = /* @__PURE__ */ new Set([
 	"EAI_AGAIN",
 	"ENOTFOUND",
 	"UND_ERR_DNS_RESOLVE_FAILED"
 ]);
 const SLACK_DNS_RETRY_ATTEMPTS = 2;
 const SLACK_DNS_RETRY_BASE_DELAY_MS = 250;
+const SLACK_DELIVERY_METADATA_EVENT = "openclaw_delivery";
+const SLACK_DELIVERY_METADATA_KEY = "openclaw_delivery_id";
+const SLACK_DELIVERY_METADATA_PART_INDEX_KEY = "openclaw_delivery_part_index";
+const SLACK_DELIVERY_METADATA_PART_COUNT_KEY = "openclaw_delivery_part_count";
+const SLACK_DELIVERY_METADATA_SIGNATURE_KEY = "openclaw_delivery_signature";
+const SLACK_RECONCILE_LOOKBACK_MS = 3e4;
+const SLACK_RECONCILE_CLOCK_SKEW_MS = 5 * 6e4;
+const SLACK_RECONCILE_LIMIT = 100;
+const SLACK_RECONCILE_MAX_PAGES = 10;
 const slackDmChannelCache = /* @__PURE__ */ new Map();
-const slackSendQueues = /* @__PURE__ */ new Map();
+const slackSendQueue = new KeyedAsyncQueue();
 const slackDefaultSendIdentities = /* @__PURE__ */ new Map();
 function hasCustomIdentity(identity) {
 	return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
@@ -427,29 +280,50 @@ function isSlackCustomizeScopeError(err) {
 	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.needed))?.includes("chat:write.customize")) return true;
 	return [...normalizeSlackScopeList(data?.response_metadata?.scopes), ...normalizeSlackScopeList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize");
 }
+function isSlackCustomIdentityRejectedError(err) {
+	if (isSlackCustomizeScopeError(err)) return true;
+	const code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(getSlackWebApiErrorData(err)?.error));
+	return code === "invalid_arguments" || code === "invalid_arg_name";
+}
 async function postSlackMessageBestEffort(params) {
 	const basePayload = buildSlackPostMessagePayload(params);
 	const postChatMessage = params.client.chat.postMessage.bind(params.client.chat);
+	const post = async (payload, identity) => ({
+		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)),
+		identity
+	});
 	try {
 		const identity = params.identity;
-		if (identity?.iconUrl) return await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage({
+		if (identity?.iconUrl) return await post({
 			...basePayload,
 			...identity.username ? { username: identity.username } : {},
 			icon_url: identity.iconUrl
-		}));
-		if (identity?.iconEmoji) return await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage({
+		}, identity);
+		if (identity?.iconEmoji) return await post({
 			...basePayload,
 			...identity.username ? { username: identity.username } : {},
 			icon_emoji: identity.iconEmoji
-		}));
-		return await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage({
+		}, identity);
+		return await post({
 			...basePayload,
 			...identity?.username ? { username: identity.username } : {}
-		}));
+		}, identity);
 	} catch (err) {
-		if (!hasCustomIdentity(params.identity) || !isSlackCustomizeScopeError(err)) throw err;
-		logVerbose("slack send: missing chat:write.customize, retrying without custom identity");
-		return withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(basePayload));
+		const identity = params.identity;
+		if (!identity || !hasCustomIdentity(identity) || !isSlackCustomIdentityRejectedError(err)) throw err;
+		if (!isSlackCustomizeScopeError(err) && identity.username && (identity.iconUrl || identity.iconEmoji)) {
+			logVerbose("slack send: custom icon rejected, retrying with username only");
+			try {
+				return await post({
+					...basePayload,
+					username: identity.username
+				}, { username: identity.username });
+			} catch (retryError) {
+				if (!isSlackCustomIdentityRejectedError(retryError)) throw retryError;
+			}
+		}
+		logVerbose("slack send: custom identity rejected, retrying without custom identity");
+		return post(basePayload);
 	}
 }
 function resolvePostedMessageThreadTs(response) {
@@ -493,20 +367,7 @@ function createSlackSendQueueKey(params) {
 	return `${params.accountId}:${createSlackTokenCacheKey(params.token)}:${recipientKey}:${params.threadTs ?? ""}`;
 }
 async function runQueuedSlackSend(key, task) {
-	const previous = slackSendQueues.get(key) ?? Promise.resolve();
-	let releaseCurrent;
-	const current = new Promise((resolve) => {
-		releaseCurrent = resolve;
-	});
-	const queuedCurrent = previous.catch(() => void 0).then(() => current);
-	slackSendQueues.set(key, queuedCurrent);
-	await previous.catch(() => void 0);
-	try {
-		return await task();
-	} finally {
-		releaseCurrent();
-		if (slackSendQueues.get(key) === queuedCurrent) slackSendQueues.delete(key);
-	}
+	return await slackSendQueue.enqueue(key, task);
 }
 function createSlackDmCacheKey(params) {
 	return `${params.accountId ?? "default"}:${createSlackTokenCacheKey(params.token)}:${params.recipientId}`;
@@ -551,6 +412,268 @@ async function resolveChannelId(client, recipient, params) {
 		cacheHit: false
 	};
 }
+async function resolveSlackDmChannelId(params) {
+	return (await resolveChannelId(params.client, {
+		kind: "user",
+		id: params.userId
+	}, {
+		accountId: params.accountId,
+		token: params.token
+	})).channelId;
+}
+function createSlackDeliveryMetadataId(queueId) {
+	const normalized = normalizeOptionalString(queueId);
+	if (!normalized) return;
+	return createHash("sha256").update(normalized).digest("base64url");
+}
+function createSlackDeliveryMetadataSignature(params) {
+	return createHmac("sha256", params.queueId).update(JSON.stringify([
+		SLACK_DELIVERY_METADATA_EVENT,
+		params.channelId,
+		params.threadTs ?? "",
+		params.partIndex,
+		params.partCount
+	])).digest("base64url");
+}
+function matchesSlackDeliveryMetadataSignature(actual, expected) {
+	if (typeof actual !== "string" || actual.length !== expected.length) return false;
+	return timingSafeEqual(Buffer.from(actual), Buffer.from(expected));
+}
+function withSlackDeliveryMetadata(metadata, params) {
+	const queueId = normalizeOptionalString(params.queueId);
+	const deliveryId = createSlackDeliveryMetadataId(queueId);
+	if (!queueId || !deliveryId) return metadata;
+	const marker = {
+		[SLACK_DELIVERY_METADATA_KEY]: deliveryId,
+		[SLACK_DELIVERY_METADATA_PART_INDEX_KEY]: params.partIndex,
+		[SLACK_DELIVERY_METADATA_PART_COUNT_KEY]: params.partCount,
+		[SLACK_DELIVERY_METADATA_SIGNATURE_KEY]: createSlackDeliveryMetadataSignature({
+			queueId,
+			channelId: params.channelId,
+			threadTs: params.threadTs,
+			partIndex: params.partIndex,
+			partCount: params.partCount
+		})
+	};
+	if (!metadata) return {
+		event_type: SLACK_DELIVERY_METADATA_EVENT,
+		event_payload: marker
+	};
+	return {
+		...metadata,
+		event_payload: {
+			...metadata.event_payload,
+			...marker
+		}
+	};
+}
+function formatSlackTimestampFromMs(ms) {
+	return (Math.max(0, ms) / 1e3).toFixed(6);
+}
+function asSlackConversationMessages(response) {
+	return Array.isArray(response.messages) ? response.messages.filter((message) => typeof message === "object" && message !== null && !Array.isArray(message)) : [];
+}
+const SLACK_RECONCILIATION_EVIDENCE_RANK = {
+	none: 0,
+	partial: 1,
+	conflict: 2,
+	complete: 3
+};
+function findSlackConversationDeliveryParts(params) {
+	const matches = [];
+	for (const message of params.messages) {
+		if (!message.metadata || typeof message.metadata !== "object" || Array.isArray(message.metadata)) continue;
+		const eventPayload = message.metadata.event_payload;
+		if (!eventPayload || typeof eventPayload !== "object" || Array.isArray(eventPayload)) continue;
+		const marker = eventPayload;
+		if (marker[SLACK_DELIVERY_METADATA_KEY] !== params.deliveryId) continue;
+		const partIndex = marker[SLACK_DELIVERY_METADATA_PART_INDEX_KEY];
+		const partCount = marker[SLACK_DELIVERY_METADATA_PART_COUNT_KEY];
+		if (typeof partIndex !== "number" || !Number.isInteger(partIndex) || typeof partCount !== "number" || !Number.isInteger(partCount) || partIndex < 0 || partCount <= 0 || partIndex >= partCount) continue;
+		const expectedSignature = createSlackDeliveryMetadataSignature({
+			queueId: params.queueId,
+			channelId: params.channelId,
+			threadTs: params.threadTs,
+			partIndex,
+			partCount
+		});
+		if (!matchesSlackDeliveryMetadataSignature(marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY], expectedSignature)) continue;
+		const messageId = typeof message.ts === "string" ? normalizeSlackThreadTsCandidate(message.ts) : void 0;
+		if (!messageId) continue;
+		const threadTs = typeof message.thread_ts === "string" ? normalizeSlackThreadTsCandidate(message.thread_ts) : void 0;
+		matches.push({
+			messageId,
+			partIndex,
+			partCount,
+			...threadTs ? { threadTs } : {}
+		});
+	}
+	return matches;
+}
+async function scanSlackConversationForDelivery(params) {
+	const threadTs = params.threadTs;
+	let cursor;
+	let expectedPartCount;
+	const deliveryParts = /* @__PURE__ */ new Map();
+	for (let page = 0; page < SLACK_RECONCILE_MAX_PAGES; page += 1) {
+		const response = threadTs ? await withSlackDnsRequestRetry("conversations.replies", () => params.client.conversations.replies({
+			channel: params.channelId,
+			ts: threadTs,
+			oldest: params.oldest,
+			latest: params.latest,
+			include_all_metadata: true,
+			limit: SLACK_RECONCILE_LIMIT,
+			...cursor ? { cursor } : {}
+		})) : await withSlackDnsRequestRetry("conversations.history", () => params.client.conversations.history({
+			channel: params.channelId,
+			oldest: params.oldest,
+			latest: params.latest,
+			include_all_metadata: true,
+			limit: SLACK_RECONCILE_LIMIT,
+			...cursor ? { cursor } : {}
+		}));
+		const matches = findSlackConversationDeliveryParts({
+			messages: asSlackConversationMessages(response),
+			queueId: params.queueId,
+			deliveryId: params.deliveryId,
+			channelId: params.channelId,
+			...threadTs ? { threadTs } : {}
+		});
+		for (const match of matches) {
+			expectedPartCount ??= match.partCount;
+			const existing = deliveryParts.get(match.partIndex);
+			if (expectedPartCount !== match.partCount || existing && existing.messageId !== match.messageId) return {
+				reconciliation: {
+					status: "unresolved",
+					error: "Slack history contains conflicting durable delivery markers",
+					retryable: false
+				},
+				evidence: "conflict"
+			};
+			deliveryParts.set(match.partIndex, match);
+		}
+		if (expectedPartCount !== void 0 && deliveryParts.size === expectedPartCount) {
+			const orderedParts = Array.from({ length: expectedPartCount }, (_, index) => deliveryParts.get(index));
+			if (orderedParts.some((part) => !part)) return {
+				reconciliation: {
+					status: "unresolved",
+					error: "Slack history contains an invalid durable delivery marker set",
+					retryable: false
+				},
+				evidence: "conflict"
+			};
+			const completeParts = orderedParts;
+			const reconciledThreadTs = completeParts[0]?.threadTs ?? params.threadTs;
+			const platformMessageIds = completeParts.map((part) => part.messageId);
+			return {
+				reconciliation: {
+					status: "sent",
+					messageId: platformMessageIds[0],
+					receipt: createSlackSendReceipt({
+						platformMessageIds,
+						channelId: params.channelId,
+						kind: "text",
+						...reconciledThreadTs ? { threadTs: reconciledThreadTs } : {}
+					})
+				},
+				evidence: "complete"
+			};
+		}
+		const nextCursor = normalizeOptionalString(response.response_metadata?.next_cursor);
+		if (!nextCursor) {
+			if (response.has_more === true) break;
+			return {
+				reconciliation: {
+					status: "unresolved",
+					error: deliveryParts.size > 0 ? "Slack history contains an incomplete durable delivery marker set" : "Slack history contains no exact durable delivery marker",
+					retryable: params.retryCount < 2
+				},
+				evidence: deliveryParts.size > 0 ? "partial" : "none"
+			};
+		}
+		cursor = nextCursor;
+	}
+	return {
+		reconciliation: {
+			status: "unresolved",
+			error: "Slack unknown-send reconciliation exceeded its history page budget",
+			retryable: params.retryCount < 2
+		},
+		evidence: deliveryParts.size > 0 ? "partial" : "none"
+	};
+}
+async function reconcileSlackUnknownSend(ctx, opts) {
+	const account = resolveSlackAccount({
+		cfg: requireRuntimeConfig(ctx.cfg, "Slack delivery reconciliation"),
+		accountId: ctx.accountId ?? void 0
+	});
+	const deliveryId = createSlackDeliveryMetadataId(ctx.queueId);
+	if (!deliveryId) return {
+		status: "unresolved",
+		error: "Slack unknown-send reconciliation requires a durable delivery id",
+		retryable: false
+	};
+	const readToken = resolveSlackOperationToken(account, "read");
+	if (!readToken) return {
+		status: "unresolved",
+		error: `Slack read token missing for account "${account.accountId}"`,
+		retryable: false
+	};
+	const recipient = parseRecipient(ctx.to);
+	const userRecipient = isSlackUserRecipient(recipient);
+	const writeToken = resolveSlackOperationToken(account, "write");
+	if (userRecipient && !writeToken) return {
+		status: "unresolved",
+		error: `Slack write token missing for direct-message reconciliation on account "${account.accountId}"`,
+		retryable: false
+	};
+	const readClient = opts?.client ?? createSlackWebClient(readToken);
+	const writeClient = opts?.client ?? (writeToken ? getSlackWriteClient(writeToken) : void 0);
+	const payloadReplyToId = ctx.payloads[0]?.replyToId;
+	const threadTs = resolveSlackThreadTsValue({
+		replyToId: Object.hasOwn(ctx, "effectiveReplyToId") ? normalizeOptionalString(ctx.effectiveReplyToId) : payloadReplyToId != null ? normalizeOptionalString(payloadReplyToId) : ctx.replyToMode === "off" ? void 0 : normalizeOptionalString(ctx.replyToId),
+		threadId: ctx.threadId
+	});
+	const searchStartedAt = ctx.platformSendStartedAt ?? ctx.enqueuedAt;
+	const oldest = formatSlackTimestampFromMs(searchStartedAt - SLACK_RECONCILE_LOOKBACK_MS - SLACK_RECONCILE_CLOCK_SKEW_MS);
+	const latest = formatSlackTimestampFromMs(searchStartedAt + SLACK_RECONCILE_CLOCK_SKEW_MS);
+	try {
+		const channelClient = userRecipient ? writeClient : readClient;
+		const channelToken = userRecipient ? writeToken : readToken;
+		if (!channelClient || !channelToken) throw new Error(`Slack channel resolution token missing for account "${account.accountId}"`);
+		const { channelId } = await resolveChannelId(channelClient, recipient, {
+			accountId: account.accountId,
+			token: channelToken
+		});
+		const lookupClients = opts?.client ? [opts.client] : [readClient, ...writeClient && writeToken !== readToken ? [writeClient] : []];
+		let lookupError;
+		let bestUnresolvedScan;
+		for (const lookupClient of lookupClients) try {
+			const scan = await scanSlackConversationForDelivery({
+				client: lookupClient,
+				channelId,
+				...threadTs ? { threadTs } : {},
+				oldest,
+				latest,
+				queueId: ctx.queueId,
+				deliveryId,
+				retryCount: ctx.retryCount
+			});
+			if (scan.reconciliation.status === "sent") return scan.reconciliation;
+			if (!bestUnresolvedScan || SLACK_RECONCILIATION_EVIDENCE_RANK[scan.evidence] > SLACK_RECONCILIATION_EVIDENCE_RANK[bestUnresolvedScan.evidence]) bestUnresolvedScan = scan;
+		} catch (err) {
+			lookupError = err;
+		}
+		if (bestUnresolvedScan) return bestUnresolvedScan.reconciliation;
+		throw lookupError;
+	} catch (err) {
+		return {
+			status: "unresolved",
+			error: readSlackRequestErrorMessage(enrichSlackWebApiError(err)),
+			retryable: ctx.retryCount < 3
+		};
+	}
+}
 async function uploadSlackFile(params) {
 	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
 		maxBytes: params.maxBytes,
@@ -582,6 +705,7 @@ async function uploadSlackFile(params) {
 	} finally {
 		await release();
 	}
+	await params.onPlatformSendDispatch?.();
 	const completeResp = await withSlackDnsRequestRetry("files.completeUploadExternal", () => params.client.files.completeUploadExternal({
 		files: [{
 			id: uploadFileId,
@@ -658,7 +782,7 @@ async function sendMessageSlackQueuedInner(params) {
 		unfurlLinks: account.config.unfurlLinks,
 		unfurlMedia: account.config.unfurlMedia
 	};
-	const directUserPostChannelId = resolveDirectUserPostChannelId({
+	const directUserPostChannelId = opts.deliveryQueueId ? void 0 : resolveDirectUserPostChannelId({
 		recipient,
 		hasMedia: Boolean(opts.mediaUrl),
 		...opts.threadTs ? { threadTs: opts.threadTs } : {}
@@ -667,12 +791,18 @@ async function sendMessageSlackQueuedInner(params) {
 		accountId: account.accountId,
 		token
 	});
+	const reportDelivery = async (result) => {
+		await opts.onDeliveryResult?.(result);
+		return result;
+	};
 	if (blocks) {
 		if (opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
-		const response = await postSlackMessageBestEffort({
+		const fallbackText = truncateSlackText(trimmedMessage || buildSlackBlocksFallbackText(blocks), SLACK_TEXT_LIMIT);
+		await opts.onPlatformSendDispatch?.();
+		const { response } = await postSlackMessageBestEffort({
 			client,
 			channelId,
-			text: truncateSlackText(trimmedMessage || buildSlackBlocksFallbackText(blocks), SLACK_TEXT_LIMIT),
+			text: fallbackText,
 			threadTs: opts.threadTs,
 			replyBroadcast: opts.replyBroadcast,
 			identity,
@@ -683,7 +813,7 @@ async function sendMessageSlackQueuedInner(params) {
 		const messageId = response.ts ?? "unknown";
 		const deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
 		const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-		return {
+		return await reportDelivery({
 			messageId,
 			channelId: deliveredChannelId,
 			threadTs: deliveredThreadTs,
@@ -693,7 +823,7 @@ async function sendMessageSlackQueuedInner(params) {
 				kind: "card",
 				threadTs: deliveredThreadTs
 			})
-		};
+		});
 	}
 	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: SLACK_TEXT_LIMIT });
 	const chunkLimit = Math.min(textLimit, SLACK_TEXT_LIMIT);
@@ -723,26 +853,63 @@ async function sendMessageSlackQueuedInner(params) {
 			mediaReadFile: opts.mediaReadFile,
 			caption: firstChunk,
 			threadTs: opts.threadTs,
-			maxBytes: mediaMaxBytes
+			maxBytes: mediaMaxBytes,
+			onPlatformSendDispatch: opts.onPlatformSendDispatch
 		});
 		sentMessageIds.push(lastMessageId);
+		await reportDelivery({
+			messageId: lastMessageId,
+			channelId,
+			threadTs: normalizeSlackThreadTsCandidate(opts.threadTs),
+			receipt: createSlackSendReceipt({
+				platformMessageIds: [lastMessageId],
+				channelId,
+				kind: "media",
+				threadTs: normalizeSlackThreadTsCandidate(opts.threadTs)
+			})
+		});
 		chunksToPost = rest;
 	} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
-	for (const chunk of chunksToPost) {
-		const response = await postSlackMessageBestEffort({
+	let sendIdentity = identity;
+	for (const [partIndex, chunk] of chunksToPost.entries()) {
+		const baseMetadata = sentMessageIds.length === 0 ? opts.metadata : void 0;
+		const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
+			queueId: opts.deliveryQueueId,
+			channelId,
+			threadTs: opts.threadTs,
+			partIndex,
+			partCount: chunksToPost.length
+		});
+		if (partIndex === 0 && !opts.mediaUrl) await opts.onPlatformSendDispatch?.();
+		const posted = await postSlackMessageBestEffort({
 			client,
 			channelId,
 			text: chunk,
 			threadTs: opts.threadTs,
 			replyBroadcast: sentMessageIds.length === 0 ? opts.replyBroadcast : void 0,
-			identity,
-			metadata: sentMessageIds.length === 0 ? opts.metadata : void 0,
+			identity: sendIdentity,
+			metadata,
 			unfurl
 		});
+		const response = posted.response;
+		sendIdentity = posted.identity;
 		lastMessageId = response.ts ?? lastMessageId;
 		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
 		canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-		if (response.ts) sentMessageIds.push(response.ts);
+		if (response.ts) {
+			sentMessageIds.push(response.ts);
+			await reportDelivery({
+				messageId: response.ts,
+				channelId: deliveredChannelId,
+				threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs),
+				receipt: createSlackSendReceipt({
+					platformMessageIds: [response.ts],
+					channelId: deliveredChannelId,
+					kind: "text",
+					threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs)
+				})
+			});
+		}
 	}
 	const messageId = lastMessageId || "unknown";
 	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
@@ -759,4 +926,4 @@ async function sendMessageSlackQueuedInner(params) {
 	};
 }
 //#endregion
-export { hasSlackThreadParticipationWithPersistence as a, normalizeSlackOutboundText as c, hasSlackThreadParticipation as i, buildSlackBlocksFallbackText as l, setSlackDefaultSendIdentity as n, recordSlackThreadParticipation as o, clearSlackThreadParticipationCache as r, markdownToSlackMrkdwnChunks as s, sendMessageSlack as t };
+export { clearSlackThreadParticipationCache as a, recordSlackThreadParticipation as c, setSlackDefaultSendIdentity as i, buildSlackBlocksFallbackText as l, resolveSlackDmChannelId as n, hasSlackThreadParticipation as o, sendMessageSlack as r, hasSlackThreadParticipationWithPersistence as s, reconcileSlackUnknownSend as t };