@openclaw/clickclack 2026.9.5 → 2026.9.6

package/dist/.setup/{runtime-api-D9Bwyc44.mjs → runtime-api-A9r1b12d.mjs}

@@ -1,5 +1,5 @@
 import { b as resolveClickClackAccount, d as isClickClackChannelNameConflict, l as ClickClackHttpError, u as createClickClackClient, v as listClickClackAccountIds } from "./setup-surface-BBl3rvVx.mjs";
-import { C as slugifyDiscussionLabel, D as listPendingDiscussionOpens, E as clearPendingDiscussionOpen, O as recordPendingDiscussionOpen, S as resolveDiscussionLabel, T as clearDiscussionBindingGeneration, _ as getClickClackDiscussionBindingStore, b as fallbackDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as bindingMatchesActiveSessionIncarnation, h as attachBindingToCurrentActiveSession, k as reserveDiscussionBindingGeneration, l as markClickClackDiscussionChannelRevoked, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionCredentialFingerprint, w as truncateDiscussionDisplayTitle, x as isDiscussionSessionKey, y as discussionExternalRef } from "./channel-yIQ_PUDD.mjs";
+import { C as slugifyDiscussionLabel, D as listPendingDiscussionOpens, E as clearPendingDiscussionOpen, O as recordPendingDiscussionOpen, S as resolveDiscussionLabel, T as clearDiscussionBindingGeneration, _ as getClickClackDiscussionBindingStore, b as fallbackDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as bindingMatchesActiveSessionIncarnation, h as attachBindingToCurrentActiveSession, k as reserveDiscussionBindingGeneration, l as markClickClackDiscussionChannelRevoked, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionCredentialFingerprint, w as truncateDiscussionDisplayTitle, x as isDiscussionSessionKey, y as discussionExternalRef } from "./channel-CT4CVd4d.mjs";
 import "../api.js";
 import { randomUUID } from "node:crypto";
 import { buildControlUiSessionPath, registerSessionDiscussionProvider } from "openclaw/plugin-sdk/session-discussion";
@@ -253,10 +253,10 @@ async function openClickClackDiscussionBinding(params) {
 	if (!workspace.route_id) throw new Error("ClickClack discussions workspace is missing its route id");
 	const serverBaseUrl = normalizedServerBaseUrl(account);
 	const credentialFingerprint = discussionCredentialFingerprint(account.token);
-	const unresolved = listPendingDiscussionOpens(runtime).find((pending) => pending.sessionKey === sessionKey);
+	const unresolved = (await listPendingDiscussionOpens(runtime)).find((pending) => pending.sessionKey === sessionKey);
 	if (unresolved && (unresolved.accountId !== account.accountId || unresolved.credentialFingerprint !== credentialFingerprint || unresolved.serverBaseUrl !== serverBaseUrl || unresolved.workspaceId !== workspace.id)) {
 		await params.reconcilePendingOpen(unresolved);
-		if (listPendingDiscussionOpens(runtime).some((pending) => pending.sessionKey === sessionKey)) throw new Error("A previous ClickClack discussion open is still unresolved; restore its credential and retry");
+		if ((await listPendingDiscussionOpens(runtime)).some((pending) => pending.sessionKey === sessionKey)) throw new Error("A previous ClickClack discussion open is still unresolved; restore its credential and retry");
 	}
 	const config = runtime.config.current();
 	const agentId = resolveSessionAgentIdStrict({
@@ -268,12 +268,21 @@ async function openClickClackDiscussionBinding(params) {
 	const displayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
 	const section = entry.category?.trim() || account.discussions.section;
 	const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? agentId, config.session?.mainKey, label);
+	const assertCurrentAuthority = () => {
+		const currentAccounts = discussionAccounts(runtime.config.current());
+		const currentAccount = currentAccounts.length === 1 ? currentAccounts[0] : void 0;
+		const currentEntry = runtime.agent.session.getSessionEntry({
+			sessionKey,
+			readConsistency: "latest"
+		});
+		if (!currentAccount || currentAccount.accountId !== account.accountId || normalizedServerBaseUrl(currentAccount) !== serverBaseUrl || currentAccount.apiEndpoint !== account.apiEndpoint || discussionCredentialFingerprint(currentAccount.token) !== credentialFingerprint || currentAccount.discussions.workspace !== account.discussions.workspace || !currentEntry?.sessionId || currentEntry.archivedAt !== void 0) throw new Error("ClickClack discussion authority changed while opening the channel");
+	};
 	return await params.withChannelMutationLock(async () => {
 		params.ensureBindingCapacity(sessionKey);
 		let channels = await client.channels(workspace.id);
 		assertManagedChannelListContract(channels);
 		const destinationIdentity = [serverBaseUrl, workspace.id].join("\0");
-		const bindingGeneration = reserveDiscussionBindingGeneration({
+		const bindingGeneration = await reserveDiscussionBindingGeneration({
 			runtime,
 			sessionKey,
 			accountId: account.accountId,
@@ -303,7 +312,7 @@ async function openClickClackDiscussionBinding(params) {
 				sidebar_section: section,
 				display_title: displayTitle
 			};
-			recordPendingDiscussionOpen({
+			await recordPendingDiscussionOpen({
 				runtime,
 				sessionKey,
 				generation: bindingGeneration,
@@ -316,7 +325,8 @@ async function openClickClackDiscussionBinding(params) {
 					credentialFingerprint
 				}
 			});
-			params.ensureTimer();
+			await params.ensureTimer();
+			assertCurrentAuthority();
 			try {
 				if (adopted) {
 					markClickClackDiscussionChannelIdentityRevoked({
@@ -358,16 +368,17 @@ async function openClickClackDiscussionBinding(params) {
 							serverBaseUrl,
 							channelId: recovered.id
 						});
+						assertCurrentAuthority();
 						resolved = await client.updateChannel(recovered.id, managedFields);
 						break;
 					}
-					if (definitiveNoCreate) clearDiscussionBindingGeneration({
+					if (definitiveNoCreate) await clearDiscussionBindingGeneration({
 						runtime,
 						sessionKey,
 						expectedGeneration: bindingGeneration
 					});
 				} catch {
-					if (definitiveNoCreate && !adopted) clearDiscussionBindingGeneration({
+					if (definitiveNoCreate && !adopted) await clearDiscussionBindingGeneration({
 						runtime,
 						sessionKey,
 						expectedGeneration: bindingGeneration
@@ -387,7 +398,7 @@ async function openClickClackDiscussionBinding(params) {
 			});
 			if (adopted) assertChannelPatch(resolved, managedFields);
 		} catch (error) {
-			clearPendingDiscussionOpen({
+			await clearPendingDiscussionOpen({
 				runtime,
 				sessionKey,
 				expectedGeneration: bindingGeneration
@@ -396,7 +407,7 @@ async function openClickClackDiscussionBinding(params) {
 			throw error;
 		}
 		if (!resolved.route_id) {
-			clearPendingDiscussionOpen({
+			await clearPendingDiscussionOpen({
 				runtime,
 				sessionKey,
 				expectedGeneration: bindingGeneration
@@ -410,7 +421,7 @@ async function openClickClackDiscussionBinding(params) {
 			readConsistency: "latest"
 		});
 		if (!currentEntry?.sessionId || currentEntry.archivedAt !== void 0) {
-			clearPendingDiscussionOpen({
+			await clearPendingDiscussionOpen({
 				runtime,
 				sessionKey,
 				expectedGeneration: bindingGeneration
@@ -440,6 +451,7 @@ async function openClickClackDiscussionBinding(params) {
 					display_title: currentDisplayTitle
 				};
 				try {
+					assertCurrentAuthority();
 					currentChannel = await client.updateChannel(channel.id, latestManagedFields);
 					assertChannelPatch(currentChannel, latestManagedFields);
 					break;
@@ -448,7 +460,7 @@ async function openClickClackDiscussionBinding(params) {
 				}
 			}
 		} catch (error) {
-			clearPendingDiscussionOpen({
+			await clearPendingDiscussionOpen({
 				runtime,
 				sessionKey,
 				expectedGeneration: bindingGeneration
@@ -475,9 +487,10 @@ async function openClickClackDiscussionBinding(params) {
 			...currentChannel.display_title !== void 0 ? { displayTitle: currentChannel.display_title } : {}
 		};
 		try {
+			assertCurrentAuthority();
 			store.set(sessionKey, nextBinding);
 		} catch (error) {
-			clearPendingDiscussionOpen({
+			await clearPendingDiscussionOpen({
 				runtime,
 				sessionKey,
 				expectedGeneration: bindingGeneration
@@ -485,10 +498,59 @@ async function openClickClackDiscussionBinding(params) {
 			params.warn(`unbound discussion channel remains quarantined: ${channel.id}`);
 			throw error;
 		}
-		params.finalizePendingBinding(sessionKey, nextBinding);
+		await params.finalizePendingBinding(sessionKey, nextBinding);
 		return nextBinding;
 	});
 }
+async function reconcilePendingDiscussionOpen(params) {
+	const { pending } = params;
+	const currentBinding = params.store.get(pending.sessionKey);
+	if (currentBinding?.externalRef === pending.externalRef) {
+		await params.finalizePendingBinding(pending.sessionKey, currentBinding);
+		return;
+	}
+	const cfg = params.runtime.config.current();
+	const account = listClickClackAccountIds(cfg).map((accountId) => resolveClickClackAccount({
+		cfg,
+		accountId
+	})).find((candidate) => candidate.configured && normalizedServerBaseUrl(candidate) === pending.serverBaseUrl && discussionCredentialFingerprint(candidate.token) === pending.credentialFingerprint);
+	if (!account) return;
+	const client = params.clientFactory(account);
+	const entry = params.runtime.agent.session.getSessionEntry({
+		sessionKey: pending.sessionKey,
+		readConsistency: "latest"
+	});
+	const activeAccounts = discussionAccounts(cfg);
+	const retryAccount = activeAccounts.length === 1 ? activeAccounts[0] : void 0;
+	if (params.allowRetry !== false && entry?.sessionId && entry.archivedAt === void 0 && retryAccount && normalizedServerBaseUrl(retryAccount) === pending.serverBaseUrl && discussionCredentialFingerprint(retryAccount.token) === pending.credentialFingerprint) {
+		if ((await params.clientFactory(retryAccount).workspaces()).find((candidate) => candidate.id === retryAccount.discussions.workspace || candidate.slug === retryAccount.discussions.workspace || candidate.name === retryAccount.discussions.workspace)?.id === pending.workspaceId) {
+			await params.open(pending.sessionKey);
+			return;
+		}
+	}
+	const channels = await client.channels(pending.workspaceId);
+	assertManagedChannelListContract(channels);
+	const channel = channels.find((candidate) => candidate.external_managed === true && candidate.external_ref === pending.externalRef);
+	if (channel) {
+		markClickClackDiscussionChannelIdentityRevoked({
+			runtime: params.runtime,
+			accountId: pending.accountId,
+			serverBaseUrl: pending.serverBaseUrl,
+			channelId: channel.id
+		});
+		await clearPendingDiscussionOpen({
+			runtime: params.runtime,
+			sessionKey: pending.sessionKey,
+			expectedGeneration: pending.generation
+		});
+		return;
+	}
+	await clearDiscussionBindingGeneration({
+		runtime: params.runtime,
+		sessionKey: pending.sessionKey,
+		expectedGeneration: pending.generation
+	});
+}
 //#endregion
 //#region extensions/clickclack/src/discussions/service.ts
 const RECONCILE_INTERVAL_MS = 6e4;
@@ -503,7 +565,7 @@ var ClickClackDiscussionService = class {
 	#timersEnabled;
 	#sessionLocks = /* @__PURE__ */ new Map();
 	#reconcileScheduler = new DiscussionReconcileScheduler({
-		shouldSchedule: (sessionKey) => !this.#closed && (this.#store.get(sessionKey) !== void 0 || listPendingDiscussionOpens(this.#runtime).some((pending) => pending.sessionKey === sessionKey)),
+		shouldSchedule: () => !this.#closed,
 		run: async (sessionKey) => await this.reconcile(sessionKey),
 		warn: (message) => this.#logger().warn(message)
 	});
@@ -512,6 +574,9 @@ var ClickClackDiscussionService = class {
 	#reconcileAllPromise;
 	#unsubscribeSessionsChanged;
 	#closed = false;
+	#activation = 0;
+	#cleanupPromise;
+	#operations = /* @__PURE__ */ new Set();
 	constructor(runtime, options = {}) {
 		this.#runtime = runtime;
 		this.#store = getClickClackDiscussionBindingStore(runtime);
@@ -532,24 +597,43 @@ var ClickClackDiscussionService = class {
 			info: async ({ sessionKey }) => await this.info(sessionKey),
 			open: async ({ sessionKey }) => await this.open(sessionKey)
 		};
-		if (options.gatewayEvents) this.bindGatewayEvents(options.gatewayEvents);
-		if (this.#timersEnabled) this.#ensureTimer();
+		if (options.gatewayEvents) this.bindGatewayEvents(options.gatewayEvents).catch((error) => {
+			this.#logger().warn(`discussion activation failed: ${String(error)}`);
+		});
+		if (this.#timersEnabled && !options.gatewayEvents) this.#withOperation(() => this.#ensureTimer()).catch((error) => {
+			this.#logger().warn(`discussion timer initialization failed: ${String(error)}`);
+		});
 	}
-	bindGatewayEvents(gatewayEvents) {
+	async bindGatewayEvents(gatewayEvents) {
+		const activation = ++this.#activation;
+		if (this.#cleanupPromise) await this.#cleanupPromise;
+		if (activation !== this.#activation) return;
+		this.#cleanupPromise = void 0;
 		this.#unsubscribeSessionsChanged?.();
 		this.#closed = false;
 		this.#reconcileScheduler.supersede();
 		this.#unsubscribeSessionsChanged = gatewayEvents?.onSessionsChanged((event) => {
-			this.#reconcileScheduler.schedule(event.sessionKey);
+			this.#withOperation(async () => {
+				if (this.#store.get(event.sessionKey) || (await listPendingDiscussionOpens(this.#runtime)).some((pending) => pending.sessionKey === event.sessionKey)) {
+					if (activation === this.#activation) this.#reconcileScheduler.schedule(event.sessionKey);
+				}
+			}).catch((error) => {
+				this.#logger().warn(`discussion event admission failed: ${String(error)}`);
+			});
+		});
+		await this.#withOperation(async () => {
+			for (const sessionKey of await this.#listReconcileSessionKeys()) {
+				if (activation !== this.#activation) return;
+				this.#reconcileScheduler.schedule(sessionKey, 0);
+			}
+			await this.#ensureTimer();
 		});
-		for (const sessionKey of this.#listReconcileSessionKeys()) this.#reconcileScheduler.schedule(sessionKey, 0);
-		if (this.#timersEnabled) this.#ensureTimer();
 	}
 	hasEnabledAccount() {
 		return discussionAccounts(this.#currentConfig()).length === 1;
 	}
 	async info(sessionKey) {
-		return await this.#withSessionLock(sessionKey, async () => {
+		return await this.#withOperation(() => this.#withSessionLock(sessionKey, async () => {
 			if (discussionAccounts(this.#currentConfig()).length !== 1) return { state: "none" };
 			const existing = this.#store.get(sessionKey);
 			if (existing) {
@@ -563,104 +647,117 @@ var ClickClackDiscussionService = class {
 					return { state: "available" };
 				}
 				if (resolved.state !== "active") return { state: "none" };
-				this.#finalizePendingBinding(sessionKey, existing);
+				await this.#finalizePendingBinding(sessionKey, existing);
 				await this.#reconcileBinding(sessionKey, existing, resolved.account);
 				const current = this.#store.get(sessionKey);
 				if (!current) return { state: this.hasEnabledAccount() ? "available" : "none" };
 				return discussionInfoForBinding(current, resolved.account);
 			}
 			return { state: "available" };
-		});
+		}));
 	}
 	async open(sessionKey) {
-		return await this.#withSessionLock(sessionKey, async () => {
-			this.#installationId ??= await getClickClackDiscussionInstallationId(this.#runtime);
-			const accounts = discussionAccounts(this.#currentConfig());
-			if (accounts.length > 1) throw new Error("ClickClack discussions require exactly one enabled discussion account");
-			const account = accounts[0];
-			if (!account) return { state: "none" };
-			const existing = this.#store.get(sessionKey);
-			if (existing) {
-				const resolved = await this.#resolveBindingForUse(existing);
-				if (resolved.state === "retargeted") this.#revokeAndDeleteBinding(sessionKey, existing);
-				else if (resolved.state === "stale") await this.#releaseStaleBinding(sessionKey, existing);
-				else if (resolved.state === "active") {
-					this.#finalizePendingBinding(sessionKey, existing);
-					await this.#reconcileBinding(sessionKey, existing, resolved.account);
-					const current = this.#store.get(sessionKey);
-					if (current) return discussionInfoForBinding(current, resolved.account);
-				}
-			}
-			let binding;
-			try {
-				binding = await openClickClackDiscussionBinding({
-					runtime: this.#runtime,
-					store: this.#store,
-					account,
-					clientFactory: this.#clientFactory,
-					installationId: this.#installationId,
-					bindingGenerationFactory: this.#bindingGenerationFactory,
-					sessionKey,
-					ensureTimer: () => this.#ensureTimer(),
-					reconcilePendingOpen: async (pending) => await this.#reconcilePendingOpen(pending, { allowRetry: false }),
-					withChannelMutationLock: async (run) => await this.#withChannelMutationLock(run),
-					ensureBindingCapacity: (key) => this.#detachedBindings.ensureCapacity(key),
-					finalizePendingBinding: (key, nextBinding) => this.#finalizePendingBinding(key, nextBinding),
-					warn: (message) => this.#logger().warn(message)
-				});
-			} finally {
-				this.#ensureTimer();
+		return await this.#withOperation(() => this.#withSessionLock(sessionKey, () => this.#open(sessionKey)));
+	}
+	async #open(sessionKey) {
+		this.#installationId ??= await getClickClackDiscussionInstallationId(this.#runtime);
+		const accounts = discussionAccounts(this.#currentConfig());
+		if (accounts.length > 1) throw new Error("ClickClack discussions require exactly one enabled discussion account");
+		const account = accounts[0];
+		if (!account) return { state: "none" };
+		const existing = this.#store.get(sessionKey);
+		if (existing) {
+			const resolved = await this.#resolveBindingForUse(existing);
+			if (resolved.state === "retargeted") this.#revokeAndDeleteBinding(sessionKey, existing);
+			else if (resolved.state === "stale") await this.#releaseStaleBinding(sessionKey, existing);
+			else if (resolved.state === "active") {
+				await this.#finalizePendingBinding(sessionKey, existing);
+				await this.#reconcileBinding(sessionKey, existing, resolved.account);
+				const current = this.#store.get(sessionKey);
+				if (current) return discussionInfoForBinding(current, resolved.account);
 			}
-			if (!binding) return { state: "available" };
-			return discussionInfoForBinding(binding, account);
-		});
+		}
+		let binding;
+		try {
+			binding = await openClickClackDiscussionBinding({
+				runtime: this.#runtime,
+				store: this.#store,
+				account,
+				clientFactory: this.#clientFactory,
+				installationId: this.#installationId,
+				bindingGenerationFactory: this.#bindingGenerationFactory,
+				sessionKey,
+				ensureTimer: () => this.#ensureTimer(),
+				reconcilePendingOpen: async (pending) => await this.#reconcilePendingOpen(pending, { allowRetry: false }),
+				withChannelMutationLock: async (run) => await this.#withChannelMutationLock(run),
+				ensureBindingCapacity: (key) => this.#detachedBindings.ensureCapacity(key),
+				finalizePendingBinding: (key, nextBinding) => this.#finalizePendingBinding(key, nextBinding),
+				warn: (message) => this.#logger().warn(message)
+			});
+		} finally {
+			await this.#ensureTimer();
+		}
+		if (!binding) return { state: "available" };
+		return discussionInfoForBinding(binding, account);
 	}
 	async reconcile(sessionKey) {
+		return await this.#withOperation(() => this.#reconcile(sessionKey));
+	}
+	async #reconcile(sessionKey) {
 		try {
 			await this.#withSessionLock(sessionKey, async () => {
 				const binding = this.#store.get(sessionKey);
 				if (binding) await this.#reconcileBinding(sessionKey, binding);
+				const pending = (await listPendingDiscussionOpens(this.#runtime)).find((candidate) => candidate.sessionKey === sessionKey);
+				if (pending) await this.#reconcilePendingOpen(pending);
 			});
-			const pending = listPendingDiscussionOpens(this.#runtime).find((candidate) => candidate.sessionKey === sessionKey);
-			if (pending) await this.#reconcilePendingOpen(pending);
 		} finally {
-			this.#ensureTimer();
+			await this.#ensureTimer();
 		}
 	}
 	async reconcileAll() {
-		if (this.#reconcileAllPromise) return await this.#reconcileAllPromise;
-		this.#reconcileAllPromise = (async () => {
-			for (const sessionKey of this.#listReconcileSessionKeys()) try {
-				await this.reconcile(sessionKey);
-			} catch (error) {
-				this.#logger().warn(`discussion reconcile failed for ${sessionKey}: ${String(error)}`);
-			}
-		})().finally(() => {
-			this.#reconcileAllPromise = void 0;
+		return await this.#withOperation(async () => {
+			if (this.#reconcileAllPromise) return await this.#reconcileAllPromise;
+			this.#reconcileAllPromise = (async () => {
+				try {
+					for (const sessionKey of await this.#listReconcileSessionKeys()) try {
+						await this.#reconcile(sessionKey);
+					} catch (error) {
+						this.#logger().warn(`discussion reconcile failed for ${sessionKey}: ${String(error)}`);
+					}
+				} finally {
+					await this.#ensureTimer();
+				}
+			})().finally(() => {
+				this.#reconcileAllPromise = void 0;
+			});
+			return await this.#reconcileAllPromise;
 		});
-		return await this.#reconcileAllPromise;
 	}
 	async readLatestMessages(sessionKey, limit) {
-		const binding = this.#store.get(sessionKey);
-		if (!binding) return { text: "No discussion is bound to this session." };
-		const resolved = await this.#resolveBindingForUse(binding);
-		if (resolved.state === "retargeted") return { text: "No discussion is bound to this session." };
-		if (resolved.state === "stale") return { text: "No discussion is bound to this session." };
-		if (resolved.state !== "active") return { text: "No discussion is bound to this session." };
-		const attached = this.#refreshSessionAttachment(sessionKey, binding);
-		if (!attached) return { text: "No discussion is bound to this session." };
-		if (isClickClackDiscussionChannelRevoked({
-			runtime: this.#runtime,
-			serverBaseUrl: binding.serverBaseUrl,
-			channelId: binding.channelId
-		})) return { text: "No discussion is bound to this session." };
-		return {
-			binding: attached,
-			text: formatDiscussionHistory(await this.#clientFactory(resolved.account).latestChannelMessages(attached.channelId, limit)) || "The bound discussion has no messages yet."
-		};
+		return await this.#withOperation(() => this.#withSessionLock(sessionKey, async () => {
+			const binding = this.#store.get(sessionKey);
+			if (!binding) return { text: "No discussion is bound to this session." };
+			const resolved = await this.#resolveBindingForUse(binding);
+			if (resolved.state === "retargeted") return { text: "No discussion is bound to this session." };
+			if (resolved.state === "stale") return { text: "No discussion is bound to this session." };
+			if (resolved.state !== "active") return { text: "No discussion is bound to this session." };
+			const attached = this.#refreshSessionAttachment(sessionKey, binding);
+			if (!attached) return { text: "No discussion is bound to this session." };
+			if (isClickClackDiscussionChannelRevoked({
+				runtime: this.#runtime,
+				serverBaseUrl: binding.serverBaseUrl,
+				channelId: binding.channelId
+			})) return { text: "No discussion is bound to this session." };
+			return {
+				binding: attached,
+				text: formatDiscussionHistory(await this.#clientFactory(resolved.account).latestChannelMessages(attached.channelId, limit)) || "The bound discussion has no messages yet."
+			};
+		}));
 	}
 	cleanup() {
 		this.#closed = true;
+		this.#activation += 1;
 		this.#unsubscribeSessionsChanged?.();
 		this.#unsubscribeSessionsChanged = void 0;
 		this.#reconcileScheduler.supersede();
@@ -669,9 +766,11 @@ var ClickClackDiscussionService = class {
 			clearInterval(this.#timer);
 			this.#timer = void 0;
 		}
+		this.#cleanupPromise ??= Promise.allSettled(this.#operations).then(() => void 0);
+		return this.#cleanupPromise;
 	}
 	async #reconcileBinding(sessionKey, binding, resolvedAccount) {
-		this.#finalizePendingBinding(sessionKey, binding);
+		await this.#finalizePendingBinding(sessionKey, binding);
 		if (isClickClackDiscussionChannelRevoked({
 			runtime: this.#runtime,
 			serverBaseUrl: binding.serverBaseUrl,
@@ -690,10 +789,7 @@ var ClickClackDiscussionService = class {
 		}
 		const activeBinding = this.#detachedBindings.clear(sessionKey, binding);
 		if (!activeBinding) return;
-		const resolved = resolvedAccount ? {
-			state: "active",
-			account: resolvedAccount
-		} : await this.#resolveBindingForUse(activeBinding);
+		const resolved = resolvedAccount ? resolveDiscussionBindingAccount(this.#currentConfig(), activeBinding) : await this.#resolveBindingForUse(activeBinding);
 		if (resolved.state === "retargeted") {
 			this.#revokeAndDeleteBinding(sessionKey, activeBinding);
 			return;
@@ -774,55 +870,18 @@ var ClickClackDiscussionService = class {
 		}
 	}
 	async #reconcilePendingOpen(pending, options = {}) {
-		const currentBinding = this.#store.get(pending.sessionKey);
-		if (currentBinding?.externalRef === pending.externalRef) {
-			this.#finalizePendingBinding(pending.sessionKey, currentBinding);
-			return;
-		}
-		const cfg = this.#currentConfig();
-		const account = listClickClackAccountIds(cfg).map((accountId) => resolveClickClackAccount({
-			cfg,
-			accountId
-		})).find((candidate) => candidate.configured && normalizedServerBaseUrl(candidate) === pending.serverBaseUrl && discussionCredentialFingerprint(candidate.token) === pending.credentialFingerprint);
-		if (!account) return;
-		const client = this.#clientFactory(account);
-		const entry = this.#runtime.agent.session.getSessionEntry({
-			sessionKey: pending.sessionKey,
-			readConsistency: "latest"
-		});
-		const activeAccounts = discussionAccounts(cfg);
-		const retryAccount = activeAccounts.length === 1 ? activeAccounts[0] : void 0;
-		if (options.allowRetry !== false && entry?.sessionId && entry.archivedAt === void 0 && retryAccount && normalizedServerBaseUrl(retryAccount) === pending.serverBaseUrl && discussionCredentialFingerprint(retryAccount.token) === pending.credentialFingerprint) {
-			if ((await this.#clientFactory(retryAccount).workspaces()).find((candidate) => candidate.id === retryAccount.discussions.workspace || candidate.slug === retryAccount.discussions.workspace || candidate.name === retryAccount.discussions.workspace)?.id === pending.workspaceId) {
-				await this.open(pending.sessionKey);
-				return;
-			}
-		}
-		const channels = await client.channels(pending.workspaceId);
-		assertManagedChannelListContract(channels);
-		const channel = channels.find((candidate) => candidate.external_managed === true && candidate.external_ref === pending.externalRef);
-		if (channel) {
-			markClickClackDiscussionChannelIdentityRevoked({
-				runtime: this.#runtime,
-				accountId: pending.accountId,
-				serverBaseUrl: pending.serverBaseUrl,
-				channelId: channel.id
-			});
-			clearPendingDiscussionOpen({
-				runtime: this.#runtime,
-				sessionKey: pending.sessionKey,
-				expectedGeneration: pending.generation
-			});
-			return;
-		}
-		clearDiscussionBindingGeneration({
+		await reconcilePendingDiscussionOpen({
 			runtime: this.#runtime,
-			sessionKey: pending.sessionKey,
-			expectedGeneration: pending.generation
+			store: this.#store,
+			clientFactory: this.#clientFactory,
+			pending,
+			...options,
+			finalizePendingBinding: (key, binding) => this.#finalizePendingBinding(key, binding),
+			open: (key) => this.#open(key)
 		});
 	}
 	async #releaseStaleBinding(sessionKey, binding) {
-		clearDiscussionBindingGeneration({
+		await clearDiscussionBindingGeneration({
 			runtime: this.#runtime,
 			sessionKey
 		});
@@ -832,15 +891,15 @@ var ClickClackDiscussionService = class {
 		markClickClackDiscussionChannelRevoked(this.#runtime, binding);
 		this.#store.delete(sessionKey);
 	}
-	#finalizePendingBinding(sessionKey, binding) {
-		const pending = listPendingDiscussionOpens(this.#runtime).find((candidate) => candidate.sessionKey === sessionKey && candidate.externalRef === binding.externalRef);
+	async #finalizePendingBinding(sessionKey, binding) {
+		const pending = (await listPendingDiscussionOpens(this.#runtime)).find((candidate) => candidate.sessionKey === sessionKey && candidate.externalRef === binding.externalRef);
 		if (pending) {
 			clearClickClackDiscussionChannelRevoked({
 				runtime: this.#runtime,
 				serverBaseUrl: binding.serverBaseUrl,
 				channelId: binding.channelId
 			});
-			clearDiscussionBindingGeneration({
+			await clearDiscussionBindingGeneration({
 				runtime: this.#runtime,
 				sessionKey,
 				expectedGeneration: pending.generation
@@ -850,13 +909,17 @@ var ClickClackDiscussionService = class {
 	async #resolveBindingForUse(binding) {
 		const resolved = resolveDiscussionBindingAccount(this.#currentConfig(), binding);
 		if (resolved.state !== "active") return resolved;
-		return (await this.#clientFactory(resolved.account).workspaces()).find((candidate) => candidate.id === resolved.account.discussions.workspace || candidate.slug === resolved.account.discussions.workspace || candidate.name === resolved.account.discussions.workspace)?.id === binding.workspaceId ? resolved : { state: "retargeted" };
+		const workspace = (await this.#clientFactory(resolved.account).workspaces()).find((candidate) => candidate.id === resolved.account.discussions.workspace || candidate.slug === resolved.account.discussions.workspace || candidate.name === resolved.account.discussions.workspace);
+		const current = resolveDiscussionBindingAccount(this.#currentConfig(), binding);
+		if (current.state !== "active") return current;
+		return workspace?.id === binding.workspaceId ? current : { state: "retargeted" };
 	}
 	#currentConfig() {
 		return this.#runtime.config.current();
 	}
-	#ensureTimer() {
-		const hasPendingOpens = listPendingDiscussionOpens(this.#runtime).length > 0;
+	async #ensureTimer() {
+		if (this.#closed) return;
+		const hasPendingOpens = (await listPendingDiscussionOpens(this.#runtime)).length > 0;
 		const needsBindingPoll = this.#unsubscribeSessionsChanged === void 0 && this.#store.count() > 0;
 		if (this.#closed || !hasPendingOpens && !needsBindingPoll) {
 			if (this.#timer) {
@@ -869,14 +932,12 @@ var ClickClackDiscussionService = class {
 		this.#timer = setInterval(() => {
 			this.reconcileAll().catch((error) => {
 				this.#logger().warn(`discussion reconcile pass failed: ${String(error)}`);
-			}).finally(() => {
-				this.#ensureTimer();
 			});
 		}, RECONCILE_INTERVAL_MS);
 		this.#timer.unref?.();
 	}
-	#listReconcileSessionKeys() {
-		return /* @__PURE__ */ new Set([...this.#store.entries().map(({ sessionKey }) => sessionKey), ...listPendingDiscussionOpens(this.#runtime).map(({ sessionKey }) => sessionKey)]);
+	async #listReconcileSessionKeys() {
+		return /* @__PURE__ */ new Set([...this.#store.entries().map(({ sessionKey }) => sessionKey), ...(await listPendingDiscussionOpens(this.#runtime)).map(({ sessionKey }) => sessionKey)]);
 	}
 	#logger() {
 		return this.#runtime.logging.getChildLogger({
@@ -884,6 +945,13 @@ var ClickClackDiscussionService = class {
 			feature: "discussions"
 		});
 	}
+	#withOperation(run) {
+		if (this.#closed) return Promise.reject(/* @__PURE__ */ new Error("ClickClack discussion service is stopped"));
+		const operation = Promise.resolve().then(run);
+		this.#operations.add(operation);
+		operation.then(() => this.#operations.delete(operation), () => this.#operations.delete(operation));
+		return operation;
+	}
 	async #withSessionLock(sessionKey, run) {
 		const current = (this.#sessionLocks.get(sessionKey) ?? Promise.resolve()).catch(() => void 0).then(run);
 		this.#sessionLocks.set(sessionKey, current);
@@ -981,12 +1049,8 @@ function registerClickClackDiscussions(api) {
 	const service = new ClickClackDiscussionService(api.runtime);
 	api.registerService({
 		id: "clickclack-discussion-session-events",
-		start: ({ gatewayEvents }) => {
-			service.bindGatewayEvents(gatewayEvents);
-		},
-		stop: () => {
-			service.cleanup();
-		}
+		start: ({ gatewayEvents }) => service.bindGatewayEvents(gatewayEvents),
+		stop: () => service.cleanup()
 	});
 	api.registerTool((context) => createClickClackDiscussionTool({
 		service,
@@ -1011,7 +1075,7 @@ function registerClickClackDiscussions(api) {
 		description: "Stops the lifecycle reconciler for managed ClickClack discussions.",
 		cleanup: () => {
 			unregisterSessionAccess();
-			service.cleanup();
+			return service.cleanup();
 		}
 	});
 }

package/dist/api.js

@@ -1,3 +1,3 @@
 import { _ as DEFAULT_ACCOUNT_ID, b as resolveClickClackAccount, p as clickClackConfigSchema, u as createClickClackClient, v as listClickClackAccountIds, x as resolveDefaultClickClackAccountId, y as listEnabledClickClackAccounts } from "./.setup/setup-surface-BBl3rvVx.mjs";
-import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-yIQ_PUDD.mjs";
+import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-CT4CVd4d.mjs";
 export { DEFAULT_ACCOUNT_ID, buildClickClackTarget, clickClackConfigSchema, clickClackPlugin, createClickClackClient, getClickClackRuntime, listClickClackAccountIds, listEnabledClickClackAccounts, parseClickClackTarget, resolveClickClackAccount, resolveDefaultClickClackAccountId, setClickClackRuntime };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackPlugin } from "./.setup/channel-yIQ_PUDD.mjs";
+import { t as clickClackPlugin } from "./.setup/channel-CT4CVd4d.mjs";
 export { clickClackPlugin };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-D9Bwyc44.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-A9r1b12d.mjs";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/clickclack/index.ts
 /**