@openclaw/discord 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/subagent-progress-FPLqBY1s.js

@@ -0,0 +1,110 @@
+import { c as resolveDiscordAccount, u as resolveDiscordAccountConfig } from "./accounts-DNl-oCEw.js";
+import { i as removeReactionDiscord } from "./send.reactions-gmJ6yFPo.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
+import { listAgentIds, resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { DEFAULT_EMOJIS } from "openclaw/plugin-sdk/channel-feedback";
+//#region extensions/discord/src/subagent-progress.ts
+const PROGRESS_STORE_TTL_MS = 10080 * 6e4;
+const MAX_TRACKED_RUNS = 4096;
+const RETRY_BASE_DELAY_MS = 1e3;
+const RETRY_MAX_DELAY_MS = 60 * 6e4;
+const RETRY_MAX_ATTEMPTS = 12;
+const HISTORICAL_RUNNING_EMOJIS = /* @__PURE__ */ new Set([
+	"1️⃣",
+	"2️⃣",
+	"3️⃣",
+	"4️⃣",
+	"5️⃣",
+	"6️⃣",
+	"7️⃣",
+	"8️⃣",
+	"9️⃣",
+	"🔟"
+]);
+const recoveryRetries = /* @__PURE__ */ new Map();
+function logFailure(api, action, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	api.logger.debug?.(`discord retired subagent progress ${action} failed: ${message}`);
+}
+function reservedReactionEmojis(api, accountAckReaction) {
+	const reserved = new Set(Object.values(DEFAULT_EMOJIS));
+	for (const emoji of [api.config.messages?.ackReaction, accountAckReaction]) if (emoji?.trim()) reserved.add(emoji.trim());
+	for (const agentId of listAgentIds(api.config)) {
+		const emoji = resolveAgentConfig(api.config, agentId)?.identity?.emoji?.trim();
+		if (emoji) reserved.add(emoji);
+	}
+	return reserved;
+}
+function clearRecoveryRetry(api) {
+	const retry = recoveryRetries.get(api);
+	if (retry?.timer) clearTimeout(retry.timer);
+	recoveryRetries.delete(api);
+}
+function scheduleRecoveryRetry(api) {
+	const retry = recoveryRetries.get(api) ?? { attempts: 0 };
+	if (retry.timer || retry.attempts >= RETRY_MAX_ATTEMPTS) return;
+	const delayMs = Math.min(RETRY_BASE_DELAY_MS * 2 ** retry.attempts, RETRY_MAX_DELAY_MS);
+	retry.attempts += 1;
+	retry.timer = setTimeout(() => {
+		retry.timer = void 0;
+		recoverDiscordSubagentProgress(api);
+	}, delayMs);
+	retry.timer.unref?.();
+	recoveryRetries.set(api, retry);
+}
+async function cleanPersistedReaction(api, store, entry) {
+	try {
+		if (entry.value.accountId !== DEFAULT_ACCOUNT_ID && !resolveDiscordAccountConfig(api.config, entry.value.accountId)) return false;
+		const account = resolveDiscordAccount({
+			cfg: api.config,
+			accountId: entry.value.accountId
+		});
+		if (!account.enabled || account.tokenStatus !== "available") return false;
+		const emoji = entry.value.runningEmoji;
+		if (emoji && HISTORICAL_RUNNING_EMOJIS.has(emoji) && !reservedReactionEmojis(api, account.config.ackReaction).has(emoji)) await removeReactionDiscord(entry.value.channelId, entry.value.messageId, emoji, {
+			cfg: api.config,
+			accountId: entry.value.accountId
+		});
+		await store.consume(entry.key);
+		return true;
+	} catch (error) {
+		logFailure(api, "startup cleanup", error);
+		return false;
+	}
+}
+async function recoverDiscordSubagentProgressImpl(api) {
+	let store;
+	try {
+		store = api.runtime.state.openKeyedStore({
+			namespace: "subagent-progress",
+			maxEntries: MAX_TRACKED_RUNS,
+			overflowPolicy: "reject-new",
+			defaultTtlMs: PROGRESS_STORE_TTL_MS
+		});
+	} catch (error) {
+		logFailure(api, "state store open", error);
+		scheduleRecoveryRetry(api);
+		return;
+	}
+	let entries;
+	try {
+		entries = await store.entries();
+	} catch (error) {
+		logFailure(api, "startup recovery list", error);
+		scheduleRecoveryRetry(api);
+		return;
+	}
+	let retryNeeded = false;
+	for (const entry of entries) if (!await cleanPersistedReaction(api, store, entry)) retryNeeded = true;
+	if (retryNeeded) scheduleRecoveryRetry(api);
+	else clearRecoveryRetry(api);
+}
+function resetDiscordSubagentProgressForTest() {
+	for (const [api, retry] of recoveryRetries) {
+		if (retry.timer) clearTimeout(retry.timer);
+		recoveryRetries.delete(api);
+	}
+}
+const recoverDiscordSubagentProgress = Object.assign(recoverDiscordSubagentProgressImpl, { resetForTest: resetDiscordSubagentProgressForTest });
+//#endregion
+export { recoverDiscordSubagentProgress };

package/dist/{system-events-DdUqf91B.js → system-events-Nuwoq_au.js}

@@ -1,5 +1,5 @@
-import { d as discord_exports } from "./chunk-DX4jpFQP.js";
-import { x as formatDiscordUserTag } from "./allow-list-DzKrtfah.js";
+import { p as discord_exports } from "./retry-DNsVTeTo.js";
+import { x as formatDiscordUserTag } from "./allow-list-BDMimASD.js";
 //#region extensions/discord/src/monitor/system-events.ts
 function resolveDiscordSystemEvent(message, location) {
 	switch (message.type) {

package/dist/{target-resolver-C3s_2m0t.js → target-resolver-DIXShHaZ.js}

@@ -1,6 +1,6 @@
-import { Yt as __exportAll, a as allowFromContainsDiscordUserId, l as parseDiscordTarget } from "./chunk-DX4jpFQP.js";
-import { c as resolveDiscordAccountAllowFrom, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-Bw5Ephzv.js";
+import { en as __exportAll, l as allowFromContainsDiscordUserId } from "./retry-DNsVTeTo.js";
+import { c as resolveDiscordAccount, k as parseDiscordTarget, l as resolveDiscordAccountAllowFrom } from "./accounts-DNl-oCEw.js";
+import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-Df0NbFJB.js";
 import { buildMessagingTarget } from "openclaw/plugin-sdk/channel-targets";
 //#region extensions/discord/src/send-target-parsing.ts
 const parseDiscordSendTarget = (raw, options = {}) => parseDiscordTarget(raw, options);

package/dist/targets-B2pf49zc.js

@@ -0,0 +1,3 @@
+import "./accounts-DNl-oCEw.js";
+import "./target-resolver-DIXShHaZ.js";
+export {};

package/dist/{thread-bindings-C-M-ly7P.js → thread-bindings-VlymUnbz.js}

@@ -1,14 +1,14 @@
-import { Yt as __exportAll, l as parseDiscordTarget } from "./chunk-DX4jpFQP.js";
-import "./targets-Dv_RN7vT.js";
-import { C as resolveThreadBindingInactivityExpiresAt, E as saveBindingsToDisk, S as resolveThreadBindingIdleTimeoutMs$1, T as resolveThreadBindingMaxAgeMs$1, h as refreshUnboundThreadWebhookIdentity, k as shouldPersistBindingMutations, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeExpiresAt } from "./thread-bindings.state-Cgi5uRn-.js";
-import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-DAIlp7Px.js";
-import { S as resolveThreadBindingThreadName, _ as resolveThreadBindingPersona, s as resolveChannelIdForBinding, v as resolveThreadBindingPersonaFromRecord, x as resolveThreadBindingIntroText, y as formatThreadBindingDurationLabel } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { i as testing, n as createThreadBindingManager, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-DYvSlrva.js";
+import { en as __exportAll } from "./retry-DNsVTeTo.js";
+import { k as parseDiscordTarget } from "./accounts-DNl-oCEw.js";
+import "./targets-B2pf49zc.js";
+import { C as resolveThreadBindingMaxAgeExpiresAt, O as shouldPersistBindingMutations, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, h as refreshUnboundThreadWebhookIdentity, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-D8OMdk4O.js";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-CJb-BpPL.js";
+import { _ as resolveThreadBindingThreadName, g as resolveThreadBindingIntroText, h as formatThreadBindingDurationLabel, m as resolveThreadBindingPersonaFromRecord, n as createThreadBindingManager, o as resolveChannelIdForBinding, p as resolveThreadBindingPersona, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-CngsgErq.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalLowercaseString, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
 import { readAcpSessionEntry } from "openclaw/plugin-sdk/acp-runtime";
-import pMap from "p-map";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.config.ts
 function resolveDiscordThreadBindingIdleTimeoutMs(params) {
 	const accountId = normalizeAccountId(params.accountId);
@@ -161,27 +161,29 @@ async function reconcileAcpThreadBindingsOnStartup(params) {
 		});
 	}
 	if (params.healthProbe && probeTargets.length > 0) {
-		const probeResults = await pMap(probeTargets, async ({ binding, sessionKey, session }) => {
-			try {
-				return {
-					binding,
-					status: (await params.healthProbe?.({
-						cfg: params.cfg,
-						accountId: manager.accountId,
-						sessionKey,
+		const { results: probeResults } = await runTasksWithConcurrency({
+			tasks: probeTargets.map(({ binding, sessionKey, session }) => async () => {
+				try {
+					return {
 						binding,
-						session
-					}))?.status ?? "uncertain"
-				};
-			} catch {
-				return {
-					binding,
-					status: "uncertain"
-				};
-			}
-		}, {
-			concurrency: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
-			stopOnError: true
+						status: (await params.healthProbe?.({
+							cfg: params.cfg,
+							accountId: manager.accountId,
+							sessionKey,
+							binding,
+							session
+						}))?.status ?? "uncertain"
+					};
+				} catch {
+					return {
+						binding,
+						status: "uncertain"
+					};
+				}
+			}),
+			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
+			errorMode: "stop",
+			throwOnError: true
 		});
 		for (const probeResult of probeResults) if (probeResult.status === "stale") staleBindings.push(probeResult.binding);
 	}
@@ -230,7 +232,6 @@ var thread_bindings_exports = /* @__PURE__ */ __exportAll({
 	resolveThreadBindingsEnabled: () => resolveThreadBindingsEnabled,
 	setThreadBindingIdleTimeoutBySessionKey: () => setThreadBindingIdleTimeoutBySessionKey,
 	setThreadBindingMaxAgeBySessionKey: () => setThreadBindingMaxAgeBySessionKey,
-	testing: () => testing,
 	unbindThreadBindingsBySessionKey: () => unbindThreadBindingsBySessionKey
 });
 //#endregion

package/dist/{thread-bindings.manager-DYvSlrva.js → thread-bindings.manager-CngsgErq.js}

@@ -1,13 +1,252 @@
-import { Yt as __exportAll, u as resolveDiscordChannelId, yt as getChannel } from "./chunk-DX4jpFQP.js";
-import { F as createDiscordRestClient } from "./send.shared-jpvAG_u6.js";
-import { C as resolveThreadBindingInactivityExpiresAt, D as setBindingRecord, E as saveBindingsToDisk, O as shouldDefaultPersist, S as resolveThreadBindingIdleTimeoutMs$1, T as resolveThreadBindingMaxAgeMs$1, _ as rememberThreadBindingToken, b as resolveBindingIdsForSession, c as ensureBindingsLoaded, f as normalizeTargetKind, h as refreshUnboundThreadWebhookIdentity, l as forgetThreadBindingToken, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, p as normalizeThreadBindingDurationMs, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeExpiresAt, x as resolveBindingRecordKey, y as resetThreadBindingsForTests } from "./thread-bindings.state-Cgi5uRn-.js";
-import { S as resolveThreadBindingThreadName, a as isThreadArchived, b as resolveThreadBindingFarewellText, c as summarizeDiscordError, i as isDiscordThreadGoneError, l as DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS, n as createWebhookForChannel, o as maybeSendBindingMessage, r as findReusableWebhook, s as resolveChannelIdForBinding, t as createThreadForBinding, u as THREAD_BINDINGS_SWEEP_INTERVAL_MS } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { en as __exportAll, ft as createChannelWebhook, wt as getChannel } from "./retry-DNsVTeTo.js";
+import { A as resolveDiscordChannelId } from "./accounts-DNl-oCEw.js";
+import { F as createDiscordRestClient } from "./send.shared-B3fpaLWJ.js";
+import { t as sendMessageDiscord } from "./send.outbound-HIkgji_7.js";
+import { i as sendWebhookMessageDiscord, o as createThreadDiscord } from "./send-rQIffSYu.js";
+import { A as toReusableWebhookKey, C as resolveThreadBindingMaxAgeExpiresAt, D as shouldDefaultPersist, E as setBindingRecord, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, _ as rememberThreadBindingToken, b as resolveBindingRecordKey, c as ensureBindingsLoaded, f as normalizeTargetKind, g as rememberReusableWebhook, h as refreshUnboundThreadWebhookIdentity, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as forgetThreadBindingToken, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, p as normalizeThreadBindingDurationMs, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1, y as resolveBindingIdsForSession } from "./thread-bindings.state-D8OMdk4O.js";
+import { ChannelType } from "discord-api-types/v10";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { SYSTEM_MARK } from "openclaw/plugin-sdk/text-chunking";
+import { formatThreadBindingDurationLabel, registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, resolveThreadBindingFarewellText, resolveThreadBindingIntroText, resolveThreadBindingThreadName, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveSessionAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
+//#region extensions/discord/src/monitor/thread-bindings.persona.ts
+const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
+function normalizePersonaLabel(value) {
+	if (!value) return;
+	return value.replace(/\s+/g, " ").trim() || void 0;
+}
+function resolveThreadBindingPersona(params) {
+	return truncateUtf16Safe(`${SYSTEM_MARK} ${normalizePersonaLabel(params.label) || normalizePersonaLabel(params.agentId) || "agent"}`, THREAD_BINDING_PERSONA_MAX_CHARS);
+}
+function resolveThreadBindingPersonaFromRecord(record) {
+	return resolveThreadBindingPersona({
+		label: record.label,
+		agentId: record.agentId
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/channel-access.ts
+function readDiscordChannelPropertySafe(channel, key) {
+	if (!channel || typeof channel !== "object") return;
+	try {
+		if (!(key in channel)) return;
+		return channel[key];
+	} catch {
+		return;
+	}
+}
+function resolveDiscordChannelStringPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "string" ? value : void 0;
+}
+function resolveDiscordChannelNumberPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "number" ? value : void 0;
+}
+const DISCORD_CHANNEL_SNAKE_CASE_ALIASES = {
+	ownerId: "owner_id",
+	parentId: "parent_id"
+};
+function resolveDiscordChannelStringWithAliasSafe(channel, camelKey) {
+	const camelValue = resolveDiscordChannelStringPropertySafe(channel, camelKey);
+	if (camelValue !== void 0) return camelValue;
+	const snakeKey = DISCORD_CHANNEL_SNAKE_CASE_ALIASES[camelKey];
+	if (!snakeKey) return;
+	const directSnakeValue = resolveDiscordChannelStringPropertySafe(channel, snakeKey);
+	if (directSnakeValue !== void 0) return directSnakeValue;
+	return resolveDiscordChannelStringPropertySafe(readDiscordChannelPropertySafe(channel, "rawData"), snakeKey);
+}
+function resolveDiscordChannelNameSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "name");
+}
+function resolveDiscordChannelIdSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "id");
+}
+function resolveDiscordChannelTopicSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "topic");
+}
+function resolveDiscordChannelParentIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "parentId");
+}
+function resolveDiscordChannelOwnerIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "ownerId");
+}
+function resolveDiscordChannelParentSafe(channel) {
+	return readDiscordChannelPropertySafe(channel, "parent");
+}
+function resolveDiscordChannelInfoSafe(channel) {
+	const parent = resolveDiscordChannelParentSafe(channel);
+	return {
+		name: resolveDiscordChannelNameSafe(channel),
+		topic: resolveDiscordChannelTopicSafe(channel),
+		type: resolveDiscordChannelNumberPropertySafe(channel, "type"),
+		parentId: resolveDiscordChannelParentIdSafe(channel),
+		ownerId: resolveDiscordChannelOwnerIdSafe(channel),
+		parentName: resolveDiscordChannelNameSafe(parent)
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.types.ts
+const THREAD_BINDINGS_SWEEP_INTERVAL_MS = 12e4;
+const DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS = 1440 * 60 * 1e3;
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.discord-api.ts
+function buildThreadTarget(threadId) {
+	return /^(channel:|user:)/i.test(threadId) ? threadId : `channel:${threadId}`;
+}
+function isThreadArchived(raw) {
+	if (!raw || typeof raw !== "object") return false;
+	const asRecord = raw;
+	if (asRecord.archived === true) return true;
+	if (asRecord.thread_metadata?.archived === true) return true;
+	if (asRecord.threadMetadata?.archived === true) return true;
+	return false;
+}
+function isThreadChannelType(type) {
+	return type === ChannelType.PublicThread || type === ChannelType.PrivateThread || type === ChannelType.AnnouncementThread;
+}
+function normalizeDiscordBindingChannelId(raw) {
+	const trimmed = normalizeOptionalString(raw) ?? "";
+	if (!trimmed) return null;
+	try {
+		return resolveDiscordChannelId(trimmed);
+	} catch {
+		return null;
+	}
+}
+function summarizeDiscordError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint" || typeof err === "symbol") return String(err);
+	return "error";
+}
+function extractNumericDiscordErrorValue(value) {
+	return parseStrictNonNegativeInteger(value);
+}
+function extractDiscordErrorStatus(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.status) ?? extractNumericDiscordErrorValue(candidate.statusCode) ?? extractNumericDiscordErrorValue(candidate.response?.status);
+}
+function extractDiscordErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.code) ?? extractNumericDiscordErrorValue(candidate.rawError?.code) ?? extractNumericDiscordErrorValue(candidate.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.data?.code);
+}
+function isDiscordThreadGoneError(err) {
+	if (extractDiscordErrorCode(err) === 10003) return true;
+	const status = extractDiscordErrorStatus(err);
+	return status === 404 || status === 403;
+}
+async function maybeSendBindingMessage(params) {
+	const text = params.text.trim();
+	if (!text) return;
+	const record = params.record;
+	if (params.preferWebhook !== false && record.webhookId && record.webhookToken) try {
+		await sendWebhookMessageDiscord(text, {
+			cfg: params.cfg,
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken,
+			accountId: record.accountId,
+			threadId: record.threadId,
+			username: resolveThreadBindingPersonaFromRecord(record)
+		});
+		return;
+	} catch (err) {
+		logVerbose(`discord thread binding webhook send failed: ${summarizeDiscordError(err)}`);
+	}
+	try {
+		await sendMessageDiscord(buildThreadTarget(record.threadId), text, {
+			cfg: params.cfg,
+			accountId: record.accountId
+		});
+	} catch (err) {
+		logVerbose(`discord thread binding fallback send failed: ${summarizeDiscordError(err)}`);
+	}
+}
+async function createWebhookForChannel(params) {
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const created = await createChannelWebhook(rest, params.channelId, { body: { name: "OpenClaw Agents" } });
+		const webhookId = normalizeOptionalString(created?.id) ?? "";
+		const webhookToken = normalizeOptionalString(created?.token) ?? "";
+		if (!webhookId || !webhookToken) return {};
+		return {
+			webhookId,
+			webhookToken
+		};
+	} catch (err) {
+		logVerbose(`discord thread binding webhook create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return {};
+	}
+}
+function findReusableWebhook(params) {
+	const reusableKey = toReusableWebhookKey({
+		accountId: params.accountId,
+		channelId: params.channelId
+	});
+	const cached = REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.get(reusableKey);
+	if (cached) return {
+		webhookId: cached.webhookId,
+		webhookToken: cached.webhookToken
+	};
+	for (const record of BINDINGS_BY_THREAD_ID.values()) {
+		if (record.accountId !== params.accountId) continue;
+		if (record.channelId !== params.channelId) continue;
+		if (!record.webhookId || !record.webhookToken) continue;
+		rememberReusableWebhook(record);
+		return {
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken
+		};
+	}
+	return {};
+}
+async function resolveChannelIdForBinding(params) {
+	const explicit = normalizeDiscordBindingChannelId(params.channelId);
+	if (explicit) return explicit;
+	const lookupThreadId = normalizeDiscordBindingChannelId(params.threadId);
+	if (!lookupThreadId) return null;
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const channel = await getChannel(rest, lookupThreadId);
+		const channelInfo = resolveDiscordChannelInfoSafe(channel);
+		const channelId = normalizeOptionalString(resolveDiscordChannelIdSafe(channel)) ?? "";
+		const type = channelInfo.type;
+		const parentId = normalizeOptionalString(channelInfo.parentId) ?? "";
+		if (parentId && isThreadChannelType(type)) return parentId;
+		return channelId || null;
+	} catch (err) {
+		logVerbose(`discord thread binding channel resolve failed for ${lookupThreadId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+async function createThreadForBinding(params) {
+	try {
+		return (normalizeOptionalString((await createThreadDiscord(params.channelId, { name: params.threadName }, {
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}))?.id) ?? "") || null;
+	} catch (err) {
+		logVerbose(`discord thread binding auto-thread create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+//#endregion
 //#region extensions/discord/src/monitor/thread-bindings.session-adapter.ts
 function normalizeChildBindingParentChannelId(raw) {
 	const trimmed = normalizeOptionalString(raw) ?? "";
@@ -77,7 +316,7 @@ function toSessionBindingRecord(record, defaults) {
 	};
 }
 function createThreadBindingSessionAdapter(params) {
-	const toRecord = (entry) => toSessionBindingRecord(entry, params.defaults);
+	const serializeBinding = (entry) => toSessionBindingRecord(entry, params.defaults);
 	return {
 		channel: "discord",
 		accountId: params.accountId,
@@ -120,13 +359,13 @@ function createThreadBindingSessionAdapter(params) {
 				introText,
 				metadata
 			});
-			return bound ? toRecord(bound) : null;
+			return bound ? serializeBinding(bound) : null;
 		},
-		listBySession: (targetSessionKey) => params.manager.listBySessionKey(targetSessionKey).map(toRecord),
+		listBySession: (targetSessionKey) => params.manager.listBySessionKey(targetSessionKey).map(serializeBinding),
 		resolveByConversation: (ref) => {
 			if (ref.channel !== "discord") return null;
 			const binding = params.manager.getByThreadId(ref.conversationId);
-			return binding ? toRecord(binding) : null;
+			return binding ? serializeBinding(binding) : null;
 		},
 		touch: (bindingId, at) => {
 			const threadId = resolveThreadBindingConversationIdFromBindingId({
@@ -144,7 +383,7 @@ function createThreadBindingSessionAdapter(params) {
 			if (input.targetSessionKey?.trim()) return params.manager.unbindBySessionKey({
 				targetSessionKey: input.targetSessionKey,
 				reason: input.reason
-			}).map(toRecord);
+			}).map(serializeBinding);
 			const threadId = resolveThreadBindingConversationIdFromBindingId({
 				accountId: params.accountId,
 				bindingId: input.bindingId
@@ -154,18 +393,16 @@ function createThreadBindingSessionAdapter(params) {
 				threadId,
 				reason: input.reason
 			});
-			return removed ? [toRecord(removed)] : [];
+			return removed ? [serializeBinding(removed)] : [];
 		}
 	};
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.manager.ts
 var thread_bindings_manager_exports = /* @__PURE__ */ __exportAll({
-	__testing: () => testing,
 	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
 	createThreadBindingManager: () => createThreadBindingManager,
-	getThreadBindingManager: () => getThreadBindingManager,
-	testing: () => testing
+	getThreadBindingManager: () => getThreadBindingManager
 });
 function registerManager(manager) {
 	MANAGERS_BY_ACCOUNT_ID.set(manager.accountId, manager);
@@ -173,7 +410,6 @@ function registerManager(manager) {
 function unregisterManager(accountId, manager) {
 	if (MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager) MANAGERS_BY_ACCOUNT_ID.delete(accountId);
 }
-const SWEEPERS_BY_ACCOUNT_ID = /* @__PURE__ */ new Map();
 function createNoopManager(accountIdRaw) {
 	return {
 		accountId: normalizeAccountId(accountIdRaw),
@@ -297,7 +533,6 @@ function createThreadBindingManager(params) {
 			}
 		}
 	};
-	SWEEPERS_BY_ACCOUNT_ID.set(accountId, runSweepOnce);
 	const manager = {
 		accountId,
 		getIdleTimeoutMs: () => idleTimeoutMs,
@@ -400,7 +635,10 @@ function createThreadBindingManager(params) {
 				threadId,
 				targetKind,
 				targetSessionKey,
-				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(existingValue?.agentId) ?? resolveAgentIdFromSessionKey(targetSessionKey, resolveDefaultAgentId(cfg)),
+				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(existingValue?.agentId) ?? resolveSessionAgentId({
+					config: cfg,
+					sessionKey: targetSessionKey
+				}),
 				label: normalizeOptionalString(bindParams.label) ?? normalizeOptionalString(existingValue?.label),
 				webhookId: webhookId || void 0,
 				webhookToken: webhookToken || void 0,
@@ -485,7 +723,6 @@ function createThreadBindingManager(params) {
 				clearInterval(sweepTimer);
 				sweepTimer = null;
 			}
-			SWEEPERS_BY_ACCOUNT_ID.delete(accountId);
 			unregisterManager(accountId, manager);
 			unregisterSessionBindingAdapter({
 				channel: "discord",
@@ -522,13 +759,5 @@ function getThreadBindingManager(accountId) {
 	const normalized = normalizeAccountId(accountId);
 	return MANAGERS_BY_ACCOUNT_ID.get(normalized) ?? null;
 }
-const testing = {
-	resolveThreadBindingThreadName,
-	resetThreadBindingsForTests,
-	runThreadBindingSweepForAccount: async (accountId) => {
-		const sweep = SWEEPERS_BY_ACCOUNT_ID.get(normalizeAccountId(accountId));
-		if (sweep) await sweep();
-	}
-};
 //#endregion
-export { thread_bindings_manager_exports as a, testing as i, createThreadBindingManager as n, getThreadBindingManager as r, createNoopThreadBindingManager as t };
+export { resolveThreadBindingThreadName as _, isThreadArchived as a, resolveDiscordChannelInfoSafe as c, resolveDiscordChannelParentSafe as d, resolveDiscordChannelTopicSafe as f, resolveThreadBindingIntroText as g, formatThreadBindingDurationLabel as h, thread_bindings_manager_exports as i, resolveDiscordChannelNameSafe as l, resolveThreadBindingPersonaFromRecord as m, createThreadBindingManager as n, resolveChannelIdForBinding as o, resolveThreadBindingPersona as p, getThreadBindingManager as r, resolveDiscordChannelIdSafe as s, createNoopThreadBindingManager as t, resolveDiscordChannelParentIdSafe as u };

package/dist/{thread-bindings.session-updates-DAIlp7Px.js → thread-bindings.session-updates-CJb-BpPL.js}

@@ -1,4 +1,4 @@
-import { D as setBindingRecord, E as saveBindingsToDisk, b as resolveBindingIdsForSession, c as ensureBindingsLoaded, k as shouldPersistBindingMutations, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-Cgi5uRn-.js";
+import { E as setBindingRecord, O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, y as resolveBindingIdsForSession } from "./thread-bindings.state-D8OMdk4O.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 //#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
 function normalizeNonNegativeMs(raw) {

package/dist/{thread-bindings.state-Cgi5uRn-.js → thread-bindings.state-D8OMdk4O.js}

@@ -1,7 +1,7 @@
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
 import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/channel-outbound";
+import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/outbound-echo-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.state.ts
 const THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.discordThreadBindingsState");
 let threadBindingsState;
@@ -223,7 +223,7 @@ function shouldPersistBindingMutations() {
 function toPersistedBindingRecord(record) {
 	const serialized = JSON.stringify(record);
 	if (!serialized) return { ...record };
-	return JSON.parse(serialized);
+	return normalizePersistedBinding(record.threadId, JSON.parse(serialized)) ?? { ...record };
 }
 function saveBindingsToDisk(params = {}) {
 	if (!params.force && !shouldPersistAnyBindingState()) return;
@@ -284,18 +284,5 @@ function resolveBindingIdsForSession(params) {
 	}
 	return out;
 }
-function resetThreadBindingsForTests() {
-	for (const manager of MANAGERS_BY_ACCOUNT_ID.values()) manager.stop();
-	MANAGERS_BY_ACCOUNT_ID.clear();
-	BINDINGS_BY_THREAD_ID.clear();
-	BINDINGS_BY_SESSION_KEY.clear();
-	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
-	TOKENS_BY_ACCOUNT_ID.clear();
-	PERSIST_BY_ACCOUNT_ID.clear();
-	THREAD_BINDINGS_STATE.loadedBindings = false;
-	THREAD_BINDINGS_STATE.loadedPersistentBindings = false;
-	THREAD_BINDINGS_STATE.persistenceAvailable = true;
-	THREAD_BINDINGS_STATE.lastPersistedAtMs = 0;
-}
 //#endregion
-export { toBindingRecordKey as A, resolveThreadBindingInactivityExpiresAt as C, setBindingRecord as D, saveBindingsToDisk as E, shouldDefaultPersist as O, resolveThreadBindingIdleTimeoutMs as S, resolveThreadBindingMaxAgeMs as T, rememberThreadBindingToken as _, THREAD_BINDINGS_MAX_ENTRIES as a, resolveBindingIdsForSession as b, ensureBindingsLoaded as c, normalizePersistedBinding as d, normalizeTargetKind as f, rememberReusableWebhook as g, refreshUnboundThreadWebhookIdentity as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toReusableWebhookKey as j, shouldPersistBindingMutations as k, forgetThreadBindingToken as l, normalizeThreadId as m, MANAGERS_BY_ACCOUNT_ID as n, THREAD_BINDINGS_NAMESPACE as o, normalizeThreadBindingDurationMs as p, PERSIST_BY_ACCOUNT_ID as r, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as s, BINDINGS_BY_THREAD_ID as t, getThreadBindingToken as u, removeBindingRecord as v, resolveThreadBindingMaxAgeExpiresAt as w, resolveBindingRecordKey as x, resetThreadBindingsForTests as y };
+export { toReusableWebhookKey as A, resolveThreadBindingMaxAgeExpiresAt as C, shouldDefaultPersist as D, setBindingRecord as E, shouldPersistBindingMutations as O, resolveThreadBindingInactivityExpiresAt as S, saveBindingsToDisk as T, rememberThreadBindingToken as _, THREAD_BINDINGS_MAX_ENTRIES as a, resolveBindingRecordKey as b, ensureBindingsLoaded as c, normalizePersistedBinding as d, normalizeTargetKind as f, rememberReusableWebhook as g, refreshUnboundThreadWebhookIdentity as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toBindingRecordKey as k, forgetThreadBindingToken as l, normalizeThreadId as m, MANAGERS_BY_ACCOUNT_ID as n, THREAD_BINDINGS_NAMESPACE as o, normalizeThreadBindingDurationMs as p, PERSIST_BY_ACCOUNT_ID as r, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as s, BINDINGS_BY_THREAD_ID as t, getThreadBindingToken as u, removeBindingRecord as v, resolveThreadBindingMaxAgeMs as w, resolveThreadBindingIdleTimeoutMs as x, resolveBindingIdsForSession as y };