@openclaw/discord 2026.9.6 → 2026.9.8

package/dist/.setup/{thread-bindings.manager-ve-i6oqt.mjs → thread-bindings.manager-DN-NissX.mjs}

@@ -1,19 +1,21 @@
-import { C as withDiscordRequestAuthority, Ut as __exportAll, pt as getChannel, tt as createChannelWebhook } from "./discord-BXpHW-cu.mjs";
-import { t as isDiscordThreadChannelType } from "./channel-type-DKnjV1XW.mjs";
-import { b as resolveDiscordChannelId, t as canFallbackDiscordWebhookSend } from "./retry-BEYkDy0P.mjs";
-import { P as createDiscordRestClient } from "./send.shared-VNvWfX2T.mjs";
-import { t as sendMessageDiscord } from "./send.outbound-QTyuFupn.mjs";
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
+import { C as withDiscordRequestAuthority, mt as getChannel, nt as createChannelWebhook } from "./discord-0xJYfdDD.mjs";
+import { t as isDiscordThreadChannelType } from "./channel-type-DRCrEMss.mjs";
+import { t as canFallbackDiscordWebhookSend, x as resolveDiscordChannelId } from "./retry-pz_cSha2.mjs";
+import { N as createDiscordRestClient } from "./send.shared-DGFkbkQR.mjs";
+import { t as sendMessageDiscord } from "./send.outbound-BISKnb-a.mjs";
 import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.mjs";
-import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-CIBzvXjS.mjs";
-import { C as resolveThreadBindingMaxAgeMs$1, E as shouldDefaultPersist, T as setBindingRecord, _ as resolveBindingIdsForSession, a as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, b as resolveThreadBindingIdleTimeoutMs$1, c as forgetThreadBindingToken, d as normalizeThreadBindingDurationMs, f as normalizeThreadId, g as removeBindingRecord, h as rememberThreadBindingToken, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, k as toReusableWebhookKey, l as getThreadBindingToken, m as rememberReusableWebhook, n as MANAGERS_BY_ACCOUNT_ID, o as ensureBindingsLoaded, p as refreshUnboundThreadWebhookIdentity, r as PERSIST_BY_ACCOUNT_ID, s as ensureBindingsLoadedAsync, t as BINDINGS_BY_THREAD_ID, u as normalizeTargetKind, v as resolveBindingRecordKey, w as saveBindingsToDisk, y as resolvePreparedThreadBindingLifecycle } from "./thread-bindings.state-BThFQEga.mjs";
+import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-CrfEI6Bs.mjs";
+import { C as resolvePreparedThreadBindingLifecycle, D as resolveThreadBindingMaxAgeMs$1, M as toReusableWebhookKey, S as resolveBindingRecordKey, _ as refreshUnboundThreadWebhookIdentity, c as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, d as forgetThreadBindingToken, f as getThreadBindingToken, h as normalizeThreadBindingDurationMs, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, j as toBindingRecordKey, k as shouldDefaultPersist, m as normalizeTargetKind, n as MANAGERS_BY_ACCOUNT_ID, r as PERSIST_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as ensureBindingsLoadedAsync, v as rememberReusableWebhook, w as resolveThreadBindingIdleTimeoutMs$1, x as resolveBindingIdsForSession, y as rememberThreadBindingToken } from "./thread-bindings.state-g6v9zAym.mjs";
+import { c as drainThreadBindingAccountOperations, d as runThreadBindingAccountOperation, f as runThreadBindingMutation, h as updateBindingRecordSync, l as drainThreadBindingMutations, m as snapshotThreadBindingJson, p as shouldPersistAnyBindingState, s as commitBindingRecord } from "./thread-bindings.session-updates-CshfKghV.mjs";
 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 { asOptionalObjectRecord, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 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 { registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, resolveThreadBindingFarewellText, resolveThreadBindingThreadName, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
 import { resolveSessionAgentIdStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.persona.ts
 const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
@@ -26,10 +28,7 @@ function resolveThreadBindingPersona(params) {
 	return truncateUtf16Safe(`${SYSTEM_MARK} ${base}`, THREAD_BINDING_PERSONA_MAX_CHARS);
 }
 function resolveThreadBindingPersonaFromRecord(record) {
-	return resolveThreadBindingPersona({
-		label: record.label,
-		agentId: record.agentId
-	});
+	return resolveThreadBindingPersona(record);
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.types.ts
@@ -44,10 +43,7 @@ function buildThreadTarget(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;
+	return asRecord.archived === true || asRecord.thread_metadata?.archived === true || asRecord.threadMetadata?.archived === true;
 }
 function normalizeDiscordBindingChannelId(raw) {
 	const trimmed = normalizeOptionalString(raw) ?? "";
@@ -64,18 +60,15 @@ function summarizeDiscordError(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);
+	return parseStrictNonNegativeInteger(candidate.status) ?? parseStrictNonNegativeInteger(candidate.statusCode) ?? parseStrictNonNegativeInteger(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);
+	return parseStrictNonNegativeInteger(candidate.code) ?? parseStrictNonNegativeInteger(candidate.rawError?.code) ?? parseStrictNonNegativeInteger(candidate.body?.code) ?? parseStrictNonNegativeInteger(candidate.response?.body?.code) ?? parseStrictNonNegativeInteger(candidate.response?.data?.code);
 }
 function isDiscordThreadGoneError(err) {
 	if (extractDiscordErrorCode(err) === 10003) return true;
@@ -207,21 +200,6 @@ async function createThreadForBinding(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.session-adapter.ts
-function normalizeChildBindingParentChannelId(raw) {
-	const trimmed = normalizeOptionalString(raw) ?? "";
-	if (!trimmed) return;
-	try {
-		return resolveDiscordChannelId(trimmed);
-	} catch {
-		return;
-	}
-}
-function toSessionBindingTargetKind(raw) {
-	return raw === "subagent" ? "subagent" : "session";
-}
-function toThreadBindingTargetKind(raw) {
-	return raw === "subagent" ? "subagent" : "acp";
-}
 function toSessionBindingRecord(record, defaults) {
 	const bindingId = resolveBindingRecordKey({
 		accountId: record.accountId,
@@ -234,7 +212,7 @@ function toSessionBindingRecord(record, defaults) {
 	return {
 		bindingId,
 		targetSessionKey: record.targetSessionKey,
-		targetKind: toSessionBindingTargetKind(record.targetKind),
+		targetKind: record.targetKind === "subagent" ? "subagent" : "session",
 		conversation: {
 			channel: "discord",
 			accountId: record.accountId,
@@ -270,18 +248,19 @@ function createThreadBindingSessionAdapter(params) {
 			if (!targetSessionKey) return null;
 			const conversationId = normalizeOptionalString(input.conversation.conversationId) ?? "";
 			const placement = input.placement === "child" ? "child" : "current";
-			const metadata = input.metadata ?? {};
+			const metadata = asOptionalObjectRecord(snapshotThreadBindingJson(input.metadata ? { ...input.metadata } : void 0)) ?? {};
+			const targetKind = input.targetKind === "subagent" ? "subagent" : "acp";
 			const label = normalizeOptionalString(metadata.label);
-			const threadName = typeof metadata.threadName === "string" ? normalizeOptionalString(metadata.threadName) : void 0;
-			const introText = typeof metadata.introText === "string" ? normalizeOptionalString(metadata.introText) : void 0;
-			const boundBy = typeof metadata.boundBy === "string" ? normalizeOptionalString(metadata.boundBy) : void 0;
-			const agentId = typeof metadata.agentId === "string" ? normalizeOptionalString(metadata.agentId) : void 0;
+			const threadName = normalizeOptionalString(metadata.threadName);
+			const introText = normalizeOptionalString(metadata.introText);
+			const boundBy = normalizeOptionalString(metadata.boundBy);
+			const agentId = normalizeOptionalString(metadata.agentId);
 			let threadId;
 			let channelId;
 			let createThread = false;
 			if (placement === "child") {
 				createThread = true;
-				channelId = normalizeChildBindingParentChannelId(input.conversation.parentConversationId);
+				channelId = normalizeDiscordBindingChannelId(input.conversation.parentConversationId) ?? void 0;
 				if (!channelId && conversationId) channelId = await resolveChannelIdForBinding({
 					cfg: params.resolveCurrentCfg(),
 					accountId: params.accountId,
@@ -294,7 +273,7 @@ function createThreadBindingSessionAdapter(params) {
 				channelId,
 				createThread,
 				threadName,
-				targetKind: toThreadBindingTargetKind(input.targetKind),
+				targetKind,
 				targetSessionKey,
 				agentId,
 				label,
@@ -312,28 +291,39 @@ function createThreadBindingSessionAdapter(params) {
 			return binding ? serializeBinding(binding) : null;
 		},
 		touch: (bindingId, at) => {
+			const threadId = resolveThreadBindingConversationIdFromBindingId({
+				accountId: params.accountId,
+				bindingId
+			});
+			if (threadId) params.manager.touchThreadSync({
+				threadId,
+				at,
+				persist: true
+			});
+		},
+		touchAsync: async (bindingId, at) => {
 			const threadId = resolveThreadBindingConversationIdFromBindingId({
 				accountId: params.accountId,
 				bindingId
 			});
 			if (!threadId) return;
-			params.manager.touchThread({
+			await params.manager.touchThread({
 				threadId,
 				at,
 				persist: true
 			});
 		},
 		unbind: async (input) => {
-			if (input.targetSessionKey?.trim()) return params.manager.unbindBySessionKey({
+			if (input.targetSessionKey?.trim()) return (await params.manager.unbindBySessionKey({
 				targetSessionKey: input.targetSessionKey,
 				reason: input.reason
-			}).map(serializeBinding);
+			})).map(serializeBinding);
 			const threadId = resolveThreadBindingConversationIdFromBindingId({
 				accountId: params.accountId,
 				bindingId: input.bindingId
 			});
 			if (!threadId) return [];
-			const removed = params.manager.unbindThread({
+			const removed = await params.manager.unbindThread({
 				threadId,
 				reason: input.reason
 			});
@@ -358,17 +348,20 @@ function createNoopThreadBindingManager(accountIdRaw) {
 	registerSessionBindingAdapter(adapter);
 	return {
 		accountId,
+		isStopping: () => false,
 		getIdleTimeoutMs: () => DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS,
 		getMaxAgeMs: () => 0,
 		getByThreadId: () => void 0,
 		getBySessionKey: () => void 0,
 		listBySessionKey: () => [],
 		listBindings: () => [],
-		touchThread: () => null,
+		touchThread: async () => null,
+		touchThreadSync: () => null,
 		bindTarget: async () => null,
-		unbindThread: () => null,
-		unbindBySessionKey: () => [],
-		stop: () => unregisterSessionBindingAdapter({
+		unbindThread: async () => null,
+		unbindBySessionKey: async () => [],
+		notifyUnbound: () => {},
+		stop: async () => unregisterSessionBindingAdapter({
 			channel: "discord",
 			accountId,
 			adapter
@@ -379,15 +372,23 @@ function createNoopThreadBindingManager(accountIdRaw) {
 //#region extensions/discord/src/monitor/thread-bindings.manager.ts
 var thread_bindings_manager_exports = /* @__PURE__ */ __exportAll({
 	createThreadBindingManager: () => createThreadBindingManager,
-	createThreadBindingManagerAsync: () => createThreadBindingManagerAsync,
 	getThreadBindingManager: () => getThreadBindingManager
 });
 function isDirectConversationBindingId(value) {
 	const trimmed = normalizeOptionalString(value);
 	return Boolean(trimmed && /^(user:|channel:)/i.test(trimmed));
 }
-function createThreadBindingManager(params) {
-	ensureBindingsLoaded();
+async function createThreadBindingManager(input) {
+	const params = { ...input };
+	await ensureBindingsLoadedAsync();
+	const manager = await runThreadBindingMutation(async () => createLoadedThreadBindingManager(params));
+	if (manager.isStopping()) {
+		await manager.stop();
+		return await createThreadBindingManager(params);
+	}
+	return manager;
+}
+function createLoadedThreadBindingManager(params) {
 	const accountId = normalizeAccountId(params.accountId);
 	const existing = MANAGERS_BY_ACCOUNT_ID.get(accountId);
 	if (existing) {
@@ -408,6 +409,23 @@ function createThreadBindingManager(params) {
 	const resolveCurrentCfg = () => getRuntimeConfigSnapshot() ?? params.cfg;
 	const resolveCurrentToken = () => getThreadBindingToken(accountId) ?? params.token;
 	const getCurrentBinding = (threadId) => MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager ? manager.getByThreadId(threadId) : void 0;
+	let stopping = false;
+	let stopPromise;
+	let sweepPromise;
+	const assertManagerCurrent = () => {
+		if (MANAGERS_BY_ACCOUNT_ID.get(accountId) !== manager) throw new Error("Discord thread binding manager was retired");
+	};
+	const runOwnedMutation = (operation) => {
+		if (stopping) return Promise.reject(/* @__PURE__ */ new Error("Discord thread binding manager is stopping"));
+		return runThreadBindingAccountOperation([manager], async () => {
+			assertManagerCurrent();
+			return await operation();
+		});
+	};
+	const mutate = (operation) => runOwnedMutation(() => runThreadBindingMutation(async () => {
+		assertManagerCurrent();
+		return await operation();
+	}));
 	let sweepTimer = null;
 	const runSweepOnce = async () => {
 		const bindings = manager.listBindings();
@@ -415,7 +433,7 @@ function createThreadBindingManager(params) {
 		let rest = null;
 		for (const snapshotBinding of bindings) {
 			const binding = getCurrentBinding(snapshotBinding.threadId);
-			if (!binding) continue;
+			if (!binding || stopping) continue;
 			const now = Date.now();
 			const lifecycle = resolvePreparedThreadBindingLifecycle({
 				record: binding,
@@ -424,8 +442,9 @@ function createThreadBindingManager(params) {
 			});
 			const { expiresAt, reason } = lifecycle;
 			if (expiresAt != null && reason && now >= expiresAt) {
-				manager.unbindThread({
+				await manager.unbindThread({
 					threadId: binding.threadId,
+					expected: binding,
 					reason,
 					sendFarewell: true,
 					farewellText: resolveThreadBindingFarewellText({
@@ -454,8 +473,9 @@ function createThreadBindingManager(params) {
 					logVerbose(`discord thread binding sweep probe returned invalid payload for ${binding.threadId}`);
 					continue;
 				}
-				if (isThreadArchived(channel)) manager.unbindThread({
+				if (isThreadArchived(channel)) await manager.unbindThread({
 					threadId: binding.threadId,
+					expected: binding,
 					reason: "thread-archived",
 					sendFarewell: true
 				});
@@ -463,8 +483,9 @@ function createThreadBindingManager(params) {
 				if (getCurrentBinding(binding.threadId) !== binding) continue;
 				if (isDiscordThreadGoneError(err)) {
 					logVerbose(`discord thread binding sweep removing stale binding ${binding.threadId}: ${summarizeDiscordError(err)}`);
-					manager.unbindThread({
+					await manager.unbindThread({
 						threadId: binding.threadId,
+						expected: binding,
 						reason: "thread-delete",
 						sendFarewell: false
 					});
@@ -474,8 +495,52 @@ function createThreadBindingManager(params) {
 			}
 		}
 	};
+	const unbindThread = async (unbindParams) => {
+		const bindingKey = resolveBindingRecordKey({
+			accountId,
+			threadId: unbindParams.threadId
+		});
+		if (!bindingKey) return null;
+		const existingLocal = BINDINGS_BY_THREAD_ID.get(bindingKey);
+		if (!existingLocal || existingLocal.accountId !== accountId || unbindParams.expected && existingLocal !== unbindParams.expected) return null;
+		await commitBindingRecord({
+			bindingKey,
+			previous: existingLocal,
+			next: null,
+			persist: unbindParams.persist ?? persist,
+			assertCurrent: assertManagerCurrent
+		});
+		const removed = existingLocal;
+		manager.notifyUnbound(removed, unbindParams);
+		return removed;
+	};
 	const manager = {
 		accountId,
+		isStopping: () => stopping,
+		notifyUnbound: (removed, notification) => {
+			refreshUnboundThreadWebhookIdentity(removed);
+			if (notification.sendFarewell !== false) {
+				const cfg = resolveCurrentCfg();
+				const farewell = resolveThreadBindingFarewellText({
+					reason: notification.reason,
+					farewellText: notification.farewellText,
+					idleTimeoutMs: resolveThreadBindingIdleTimeoutMs$1({
+						record: removed,
+						defaultIdleTimeoutMs: idleTimeoutMs
+					}),
+					maxAgeMs: resolveThreadBindingMaxAgeMs$1({
+						record: removed,
+						defaultMaxAgeMs: maxAgeMs
+					})
+				});
+				if (cfg) maybeSendBindingMessage({
+					cfg,
+					record: removed,
+					text: farewell,
+					preferWebhook: false
+				});
+			}
+		},
 		getIdleTimeoutMs: () => idleTimeoutMs,
 		getMaxAgeMs: () => maxAgeMs,
 		getByThreadId: (threadId) => {
@@ -498,206 +563,237 @@ function createThreadBindingManager(params) {
 			}).map((bindingKey) => BINDINGS_BY_THREAD_ID.get(bindingKey)).filter((entry) => Boolean(entry));
 		},
 		listBindings: () => [...BINDINGS_BY_THREAD_ID.values()].filter((entry) => entry.accountId === accountId),
-		touchThread: (touchParams) => {
+		touchThreadSync: (input) => {
+			assertManagerCurrent();
+			if (stopping) throw new Error("Discord thread binding manager is stopping");
 			const key = resolveBindingRecordKey({
 				accountId,
-				threadId: touchParams.threadId
+				threadId: input.threadId
 			});
 			if (!key) return null;
-			const existingResult = BINDINGS_BY_THREAD_ID.get(key);
-			if (!existingResult || existingResult.accountId !== accountId) return null;
-			const now = Date.now();
-			const at = typeof touchParams.at === "number" && Number.isFinite(touchParams.at) ? Math.max(0, Math.floor(touchParams.at)) : now;
-			const nextRecord = {
-				...existingResult,
-				lastActivityAt: Math.max(existingResult.lastActivityAt || 0, at)
+			const at = typeof input.at === "number" && Number.isFinite(input.at) ? Math.max(0, Math.floor(input.at)) : Date.now();
+			return updateBindingRecordSync({
+				bindingKey: key,
+				transform: (record) => ({
+					...record,
+					lastActivityAt: Math.max(record.lastActivityAt || 0, at)
+				}),
+				persist: (input.persist ?? persist) && shouldPersistAnyBindingState(),
+				minIntervalMs: THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS
+			});
+		},
+		touchThread: (input) => {
+			const touchParams = {
+				...input,
+				at: typeof input.at === "number" && Number.isFinite(input.at) ? Math.max(0, Math.floor(input.at)) : Date.now()
 			};
-			setBindingRecord(nextRecord);
-			if (touchParams.persist ?? persist) saveBindingsToDisk({ minIntervalMs: THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS });
-			return nextRecord;
+			return mutate(async () => {
+				const key = resolveBindingRecordKey({
+					accountId,
+					threadId: touchParams.threadId
+				});
+				if (!key) return null;
+				const existingResult = BINDINGS_BY_THREAD_ID.get(key);
+				if (!existingResult || existingResult.accountId !== accountId) return null;
+				const nextRecord = {
+					...existingResult,
+					lastActivityAt: Math.max(existingResult.lastActivityAt || 0, touchParams.at)
+				};
+				await commitBindingRecord({
+					bindingKey: key,
+					previous: existingResult,
+					next: nextRecord,
+					persist: (touchParams.persist ?? persist) && shouldPersistAnyBindingState(),
+					minIntervalMs: THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS,
+					assertCurrent: assertManagerCurrent
+				});
+				return nextRecord;
+			});
 		},
 		bindTarget: async (input) => {
 			const bindParams = {
 				...input,
-				metadata: input.metadata ? { ...input.metadata } : void 0
+				metadata: asOptionalObjectRecord(snapshotThreadBindingJson(input.metadata ? { ...input.metadata } : void 0))
 			};
-			const assertCurrent = bindParams.assertCurrent;
-			assertCurrent?.();
-			const cfg = resolveCurrentCfg();
-			let threadId = normalizeThreadId(bindParams.threadId);
-			let channelId = normalizeOptionalString(bindParams.channelId) ?? "";
-			const directConversationBinding = isDirectConversationBindingId(threadId) || isDirectConversationBindingId(channelId);
-			let nativeBindingCreated = false;
-			const targetSessionKey = normalizeOptionalString(bindParams.targetSessionKey) ?? "";
-			if (!targetSessionKey) return null;
-			const targetKind = normalizeTargetKind(bindParams.targetKind, targetSessionKey);
-			let agentId = normalizeOptionalString(bindParams.agentId);
-			if (!threadId && bindParams.createThread) {
+			return runOwnedMutation(async () => {
+				const assertCurrent = bindParams.assertCurrent;
+				assertCurrent?.();
+				const cfg = resolveCurrentCfg();
+				let threadId = normalizeOptionalStringifiedId(bindParams.threadId);
+				let channelId = normalizeOptionalString(bindParams.channelId) ?? "";
+				const directConversationBinding = isDirectConversationBindingId(threadId) || isDirectConversationBindingId(channelId);
+				let nativeBindingCreated = false;
+				const targetSessionKey = normalizeOptionalString(bindParams.targetSessionKey) ?? "";
+				if (!targetSessionKey) return null;
+				const targetKind = normalizeTargetKind(bindParams.targetKind, targetSessionKey);
+				let agentId = normalizeOptionalString(bindParams.agentId);
+				if (!threadId && bindParams.createThread) {
+					if (!channelId) return null;
+					agentId ??= resolveSessionAgentIdStrict({
+						config: cfg,
+						sessionKey: targetSessionKey
+					});
+					const threadName = resolveThreadBindingThreadName({
+						agentId: bindParams.agentId,
+						label: bindParams.label
+					});
+					threadId = await createThreadForBinding({
+						cfg,
+						accountId,
+						token: resolveCurrentToken(),
+						channelId,
+						threadName: normalizeOptionalString(bindParams.threadName) ?? threadName,
+						...assertCurrent ? { assertCreateAllowed: assertCurrent } : {}
+					}) ?? void 0;
+					nativeBindingCreated = Boolean(threadId);
+				}
+				if (!threadId) return null;
+				if (!channelId && directConversationBinding) channelId = threadId;
+				if (!channelId) channelId = await resolveChannelIdForBinding({
+					cfg,
+					accountId,
+					token: resolveCurrentToken(),
+					threadId,
+					channelId: bindParams.channelId
+				}) ?? "";
 				if (!channelId) return null;
-				agentId ??= resolveSessionAgentIdStrict({
+				const existingValue = manager.getByThreadId(threadId);
+				const previous = existingValue?.targetSessionKey === targetSessionKey && existingValue.targetKind === targetKind ? existingValue : void 0;
+				agentId ??= normalizeOptionalString(previous?.agentId) ?? resolveSessionAgentIdStrict({
 					config: cfg,
 					sessionKey: targetSessionKey
 				});
-				const threadName = resolveThreadBindingThreadName({
-					agentId: bindParams.agentId,
-					label: bindParams.label
-				});
-				threadId = await createThreadForBinding({
-					cfg,
+				let webhookId = normalizeOptionalString(bindParams.webhookId) ?? normalizeOptionalString(existingValue?.webhookId) ?? "";
+				let webhookToken = normalizeOptionalString(bindParams.webhookToken) ?? normalizeOptionalString(existingValue?.webhookToken) ?? "";
+				if (!directConversationBinding && (!webhookId || !webhookToken)) {
+					const cachedWebhook = findReusableWebhook({
+						accountId,
+						channelId
+					});
+					webhookId = cachedWebhook.webhookId ?? "";
+					webhookToken = cachedWebhook.webhookToken ?? "";
+				}
+				if (!directConversationBinding && (!webhookId || !webhookToken)) {
+					const createdWebhook = await createWebhookForChannel({
+						cfg,
+						accountId,
+						token: resolveCurrentToken(),
+						channelId,
+						...assertCurrent ? { assertCreateAllowed: assertCurrent } : {}
+					});
+					webhookId = createdWebhook.webhookId ?? "";
+					webhookToken = createdWebhook.webhookToken ?? "";
+					nativeBindingCreated ||= Boolean(webhookId && webhookToken);
+				}
+				const now = Date.now();
+				const record = {
 					accountId,
-					token: resolveCurrentToken(),
 					channelId,
-					threadName: normalizeOptionalString(bindParams.threadName) ?? threadName,
-					...assertCurrent ? { assertCreateAllowed: assertCurrent } : {}
-				}) ?? void 0;
-				nativeBindingCreated = Boolean(threadId);
-			}
-			if (!threadId) return null;
-			if (!channelId && directConversationBinding) channelId = threadId;
-			if (!channelId) channelId = await resolveChannelIdForBinding({
-				cfg,
-				accountId,
-				token: resolveCurrentToken(),
-				threadId,
-				channelId: bindParams.channelId
-			}) ?? "";
-			if (!channelId) return null;
-			const existingValue = manager.getByThreadId(threadId);
-			const previous = existingValue?.targetSessionKey === targetSessionKey && existingValue.targetKind === targetKind ? existingValue : void 0;
-			agentId ??= normalizeOptionalString(previous?.agentId) ?? resolveSessionAgentIdStrict({
-				config: cfg,
-				sessionKey: targetSessionKey
-			});
-			let webhookId = normalizeOptionalString(bindParams.webhookId) ?? normalizeOptionalString(existingValue?.webhookId) ?? "";
-			let webhookToken = normalizeOptionalString(bindParams.webhookToken) ?? normalizeOptionalString(existingValue?.webhookToken) ?? "";
-			if (!directConversationBinding && (!webhookId || !webhookToken)) {
-				const cachedWebhook = findReusableWebhook({
-					accountId,
-					channelId
-				});
-				webhookId = cachedWebhook.webhookId ?? "";
-				webhookToken = cachedWebhook.webhookToken ?? "";
-			}
-			if (!directConversationBinding && (!webhookId || !webhookToken)) {
-				const createdWebhook = await createWebhookForChannel({
+					threadId,
+					targetKind,
+					targetSessionKey,
+					agentId,
+					label: normalizeOptionalString(bindParams.label) ?? normalizeOptionalString(previous?.label),
+					webhookId: webhookId || void 0,
+					webhookToken: webhookToken || void 0,
+					boundBy: normalizeOptionalString(bindParams.boundBy) ?? normalizeOptionalString(previous?.boundBy) ?? "system",
+					boundAt: now,
+					lastActivityAt: now,
+					idleTimeoutMs: typeof existingValue?.idleTimeoutMs === "number" ? existingValue.idleTimeoutMs : idleTimeoutMs,
+					maxAgeMs: typeof existingValue?.maxAgeMs === "number" ? existingValue.maxAgeMs : maxAgeMs,
+					metadata: {
+						...previous?.metadata,
+						...bindParams.metadata
+					}
+				};
+				if (!nativeBindingCreated) assertCurrent?.();
+				await runThreadBindingMutation(() => commitBindingRecord({
+					bindingKey: toBindingRecordKey({
+						accountId,
+						threadId
+					}),
+					previous: existingValue,
+					next: record,
+					persist,
+					assertCurrent: () => {
+						assertManagerCurrent();
+						if (!nativeBindingCreated) assertCurrent?.();
+					}
+				}));
+				const introText = bindParams.introText?.trim();
+				if (introText && cfg) maybeSendBindingMessage({
 					cfg,
-					accountId,
-					token: resolveCurrentToken(),
-					channelId,
-					...assertCurrent ? { assertCreateAllowed: assertCurrent } : {}
+					record,
+					text: introText,
+					assertCurrent: () => {
+						assertCurrent?.();
+						const current = getCurrentBinding(record.threadId);
+						if (!current || current.targetSessionKey !== record.targetSessionKey || current.targetKind !== record.targetKind) throw new Error("Discord thread binding changed before its intro");
+					}
 				});
-				webhookId = createdWebhook.webhookId ?? "";
-				webhookToken = createdWebhook.webhookToken ?? "";
-				nativeBindingCreated ||= Boolean(webhookId && webhookToken);
-			}
-			const now = Date.now();
-			const record = {
-				accountId,
-				channelId,
-				threadId,
-				targetKind,
-				targetSessionKey,
-				agentId,
-				label: normalizeOptionalString(bindParams.label) ?? normalizeOptionalString(previous?.label),
-				webhookId: webhookId || void 0,
-				webhookToken: webhookToken || void 0,
-				boundBy: normalizeOptionalString(bindParams.boundBy) ?? normalizeOptionalString(previous?.boundBy) ?? "system",
-				boundAt: now,
-				lastActivityAt: now,
-				idleTimeoutMs: typeof existingValue?.idleTimeoutMs === "number" ? existingValue.idleTimeoutMs : idleTimeoutMs,
-				maxAgeMs: typeof existingValue?.maxAgeMs === "number" ? existingValue.maxAgeMs : maxAgeMs,
-				metadata: {
-					...previous?.metadata,
-					...bindParams.metadata
-				}
-			};
-			if (!nativeBindingCreated) assertCurrent?.();
-			setBindingRecord(record);
-			if (persist) saveBindingsToDisk();
-			const introText = bindParams.introText?.trim();
-			if (introText && cfg) maybeSendBindingMessage({
-				cfg,
-				record,
-				text: introText,
-				...assertCurrent ? { assertCurrent } : {}
+				return record;
 			});
-			return record;
 		},
-		unbindThread: (unbindParams) => {
-			const bindingKey = resolveBindingRecordKey({
-				accountId,
-				threadId: unbindParams.threadId
-			});
-			if (!bindingKey) return null;
-			const existingLocal = BINDINGS_BY_THREAD_ID.get(bindingKey);
-			if (!existingLocal || existingLocal.accountId !== accountId) return null;
-			const removed = removeBindingRecord(bindingKey);
-			if (!removed) return null;
-			refreshUnboundThreadWebhookIdentity(removed);
-			if (persist) saveBindingsToDisk();
-			if (unbindParams.sendFarewell !== false) {
-				const cfg = resolveCurrentCfg();
-				const farewell = resolveThreadBindingFarewellText({
-					reason: unbindParams.reason,
-					farewellText: unbindParams.farewellText,
-					idleTimeoutMs: resolveThreadBindingIdleTimeoutMs$1({
-						record: removed,
-						defaultIdleTimeoutMs: idleTimeoutMs
-					}),
-					maxAgeMs: resolveThreadBindingMaxAgeMs$1({
-						record: removed,
-						defaultMaxAgeMs: maxAgeMs
-					})
-				});
-				if (cfg) maybeSendBindingMessage({
-					cfg,
-					record: removed,
-					text: farewell,
-					preferWebhook: false
-				});
-			}
-			return removed;
+		unbindThread: (input) => {
+			const unbindParams = { ...input };
+			return mutate(() => unbindThread(unbindParams));
 		},
-		unbindBySessionKey: (unbindParams) => {
-			const ids = resolveBindingIdsForSession({
-				targetSessionKey: unbindParams.targetSessionKey,
-				accountId,
-				targetKind: unbindParams.targetKind
-			});
-			if (ids.length === 0) return [];
-			const removed = [];
-			for (const bindingKey of ids) {
-				const binding = BINDINGS_BY_THREAD_ID.get(bindingKey);
-				if (!binding) continue;
-				const entry = manager.unbindThread({
-					threadId: binding.threadId,
-					reason: unbindParams.reason,
-					sendFarewell: unbindParams.sendFarewell,
-					farewellText: unbindParams.farewellText
+		unbindBySessionKey: (input) => {
+			const unbindParams = { ...input };
+			return mutate(async () => {
+				const ids = resolveBindingIdsForSession({
+					targetSessionKey: unbindParams.targetSessionKey,
+					accountId,
+					targetKind: unbindParams.targetKind
 				});
-				if (entry) removed.push(entry);
-			}
-			return removed;
+				if (ids.length === 0) return [];
+				const removed = [];
+				for (const bindingKey of ids) {
+					const binding = BINDINGS_BY_THREAD_ID.get(bindingKey);
+					if (!binding) continue;
+					const entry = await unbindThread({
+						threadId: binding.threadId,
+						reason: unbindParams.reason,
+						sendFarewell: unbindParams.sendFarewell,
+						farewellText: unbindParams.farewellText
+					});
+					if (entry) removed.push(entry);
+				}
+				return removed;
+			});
 		},
 		stop: () => {
+			if (stopPromise) return stopPromise;
+			stopping = true;
 			if (sweepTimer) {
 				clearInterval(sweepTimer);
 				sweepTimer = null;
 			}
-			if (MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager) {
-				MANAGERS_BY_ACCOUNT_ID.delete(accountId);
-				forgetThreadBindingToken(accountId);
-			}
-			unregisterSessionBindingAdapter({
-				channel: "discord",
-				accountId,
-				adapter: sessionBindingAdapter
-			});
+			stopPromise = (async () => {
+				await sweepPromise;
+				await drainThreadBindingAccountOperations(manager);
+				await drainThreadBindingMutations();
+				if (MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager) {
+					MANAGERS_BY_ACCOUNT_ID.delete(accountId);
+					forgetThreadBindingToken(accountId);
+				}
+				unregisterSessionBindingAdapter({
+					channel: "discord",
+					accountId,
+					adapter: sessionBindingAdapter
+				});
+			})();
+			return stopPromise;
 		}
 	};
 	if (params.enableSweeper !== false) {
 		sweepTimer = setInterval(() => {
-			runSweepOnce();
+			if (stopping || sweepPromise) return;
+			sweepPromise = runSweepOnce().catch((error) => {
+				logVerbose(`discord thread binding sweep failed: ${String(error)}`);
+			}).finally(() => {
+				sweepPromise = void 0;
+			});
 		}, THREAD_BINDINGS_SWEEP_INTERVAL_MS);
 		if (!(process.env.VITEST || false)) sweepTimer.unref?.();
 	}
@@ -715,13 +811,9 @@ function createThreadBindingManager(params) {
 	MANAGERS_BY_ACCOUNT_ID.set(accountId, manager);
 	return manager;
 }
-async function createThreadBindingManagerAsync(params) {
-	await ensureBindingsLoadedAsync();
-	return createThreadBindingManager(params);
-}
 function getThreadBindingManager(accountId) {
 	const normalized = normalizeAccountId(accountId);
 	return MANAGERS_BY_ACCOUNT_ID.get(normalized) ?? null;
 }
 //#endregion
-export { createNoopThreadBindingManager as a, resolveThreadBindingPersona as c, resolveThreadBindingIntroText as d, resolveThreadBindingThreadName as f, thread_bindings_manager_exports as i, resolveThreadBindingPersonaFromRecord as l, createThreadBindingManagerAsync as n, isThreadArchived as o, getThreadBindingManager as r, resolveChannelIdForBinding as s, createThreadBindingManager as t, formatThreadBindingDurationLabel as u };
+export { isThreadArchived as a, resolveThreadBindingPersonaFromRecord as c, createNoopThreadBindingManager as i, getThreadBindingManager as n, resolveChannelIdForBinding as o, thread_bindings_manager_exports as r, resolveThreadBindingPersona as s, createThreadBindingManager as t };