@openclaw/clickclack 2026.10.5-beta.4 → 2026.10.10-beta.2

package/README.md

@@ -18,7 +18,7 @@ openclaw channels add clickclack --code 'https://clickclack.example.com/#XXXX-XX
 
 Split-origin and path-mounted ClickClack deployments generate an exact
 `/api/bot-setup-codes/claim#CODE` endpoint. OpenClaw validates the versioned
-claim response and saves its canonical API base.
+claim response and saves its normalized API base URL.
 
 For manual token setup:
 
@@ -104,7 +104,7 @@ category changes remain reflected in the channel, but session archive, restore,
 reset, and deletion never archive or replace it. ClickClack owns channel archive
 and restore independently. `workspace`
 defaults to the account workspace, and `section` defaults to `Sessions`.
-`controlUrlBase` adds canonical `/chat/<agent>/<session-ref>` links to the
+`controlUrlBase` adds standard `/chat/<agent>/<session-ref>` links to the
 OpenClaw Control UI, preserving base paths. Main sessions use `/chat/<agent>`.
 
 ClickClack-managed embed URLs explicitly advertise host-theme support. The
@@ -131,7 +131,7 @@ and scoped grant. The previous side session cannot access the new main session.
 Messages arriving through an inactive, disabled, or retargeted managed
 binding are dropped instead of falling back to the account's normal channel
 routing. Released bindings leave a durable revoked-channel marker so delayed
-realtime events remain fail-closed. Remote ownership is keyed by ClickClack
+realtime events are still rejected. Remote ownership is keyed by ClickClack
 server and channel id, so renaming the local account cannot turn a managed
 channel into an ordinary one.
 

package/dist/.setup/{channel-BFuhVeiX.mjs → channel-DRcZ_twH.mjs}

@@ -1,5 +1,5 @@
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { c as CLICKCLACK_CHANNEL_ID, d as DEFAULT_ACCOUNT_ID, f as isClickClackAccountCurrent, g as resolveClickClackAccountConfig, h as resolveClickClackAccount, l as clickClackConfigAdapter, m as listEnabledClickClackAccounts, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BJ5D55LV.mjs";
+import { c as CLICKCLACK_CHANNEL_ID, d as DEFAULT_ACCOUNT_ID, f as isClickClackAccountCurrent, g as resolveClickClackAccountConfig, h as resolveClickClackAccount, l as clickClackConfigAdapter, m as listEnabledClickClackAccounts, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BJ3jioqA.mjs";
 import { a as createClickClackClient, i as ClickClackHttpError, n as resolveChannelId, r as resolveWorkspaceId, s as normalizeClickClackCorrelationId } from "./resolve-Br3ylpSz.mjs";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-CF7TKtkU.mjs";
 import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/account-helpers";
@@ -19,6 +19,7 @@ import { formatNormalizedAllowFromEntries, resolveAllowlistMatchByCandidates } f
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { createHash, randomUUID } from "node:crypto";
 import { createAsyncLock } from "openclaw/plugin-sdk/async-lock-runtime";
+import { assertPluginStateReadAvailable, preparePluginStateRead } from "openclaw/plugin-sdk/plugin-state-runtime";
 import { truncateCodePoints } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
@@ -54,10 +55,8 @@ const storesByRuntime$2 = /* @__PURE__ */ new WeakMap();
 function withGenerationStore(runtime, run) {
 	let owner = storesByRuntime$2.get(runtime);
 	if (!owner) {
-		const store = runtime.state.openKeyedStore(GENERATION_STORE_OPTIONS);
 		owner = {
-			store,
-			...!store.observe || !store.compareAndApply ? { native: runtime.state.openSyncKeyedStore(GENERATION_STORE_OPTIONS) } : {},
+			store: runtime.state.openKeyedStoreV2(GENERATION_STORE_OPTIONS),
 			withLock: createAsyncLock()
 		};
 		storesByRuntime$2.set(runtime, owner);
@@ -66,18 +65,8 @@ function withGenerationStore(runtime, run) {
 	return currentOwner.withLock(() => run(currentOwner));
 }
 function mutateGeneration(runtime, sessionKey, decide) {
-	return withGenerationStore(runtime, async ({ store, native }) => {
-		if (native) {
-			const current = native.lookup(sessionKey);
-			const next = decide(current);
-			if (next.value !== current) {
-				if (next.value) native.register(sessionKey, next.value);
-				else native.delete(sessionKey);
-			}
-			return next.result;
-		}
+	return withGenerationStore(runtime, async ({ store }) => {
 		const { observe, compareAndApply } = store;
-		if (!observe || !compareAndApply) throw new Error("ClickClack generation comparison capabilities changed");
 		let observed = await observe(sessionKey);
 		for (;;) {
 			const next = decide(observed.value);
@@ -144,6 +133,16 @@ function recordPendingDiscussionOpen(params) {
 		};
 	});
 }
+function getPendingDiscussionOpen(runtime, sessionKey) {
+	return withGenerationStore(runtime, async ({ store }) => {
+		const entry = await store.lookup(sessionKey);
+		return entry?.pending ? {
+			sessionKey,
+			generation: entry.generation,
+			...entry.pending
+		} : void 0;
+	});
+}
 function listPendingDiscussionOpens(runtime) {
 	return withGenerationStore(runtime, async ({ store }) => (await store.entries()).flatMap((entry) => entry.value.pending ? [{
 		sessionKey: entry.key,
@@ -187,18 +186,15 @@ async function readDiscussionSessionEntry(runtime, sessionKey) {
 		sessionKey,
 		readConsistency: "latest"
 	};
-	return runtime.agent.session.getSessionEntryAsync ? await runtime.agent.session.getSessionEntryAsync(params) : runtime.agent.session.getSessionEntry(params);
+	return await runtime.agent.session.getSessionEntryAsync(params);
 }
 /**
 * Refresh the replaceable session attachment without changing the durable room identity.
 * The store registers persisted state before reindexing, so a failed write leaves the
 * previous attachment authoritative in both persistence and memory.
 */
-function attachBindingToCurrentActiveSession(params) {
-	const entry = params.runtime.agent.session.getSessionEntry({
-		sessionKey: params.sessionKey,
-		readConsistency: "latest"
-	});
+async function attachBindingToCurrentActiveSession(params) {
+	const entry = await readDiscussionSessionEntry(params.runtime, params.sessionKey);
 	if (!entry?.sessionId || entry.archivedAt !== void 0) return;
 	if (entry.sessionId === params.binding.sessionId && params.binding.detachedAt === void 0) return params.binding;
 	const { detachedAt: _detachedAt, ...retained } = params.binding;
@@ -206,8 +202,10 @@ function attachBindingToCurrentActiveSession(params) {
 		...retained,
 		sessionId: entry.sessionId
 	};
-	params.store.set(params.sessionKey, attached);
-	return attached;
+	return await params.store.setIfCurrent(params.sessionKey, params.binding, attached, { assertCurrent: () => {
+		const current = params.store.get(params.sessionKey);
+		if (!current || current.externalRef !== params.binding.externalRef || current.serverBaseUrl !== params.binding.serverBaseUrl || current.channelId !== params.binding.channelId || !bindingMatchesActiveSessionIncarnation(params.runtime, params.sessionKey, attached)) throw new Error("ClickClack discussion session changed before attachment committed");
+	} }) ? attached : void 0;
 }
 const DISCUSSION_BINDINGS_NAMESPACE = "discussion-bindings";
 const MAX_DISCUSSION_BINDINGS = 1e4;
@@ -223,18 +221,18 @@ function channelKey(serverBaseUrl, channelId) {
 }
 /** SQLite-backed session/channel bindings with a process-local inbound lookup index. */
 var ClickClackDiscussionBindingStore = class {
+	#nativeStore;
 	#store;
-	#asyncStore;
 	#sessionByChannel = /* @__PURE__ */ new Map();
 	#detachedAtBySession = /* @__PURE__ */ new Map();
 	#channelBySession = /* @__PURE__ */ new Map();
 	#runtime;
+	#withMutation = createAsyncLock();
 	#prepared = false;
 	#preparing;
 	#changedDuringPreparation = /* @__PURE__ */ new Set();
 	constructor(runtime) {
 		this.#runtime = runtime;
-		this.#store = runtime.state.openSyncKeyedStore(BINDING_STORE_OPTIONS);
 	}
 	async prepare() {
 		if (!this.#prepared) await this.entries();
@@ -242,19 +240,29 @@ var ClickClackDiscussionBindingStore = class {
 	async getAsync(sessionKey) {
 		return await this.#workerStore().lookup(sessionKey);
 	}
+	async prepareRead(sessionKey) {
+		return await preparePluginStateRead(this.#workerStore(), sessionKey) ?? {
+			read: () => this.get(sessionKey),
+			release() {}
+		};
+	}
 	get(sessionKey) {
-		return this.#store.lookup(sessionKey);
+		this.#nativeStore ??= this.#runtime.state.openSyncKeyedStore(BINDING_STORE_OPTIONS);
+		return this.#nativeStore.lookup(sessionKey);
+	}
+	assertReadAvailable() {
+		assertPluginStateReadAvailable(this.#workerStore());
 	}
 	async hasCapacity(sessionKey) {
 		return await this.getAsync(sessionKey) !== void 0 || await this.countAsync() < MAX_DISCUSSION_BINDINGS;
 	}
-	getByChannel(serverBaseUrl, channelId) {
+	async getByChannel(serverBaseUrl, channelId) {
 		const key = channelKey(serverBaseUrl, channelId);
 		const sessionKey = this.#sessionByChannel.get(key);
 		if (!sessionKey) return;
-		const binding = this.get(sessionKey);
+		const binding = await this.getAsync(sessionKey);
 		if (!binding || channelKey(binding.serverBaseUrl, binding.channelId) !== key) {
-			this.#sessionByChannel.delete(key);
+			if (this.#sessionByChannel.get(key) === sessionKey) this.#sessionByChannel.delete(key);
 			return;
 		}
 		return {
@@ -262,17 +270,66 @@ var ClickClackDiscussionBindingStore = class {
 			binding
 		};
 	}
-	set(sessionKey, binding) {
-		this.#store.register(sessionKey, binding);
+	async setIfCurrent(sessionKey, expected, binding, options) {
+		return await this.#mutateIfCurrent(sessionKey, expected, binding, options);
+	}
+	async observeCurrent(sessionKey) {
+		return await this.#withMutation(async () => {
+			const observed = await this.#workerStore().observe(sessionKey);
+			this.#publish(sessionKey, observed.value);
+			return {
+				binding: observed.value,
+				condition: {
+					namespace: DISCUSSION_BINDINGS_NAMESPACE,
+					key: sessionKey,
+					comparison: observed.comparison
+				}
+			};
+		});
+	}
+	async deleteIfCurrent(sessionKey, expected, options) {
+		return await this.#mutateIfCurrent(sessionKey, expected, void 0, options);
+	}
+	async #mutateIfCurrent(sessionKey, expected, next, options) {
+		return await this.#withMutation(async () => {
+			const worker = this.#workerStore();
+			const observed = await worker.observe(sessionKey);
+			if (!isDeepStrictEqual(observed.value, expected)) {
+				this.#publish(sessionKey, observed.value);
+				return false;
+			}
+			let authorityRejected = false;
+			try {
+				const result = await (options?.assertCurrent ? this.#runtime.state.openKeyedStoreV2(BINDING_STORE_OPTIONS, { assertCurrent: () => {
+					try {
+						options.assertCurrent?.();
+					} catch (error) {
+						authorityRejected = true;
+						throw error;
+					}
+				} }) : worker).compareAndApply(sessionKey, observed.comparison, next ? {
+					operation: "update",
+					action: "set",
+					value: next
+				} : {
+					operation: "delete",
+					action: "delete"
+				});
+				this.#publish(sessionKey, result.status === "conflict" ? result.current.value : next);
+				return result.status === "applied";
+			} catch (error) {
+				if (!authorityRejected) throw error;
+				const current = await worker.observe(sessionKey);
+				if (current.comparison === observed.comparison) throw error;
+				this.#publish(sessionKey, current.value);
+				return false;
+			}
+		});
+	}
+	#publish(sessionKey, binding) {
 		if (!this.#prepared) this.#changedDuringPreparation.add(sessionKey);
 		this.#unindex(sessionKey);
-		this.#index(sessionKey, binding);
-	}
-	delete(sessionKey) {
-		const deleted = this.#store.delete(sessionKey);
-		if (deleted && !this.#prepared) this.#changedDuringPreparation.add(sessionKey);
-		if (deleted) this.#unindex(sessionKey);
-		return deleted;
+		if (binding) this.#index(sessionKey, binding);
 	}
 	async entries() {
 		const load = async () => (await this.#workerStore().entries()).map((entry) => ({
@@ -291,16 +348,15 @@ var ClickClackDiscussionBindingStore = class {
 		return await this.#preparing;
 	}
 	async countAsync() {
-		const store = this.#workerStore();
-		return store.count ? await store.count() : (await this.entries()).length;
+		return await this.#workerStore().count();
 	}
 	detachedCount() {
 		return this.#detachedAtBySession.size;
 	}
 	#workerStore() {
-		return this.#asyncStore ??= this.#runtime.state.openKeyedStore(BINDING_STORE_OPTIONS);
+		return this.#store ??= this.#runtime.state.openKeyedStoreV2(BINDING_STORE_OPTIONS);
 	}
-	oldestDetached() {
+	async oldestDetached() {
 		let oldestSessionKey;
 		let oldestDetachedAt = Number.POSITIVE_INFINITY;
 		for (const [sessionKey, detachedAt] of this.#detachedAtBySession) if (detachedAt < oldestDetachedAt || detachedAt === oldestDetachedAt && (oldestSessionKey === void 0 || sessionKey < oldestSessionKey)) {
@@ -308,9 +364,9 @@ var ClickClackDiscussionBindingStore = class {
 			oldestDetachedAt = detachedAt;
 		}
 		if (!oldestSessionKey) return;
-		const binding = this.get(oldestSessionKey);
+		const binding = await this.getAsync(oldestSessionKey);
 		if (!binding || binding.detachedAt === void 0) {
-			this.#detachedAtBySession.delete(oldestSessionKey);
+			if (this.#detachedAtBySession.get(oldestSessionKey) === oldestDetachedAt) this.#detachedAtBySession.delete(oldestSessionKey);
 			return this.oldestDetached();
 		}
 		return {
@@ -427,106 +483,172 @@ function discussionInfoForBinding(binding, account) {
 }
 //#endregion
 //#region extensions/clickclack/src/discussions/revoked-channel-store.ts
-const REVOKED_CHANNELS_NAMESPACE = "discussion-revoked-channels";
-const MAX_REVOKED_CHANNELS = 1e5;
+const STORE_OPTIONS = {
+	namespace: "discussion-revoked-channels",
+	maxEntries: 1e5,
+	overflowPolicy: "reject-new"
+};
 const storesByRuntime = /* @__PURE__ */ new WeakMap();
+const nativeStoresByRuntime = /* @__PURE__ */ new WeakMap();
 function revokedChannelKey(params) {
 	return [params.serverBaseUrl.replace(/\/+$/u, ""), params.channelId].join("\0");
 }
 function getStore(runtime) {
 	const existing = storesByRuntime.get(runtime);
 	if (existing) return existing;
-	const created = runtime.state.openSyncKeyedStore({
-		namespace: REVOKED_CHANNELS_NAMESPACE,
-		maxEntries: MAX_REVOKED_CHANNELS,
-		overflowPolicy: "reject-new"
-	});
+	const created = runtime.state.openKeyedStoreV2(STORE_OPTIONS);
 	storesByRuntime.set(runtime, created);
 	return created;
 }
 /** Records managed ownership before its live binding is released. */
-function markClickClackDiscussionChannelRevoked(runtime, binding) {
+async function markClickClackDiscussionChannelRevoked(runtime, sessionKey, binding, options) {
 	const value = {
 		accountId: binding.accountId,
 		serverBaseUrl: binding.serverBaseUrl,
 		channelId: binding.channelId,
-		revokedAt: Date.now()
+		revokedAt: Date.now(),
+		binding
 	};
-	getStore(runtime).register(revokedChannelKey(value), value);
+	const bindings = getClickClackDiscussionBindingStore(runtime);
+	for (;;) {
+		const owner = await bindings.observeCurrent(sessionKey);
+		const isCurrent = isDeepStrictEqual(owner.binding, binding);
+		const observed = await getStore(runtime).observe(revokedChannelKey(value));
+		if (observed.value && !observed.value.binding) return isCurrent;
+		if (!isCurrent && observed.value) return false;
+		let authorityRejected = false;
+		try {
+			if ((await (isCurrent && options?.assertCurrent ? runtime.state.openKeyedStoreV2(STORE_OPTIONS, { assertCurrent: () => {
+				try {
+					options.assertCurrent?.();
+				} catch (error) {
+					authorityRejected = true;
+					throw error;
+				}
+			} }) : getStore(runtime)).compareAndApply(revokedChannelKey(value), observed.comparison, {
+				operation: "update",
+				action: "set",
+				value
+			}, { conditions: [owner.condition] })).status !== "conflict") return isCurrent;
+		} catch (error) {
+			if (authorityRejected) {
+				const current = await bindings.observeCurrent(sessionKey);
+				if (!isDeepStrictEqual(current.binding, binding)) continue;
+			}
+			throw error;
+		}
+	}
 }
-function markClickClackDiscussionChannelIdentityRevoked(params) {
+async function markClickClackDiscussionChannelIdentityRevoked(params) {
 	const value = {
 		accountId: params.accountId,
 		serverBaseUrl: params.serverBaseUrl.replace(/\/+$/u, ""),
 		channelId: params.channelId,
 		revokedAt: Date.now()
 	};
-	getStore(params.runtime).register(revokedChannelKey(value), value);
+	await getStore(params.runtime).register(revokedChannelKey(value), value);
 }
-function clearClickClackDiscussionChannelRevoked(params) {
-	getStore(params.runtime).delete(revokedChannelKey(params));
+async function clearClickClackDiscussionChannelRevoked(params) {
+	await getStore(params.runtime).delete(revokedChannelKey(params));
 }
 /** Distinguishes a released managed channel from a genuinely ordinary channel. */
 function isClickClackDiscussionChannelRevoked(params) {
-	return Boolean(getStore(params.runtime).lookup(revokedChannelKey(params)));
+	let store = nativeStoresByRuntime.get(params.runtime);
+	if (!store) {
+		store = params.runtime.state.openSyncKeyedStore(STORE_OPTIONS);
+		nativeStoresByRuntime.set(params.runtime, store);
+	}
+	return revocationApplies(store.lookup(revokedChannelKey(params)), params.binding);
+}
+async function prepareClickClackDiscussionChannelRevocation(params) {
+	const facts = await preparePluginStateRead(getStore(params.runtime), revokedChannelKey(params));
+	return {
+		isRevoked: (binding) => {
+			if (binding && revokedChannelKey(binding) !== revokedChannelKey(params)) return true;
+			return facts ? revocationApplies(facts.read(), binding) : isClickClackDiscussionChannelRevoked({
+				...params,
+				binding
+			});
+		},
+		release: () => facts?.release()
+	};
+}
+async function isClickClackDiscussionChannelRevokedAsync(params) {
+	return revocationApplies(await getStore(params.runtime).lookup(revokedChannelKey(params)), params.binding);
+}
+function revocationApplies(revoked, binding) {
+	return Boolean(revoked && (!binding || !revoked.binding || isDeepStrictEqual(revoked.binding, binding)));
 }
 //#endregion
 //#region extensions/clickclack/src/discussions/routing.ts
 async function resolveClickClackDiscussionRoute(params) {
 	const store = getClickClackDiscussionBindingStore(params.runtime);
 	await store.prepare();
-	let matched = store.getByChannel(params.serverBaseUrl, params.channelId);
+	let matched = await store.getByChannel(params.serverBaseUrl, params.channelId);
 	let pending = false;
 	if (!matched) {
 		pending = await hasPendingDiscussionOpenForDestination(params);
-		matched = store.getByChannel(params.serverBaseUrl, params.channelId);
+		matched = await store.getByChannel(params.serverBaseUrl, params.channelId);
 	}
-	if (isClickClackDiscussionChannelRevoked(params)) return { state: "revoked" };
-	if (!matched) return { state: pending ? "revoked" : "unbound" };
-	if (matched.binding.accountId !== params.accountId) return { state: "revoked" };
-	if (matched.binding.serverBaseUrl !== params.serverBaseUrl.replace(/\/+$/u, "")) return { state: "revoked" };
-	if (resolveDiscussionBindingAccount(params.runtime.config.current(), matched.binding).state !== "active") return { state: "revoked" };
-	let binding;
+	let revocation;
+	let bindingFacts;
 	try {
-		binding = attachBindingToCurrentActiveSession({
+		revocation = await prepareClickClackDiscussionChannelRevocation(params);
+		if (revocation.isRevoked(matched?.binding)) return { state: "revoked" };
+		if (!matched) return { state: pending ? "revoked" : "unbound" };
+		if (matched.binding.accountId !== params.accountId) return { state: "revoked" };
+		if (matched.binding.serverBaseUrl !== params.serverBaseUrl.replace(/\/+$/u, "")) return { state: "revoked" };
+		if (resolveDiscussionBindingAccount(params.runtime.config.current(), matched.binding).state !== "active") return { state: "revoked" };
+		bindingFacts = await store.prepareRead(matched.sessionKey);
+		let binding;
+		try {
+			binding = await attachBindingToCurrentActiveSession({
+				runtime: params.runtime,
+				store,
+				sessionKey: matched.sessionKey,
+				binding: matched.binding
+			});
+		} catch (error) {
+			params.runtime.logging.getChildLogger({
+				plugin: "clickclack",
+				feature: "discussions"
+			}).warn(`discussion attachment refresh failed for channel ${params.channelId}: ${String(error)}`);
+			return { state: "revoked" };
+		}
+		if (!binding) return { state: "revoked" };
+		const current = bindingFacts.read();
+		if (!current || current.externalRef !== binding.externalRef || current.channelId !== binding.channelId || revocation.isRevoked(current) || !bindingMatchesActiveSessionIncarnation(params.runtime, matched.sessionKey, binding) || resolveDiscussionBindingAccount(params.runtime.config.current(), binding).state !== "active") return { state: "revoked" };
+		const sessionKey = discussionSessionKey({
 			runtime: params.runtime,
-			store,
-			sessionKey: matched.sessionKey,
-			binding: matched.binding
+			agentId: binding.agentId,
+			mainSessionKey: matched.sessionKey,
+			sessionId: binding.sessionId,
+			accountId: params.accountId,
+			serverBaseUrl: binding.serverBaseUrl,
+			channelId: binding.channelId,
+			externalRef: binding.externalRef
 		});
-	} catch (error) {
-		params.runtime.logging.getChildLogger({
-			plugin: "clickclack",
-			feature: "discussions"
-		}).warn(`discussion attachment refresh failed for channel ${params.channelId}: ${String(error)}`);
+		if (!sessionKey) return { state: "revoked" };
+		return {
+			state: "active",
+			route: {
+				agentId: binding.agentId,
+				sessionKey,
+				systemPrompt: [
+					"You are the side agent for a ClickClack discussion attached to an OpenClaw session.",
+					`The main session key is ${matched.sessionKey}.`,
+					"Observe it with sessions_history and session_status (using changesSince for incremental checks).",
+					"Use sessions_send to relay or steer the main session only when the humans in this discussion ask you to.",
+					"These session tools are host-scoped to the attached main session; do not attempt session discovery or alternate targets."
+				].join(" ")
+			}
+		};
+	} catch {
 		return { state: "revoked" };
+	} finally {
+		bindingFacts?.release();
+		revocation?.release();
 	}
-	if (!binding) return { state: "revoked" };
-	const sessionKey = discussionSessionKey({
-		runtime: params.runtime,
-		agentId: binding.agentId,
-		mainSessionKey: matched.sessionKey,
-		sessionId: binding.sessionId,
-		accountId: params.accountId,
-		serverBaseUrl: binding.serverBaseUrl,
-		channelId: binding.channelId,
-		externalRef: binding.externalRef
-	});
-	if (!sessionKey) return { state: "revoked" };
-	return {
-		state: "active",
-		route: {
-			agentId: binding.agentId,
-			sessionKey,
-			systemPrompt: [
-				"You are the side agent for a ClickClack discussion attached to an OpenClaw session.",
-				`The main session key is ${matched.sessionKey}.`,
-				"Observe it with sessions_history and session_status (using changesSince for incremental checks).",
-				"Use sessions_send to relay or steer the main session only when the humans in this discussion ask you to.",
-				"These session tools are host-scoped to the attached main session; do not attempt session discovery or alternate targets."
-			].join(" ")
-		}
-	};
 }
 //#endregion
 //#region extensions/clickclack/src/group-policy.ts
@@ -1271,9 +1393,9 @@ function createOutboundContext(params) {
 }
 async function sendClickClackText(params) {
 	const text = sanitizeAssistantVisibleText(params.text);
-	if (!text) return;
+	if (!text) return { outcome: "not_sent" };
 	const { account, client } = createOutboundContext(params);
-	return (await createTargetMessage({
+	return { messageId: (await createTargetMessage({
 		client,
 		workspaceId: await resolveWorkspaceId(client, account.workspace),
 		to: params.to,
@@ -1284,7 +1406,7 @@ async function sendClickClackText(params) {
 		nonce: textDeliveryNonce(params),
 		onPlatformSendDispatch: params.onPlatformSendDispatch,
 		assertDirectAdapterHandoff: params.assertDirectAdapterHandoff
-	})).id;
+	})).id };
 }
 async function sendClickClackMedia(params) {
 	const nonces = mediaDeliveryNonces(params);
@@ -1559,13 +1681,6 @@ function createClickClackAgentProgressPublisher(params) {
 		const controlFrames = queue.filter((frame) => !frame.lineId);
 		queue.splice(0, queue.length, ...controlFrames);
 	};
-	const waitForDrainWithinFinalizeGrace = async (pending) => {
-		let drained = false;
-		await raceWithTimeout(pending.then(() => {
-			drained = true;
-		}), CLICKCLACK_PROGRESS_FINALIZE_GRACE_MS, () => void 0);
-		return drained;
-	};
 	const scheduleLineDrain = () => {
 		if (lineDrainTimer) return;
 		lineDrainTimer = setTimeout(() => {
@@ -1650,7 +1765,7 @@ function createClickClackAgentProgressPublisher(params) {
 			}
 			flushQueuedLines();
 			enqueue({ op: "clear" });
-			if (!await waitForDrainWithinFinalizeGrace(drain())) discardQueuedLines();
+			if (!await raceWithTimeout(drain().then(() => true), CLICKCLACK_PROGRESS_FINALIZE_GRACE_MS, () => false)) discardQueuedLines();
 		}
 	};
 }
@@ -2169,18 +2284,18 @@ const clickClackMessageAdapter = defineChannelMessageAdapter({
 	},
 	send: {
 		text: async (ctx) => {
-			const messageId = await sendClickClackText({
+			const result = await sendClickClackText({
 				...ctx,
 				cfg: ctx.cfg
 			});
 			const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
 			const replyToId = ctx.replyToId ?? void 0;
 			return {
-				...messageId ? { messageId } : {},
+				...result,
 				receipt: createMessageReceiptFromOutboundResults({
-					results: messageId ? [{
+					results: "messageId" in result ? [{
 						channel: CHANNEL_ID,
-						messageId
+						messageId: result.messageId
 					}] : [],
 					threadId,
 					replyToId,
@@ -2299,12 +2414,13 @@ const clickClackPlugin = createChatChannelPlugin({
 		base: { deliveryMode: "direct" },
 		attachedResults: {
 			channel: CHANNEL_ID,
-			sendText: async (ctx) => {
-				return { messageId: await sendClickClackText({
+			sendText: async (ctx) => ({
+				messageId: "",
+				...await sendClickClackText({
 					...ctx,
 					cfg: ctx.cfg
-				}) ?? "" };
-			},
+				})
+			}),
 			sendMedia: async (ctx) => {
 				const { mediaUrl, onDeliveryResult } = ctx;
 				if (!mediaUrl) throw new Error("ClickClack media send requires mediaUrl");
@@ -2323,4 +2439,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { recordPendingDiscussionOpen as A, attachBindingToCurrentActiveSession as C, clearDiscussionBindingGeneration as D, readDiscussionSessionEntry as E, clearPendingDiscussionOpen as O, MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS as S, getClickClackDiscussionBindingStore as T, fallbackDiscussionLabel as _, setClickClackRuntime as a, slugifyDiscussionLabel as b, markClickClackDiscussionChannelIdentityRevoked as c, discussionInfoForBinding as d, normalizedServerBaseUrl as f, discussionSessionKey as g, discussionExternalRef as h, getClickClackRuntime as i, reserveDiscussionBindingGeneration as j, listPendingDiscussionOpens as k, markClickClackDiscussionChannelRevoked as l, discussionCredentialFingerprint as m, buildClickClackTarget as n, clearClickClackDiscussionChannelRevoked as o, resolveDiscussionBindingAccount as p, parseClickClackTarget as r, isClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, discussionAccounts as u, isDiscussionSessionKey as v, bindingMatchesActiveSessionIncarnation as w, truncateDiscussionDisplayTitle as x, resolveDiscussionLabel as y };
+export { clearPendingDiscussionOpen as A, truncateDiscussionDisplayTitle as C, getClickClackDiscussionBindingStore as D, bindingMatchesActiveSessionIncarnation as E, listPendingDiscussionOpens as M, recordPendingDiscussionOpen as N, readDiscussionSessionEntry as O, reserveDiscussionBindingGeneration as P, slugifyDiscussionLabel as S, attachBindingToCurrentActiveSession as T, discussionExternalRef as _, setClickClackRuntime as a, isDiscussionSessionKey as b, isClickClackDiscussionChannelRevokedAsync as c, prepareClickClackDiscussionChannelRevocation as d, discussionAccounts as f, discussionCredentialFingerprint as g, resolveDiscussionBindingAccount as h, getClickClackRuntime as i, getPendingDiscussionOpen as j, clearDiscussionBindingGeneration as k, markClickClackDiscussionChannelIdentityRevoked as l, normalizedServerBaseUrl as m, buildClickClackTarget as n, clearClickClackDiscussionChannelRevoked as o, discussionInfoForBinding as p, parseClickClackTarget as r, isClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, markClickClackDiscussionChannelRevoked as u, discussionSessionKey as v, MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS as w, resolveDiscussionLabel as x, fallbackDiscussionLabel as y };

package/dist/.setup/{runtime-api-hAV5Muz-.mjs → runtime-api-BrlvVAQJ.mjs}

@@ -1,7 +1,8 @@
-import { h as resolveClickClackAccount, p as listClickClackAccountIds } from "./setup-surface-BJ5D55LV.mjs";
-import { A as recordPendingDiscussionOpen, C as attachBindingToCurrentActiveSession, D as clearDiscussionBindingGeneration, E as readDiscussionSessionEntry, O as clearPendingDiscussionOpen, T as getClickClackDiscussionBindingStore, _ as fallbackDiscussionLabel, b as slugifyDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as discussionSessionKey, h as discussionExternalRef, j as reserveDiscussionBindingGeneration, k as listPendingDiscussionOpens, l as markClickClackDiscussionChannelRevoked, m as discussionCredentialFingerprint, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as isDiscussionSessionKey, w as bindingMatchesActiveSessionIncarnation, x as truncateDiscussionDisplayTitle, y as resolveDiscussionLabel } from "./channel-BFuhVeiX.mjs";
+import { h as resolveClickClackAccount, p as listClickClackAccountIds } from "./setup-surface-BJ3jioqA.mjs";
+import { A as clearPendingDiscussionOpen, C as truncateDiscussionDisplayTitle, D as getClickClackDiscussionBindingStore, E as bindingMatchesActiveSessionIncarnation, M as listPendingDiscussionOpens, N as recordPendingDiscussionOpen, O as readDiscussionSessionEntry, P as reserveDiscussionBindingGeneration, S as slugifyDiscussionLabel, T as attachBindingToCurrentActiveSession, _ as discussionExternalRef, b as isDiscussionSessionKey, c as isClickClackDiscussionChannelRevokedAsync, d as prepareClickClackDiscussionChannelRevocation, f as discussionAccounts, g as discussionCredentialFingerprint, h as resolveDiscussionBindingAccount, j as getPendingDiscussionOpen, k as clearDiscussionBindingGeneration, l as markClickClackDiscussionChannelIdentityRevoked, m as normalizedServerBaseUrl, o as clearClickClackDiscussionChannelRevoked, p as discussionInfoForBinding, s as isClickClackDiscussionChannelRevoked, u as markClickClackDiscussionChannelRevoked, v as discussionSessionKey, x as resolveDiscussionLabel, y as fallbackDiscussionLabel } from "./channel-DRcZ_twH.mjs";
 import { a as createClickClackClient, i as ClickClackHttpError, o as isClickClackChannelNameConflict, t as findClickClackWorkspace } from "./resolve-Br3ylpSz.mjs";
 import "../api.js";
+import { isDeepStrictEqual } from "node:util";
 import { randomUUID } from "node:crypto";
 import { createAsyncLock } from "openclaw/plugin-sdk/async-lock-runtime";
 import { buildControlUiSessionPath, registerSessionDiscussionProvider } from "openclaw/plugin-sdk/session-discussion";
@@ -19,47 +20,54 @@ var DetachedDiscussionBindingRetention = class {
 		this.#store = options.store;
 		this.#maxRetained = options.maxRetained;
 	}
-	mark(sessionKey, binding) {
-		const current = this.#store.get(sessionKey);
-		if (!current || !this.#sameRoom(current, binding)) return;
-		if (current.detachedAt === void 0) this.#store.set(sessionKey, {
+	async mark(sessionKey, binding) {
+		const current = await this.#store.getAsync(sessionKey);
+		if (!current || !isDeepStrictEqual(current, binding)) return;
+		if (current.detachedAt === void 0) await this.#store.setIfCurrent(sessionKey, current, {
 			...current,
 			detachedAt: Date.now()
-		});
-		while (this.#store.detachedCount() > this.#maxRetained) if (!this.#pruneOldest()) throw new Error("ClickClack detached discussion binding retention could not be reduced");
+		}, { assertCurrent: () => this.#assertDetached(sessionKey, current) });
+		while (this.#store.detachedCount() > this.#maxRetained) if (!await this.#pruneOldest()) throw new Error("ClickClack detached discussion binding retention could not be reduced");
 	}
-	clear(sessionKey, binding) {
-		const current = this.#store.get(sessionKey);
-		if (!current || !this.#sameRoom(current, binding)) return;
+	async clear(sessionKey, binding) {
+		const current = await this.#store.getAsync(sessionKey);
+		if (!current || !isDeepStrictEqual(current, binding)) return;
 		if (current.detachedAt === void 0) return current;
 		const { detachedAt: _detachedAt, ...retained } = current;
-		this.#store.set(sessionKey, retained);
-		return retained;
+		return await this.#store.setIfCurrent(sessionKey, current, retained, { assertCurrent: () => this.#assertRoomCurrent(sessionKey, current) }) ? retained : void 0;
 	}
 	async ensureCapacity(sessionKey) {
 		await this.#store.prepare();
-		while (!await this.#store.hasCapacity(sessionKey)) if (!this.#pruneOldest()) throw new Error("ClickClack discussion binding capacity is exhausted");
+		while (!await this.#store.hasCapacity(sessionKey)) if (!await this.#pruneOldest()) throw new Error("ClickClack discussion binding capacity is exhausted");
 	}
-	#pruneOldest() {
+	async #pruneOldest() {
 		for (;;) {
-			const oldest = this.#store.oldestDetached();
+			const oldest = await this.#store.oldestDetached();
 			if (!oldest) return false;
 			const current = oldest.binding;
-			if (this.#runtime.agent.session.getSessionEntry({
-				sessionKey: oldest.sessionKey,
-				readConsistency: "latest"
-			})) {
-				this.clear(oldest.sessionKey, current);
+			if (await readDiscussionSessionEntry(this.#runtime, oldest.sessionKey)) {
+				await this.clear(oldest.sessionKey, current);
 				continue;
 			}
-			markClickClackDiscussionChannelRevoked(this.#runtime, current);
-			this.#store.delete(oldest.sessionKey);
-			return true;
+			const authority = { assertCurrent: () => this.#assertDetached(oldest.sessionKey, current) };
+			if (!await markClickClackDiscussionChannelRevoked(this.#runtime, oldest.sessionKey, current, authority)) continue;
+			if (await this.#store.deleteIfCurrent(oldest.sessionKey, current, authority)) return true;
 		}
 	}
 	#sameRoom(left, right) {
 		return left.serverBaseUrl === right.serverBaseUrl && left.channelId === right.channelId && left.externalRef === right.externalRef;
 	}
+	#assertRoomCurrent(sessionKey, expected) {
+		const current = this.#store.get(sessionKey);
+		if (!current || !this.#sameRoom(current, expected)) throw new Error("ClickClack discussion binding changed before retention committed");
+	}
+	#assertDetached(sessionKey, expected) {
+		this.#assertRoomCurrent(sessionKey, expected);
+		if (this.#runtime.agent.session.getSessionEntry({
+			sessionKey,
+			readConsistency: "latest"
+		})) throw new Error("ClickClack discussion session returned before retention committed");
+	}
 };
 //#endregion
 //#region extensions/clickclack/src/discussions/control-session-url.ts
@@ -99,7 +107,7 @@ const INSTALLATION_NAMESPACE = "discussion-installation";
 const INSTALLATION_KEY = "current";
 /** Returns the durable installation namespace used in server-visible ownership refs. */
 async function getClickClackDiscussionInstallationId(runtime) {
-	const store = runtime.state.openKeyedStore({
+	const store = runtime.state.openKeyedStoreV2({
 		namespace: INSTALLATION_NAMESPACE,
 		maxEntries: 1,
 		overflowPolicy: "reject-new"
@@ -258,10 +266,10 @@ async function openClickClackDiscussionBinding(params) {
 		serverBaseUrl,
 		channelId
 	});
-	const unresolved = (await listPendingDiscussionOpens(runtime)).find((pending) => pending.sessionKey === sessionKey);
+	const unresolved = await getPendingDiscussionOpen(runtime, sessionKey);
 	if (unresolved && (unresolved.accountId !== account.accountId || unresolved.credentialFingerprint !== credentialFingerprint || unresolved.serverBaseUrl !== serverBaseUrl || unresolved.workspaceId !== workspace.id)) {
 		await params.reconcilePendingOpen(unresolved);
-		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");
+		if (await getPendingDiscussionOpen(runtime, 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({
@@ -346,14 +354,15 @@ async function openClickClackDiscussionBinding(params) {
 			assertCurrentAuthority();
 			try {
 				if (adopted) {
-					revokeChannel(adopted.id);
+					await revokeChannel(adopted.id);
+					assertCurrentAuthority();
 					resolved = await client.updateChannel(adopted.id, managedFields);
 				} else {
 					resolved = await client.createChannel(workspace.id, {
 						...managedFields,
 						kind: "public"
 					});
-					revokeChannel(resolved.id);
+					await revokeChannel(resolved.id);
 				}
 				break;
 			} catch (error) {
@@ -369,7 +378,7 @@ async function openClickClackDiscussionBinding(params) {
 					const recovered = relisted.find((candidate) => candidate.external_managed === true && candidate.external_ref === externalRef);
 					if (recovered) {
 						adopted = recovered;
-						revokeChannel(recovered.id);
+						await revokeChannel(recovered.id);
 						assertCurrentAuthority();
 						resolved = await client.updateChannel(recovered.id, managedFields);
 						break;
@@ -452,7 +461,13 @@ async function openClickClackDiscussionBinding(params) {
 		};
 		try {
 			nextBinding.sessionId = assertCurrentAuthority().sessionId;
-			store.set(sessionKey, nextBinding);
+			if (!await store.setIfCurrent(sessionKey, void 0, nextBinding, { assertCurrent: () => {
+				if (assertCurrentAuthority().sessionId !== nextBinding.sessionId) throw new Error("ClickClack discussion session changed before binding committed");
+			} })) {
+				await clearPendingDiscussionOpen(generationScope);
+				params.warn(`superseded discussion channel remains quarantined: ${channel.id}`);
+				return;
+			}
 		} catch (error) {
 			await clearPendingDiscussionOpen(generationScope);
 			params.warn(`unbound discussion channel remains quarantined: ${channel.id}`);
@@ -490,7 +505,7 @@ async function reconcilePendingDiscussionOpen(params) {
 	assertManagedChannelListContract(channels);
 	const channel = channels.find((candidate) => candidate.external_managed === true && candidate.external_ref === pending.externalRef);
 	if (channel) {
-		markClickClackDiscussionChannelIdentityRevoked({
+		await markClickClackDiscussionChannelIdentityRevoked({
 			runtime: params.runtime,
 			accountId: pending.accountId,
 			serverBaseUrl: pending.serverBaseUrl,
@@ -567,7 +582,7 @@ var ClickClackDiscussionService = class {
 		});
 		this.#unsubscribeSessionsChanged = gatewayEvents?.onSessionsChanged((event) => {
 			this.#withOperation(async () => {
-				if (await this.#store.getAsync(event.sessionKey) || (await listPendingDiscussionOpens(this.#runtime)).some((pending) => pending.sessionKey === event.sessionKey)) {
+				if (await this.#store.getAsync(event.sessionKey) || await getPendingDiscussionOpen(this.#runtime, event.sessionKey)) {
 					if (activation === this.#activation) this.#reconcileScheduler?.schedule(event.sessionKey);
 				}
 			}).catch((error) => {
@@ -593,7 +608,7 @@ var ClickClackDiscussionService = class {
 			if (existing) {
 				const resolved = await this.#resolveBindingForUse(existing);
 				if (resolved.state === "retargeted") {
-					this.#revokeAndDeleteBinding(sessionKey, existing);
+					await this.#revokeAndDeleteBinding(sessionKey, existing);
 					return { state: "available" };
 				}
 				if (resolved.state === "stale") {
@@ -601,7 +616,6 @@ var ClickClackDiscussionService = class {
 					return { state: "available" };
 				}
 				if (resolved.state !== "active") return { state: "none" };
-				await this.#finalizePendingBinding(sessionKey, existing);
 				await this.#reconcileBinding(sessionKey, existing, resolved.account);
 				const current = await this.#store.getAsync(sessionKey);
 				if (!current) return { state: this.hasEnabledAccount() ? "available" : "none" };
@@ -625,10 +639,11 @@ var ClickClackDiscussionService = class {
 		const existing = await this.#store.getAsync(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);
+			if (resolved.state === "retargeted") {
+				if (!await this.#revokeAndDeleteBinding(sessionKey, existing)) return { state: "available" };
+			} else if (resolved.state === "stale") {
+				if (!await this.#releaseStaleBinding(sessionKey, existing)) return { state: "available" };
+			} else if (resolved.state === "active") {
 				await this.#reconcileBinding(sessionKey, existing, resolved.account);
 				const current = await this.#store.getAsync(sessionKey);
 				if (current) return discussionInfoForBinding(current, resolved.account);
@@ -666,7 +681,7 @@ var ClickClackDiscussionService = class {
 				await this.#store.prepare();
 				const binding = await this.#store.getAsync(sessionKey);
 				if (binding) await this.#reconcileBinding(sessionKey, binding);
-				const pending = (await listPendingDiscussionOpens(this.#runtime)).find((candidate) => candidate.sessionKey === sessionKey);
+				const pending = await getPendingDiscussionOpen(this.#runtime, sessionKey);
 				if (pending) await this.#reconcilePendingOpen(pending);
 			});
 		} finally {
@@ -699,12 +714,13 @@ var ClickClackDiscussionService = class {
 			if (!binding) return { text: "No discussion is bound to this session." };
 			const resolved = await this.#resolveBindingForUse(binding);
 			if (resolved.state !== "active") return { text: "No discussion is bound to this session." };
-			const attached = this.#refreshSessionAttachment(sessionKey, binding);
+			const attached = await this.#refreshSessionAttachment(sessionKey, binding);
 			if (!attached) return { text: "No discussion is bound to this session." };
-			if (isClickClackDiscussionChannelRevoked({
+			if (!bindingMatchesActiveSessionIncarnation(this.#runtime, sessionKey, attached) || resolveDiscussionBindingAccount(this.#currentConfig(), attached).state !== "active" || isClickClackDiscussionChannelRevoked({
 				runtime: this.#runtime,
 				serverBaseUrl: binding.serverBaseUrl,
-				channelId: binding.channelId
+				channelId: binding.channelId,
+				binding: attached
 			})) return { text: "No discussion is bound to this session." };
 			return {
 				binding: attached,
@@ -724,27 +740,25 @@ var ClickClackDiscussionService = class {
 	}
 	async #reconcileBinding(sessionKey, binding, resolvedAccount) {
 		await this.#finalizePendingBinding(sessionKey, binding);
-		if (isClickClackDiscussionChannelRevoked({
+		if (await isClickClackDiscussionChannelRevokedAsync({
 			runtime: this.#runtime,
 			serverBaseUrl: binding.serverBaseUrl,
-			channelId: binding.channelId
+			channelId: binding.channelId,
+			binding
 		})) {
-			this.#store.delete(sessionKey);
+			await this.#store.deleteIfCurrent(sessionKey, binding);
 			return;
 		}
-		const entry = this.#runtime.agent.session.getSessionEntry({
-			sessionKey,
-			readConsistency: "latest"
-		});
+		const entry = await readDiscussionSessionEntry(this.#runtime, sessionKey);
 		if (!entry) {
-			this.#detachedBindings.mark(sessionKey, binding);
+			await this.#detachedBindings.mark(sessionKey, binding);
 			return;
 		}
-		const activeBinding = this.#detachedBindings.clear(sessionKey, binding);
+		const activeBinding = await this.#detachedBindings.clear(sessionKey, binding);
 		if (!activeBinding) return;
 		const resolved = resolvedAccount ? resolveDiscussionBindingAccount(this.#currentConfig(), activeBinding) : await this.#resolveBindingForUse(activeBinding);
 		if (resolved.state === "retargeted") {
-			this.#revokeAndDeleteBinding(sessionKey, activeBinding);
+			await this.#revokeAndDeleteBinding(sessionKey, activeBinding);
 			return;
 		}
 		if (resolved.state === "stale") {
@@ -760,14 +774,15 @@ var ClickClackDiscussionService = class {
 		let observedSiblingTitleSupport = false;
 		if (labelForBackfill === activeBinding.label && desiredBackfillTitle !== "" && activeBinding.displayTitle === void 0) {
 			const bindings = await this.#store.entries();
-			const freshBinding = this.#store.get(sessionKey);
+			const freshBinding = await this.#store.getAsync(sessionKey);
 			if (!freshBinding || freshBinding.serverBaseUrl !== activeBinding.serverBaseUrl || freshBinding.channelId !== activeBinding.channelId || freshBinding.externalRef !== activeBinding.externalRef) return;
-			if (isClickClackDiscussionChannelRevoked({
+			if (await isClickClackDiscussionChannelRevokedAsync({
 				runtime: this.#runtime,
 				serverBaseUrl: freshBinding.serverBaseUrl,
-				channelId: freshBinding.channelId
+				channelId: freshBinding.channelId,
+				binding: freshBinding
 			})) {
-				this.#store.delete(sessionKey);
+				await this.#store.deleteIfCurrent(sessionKey, freshBinding);
 				return;
 			}
 			bindingForAttachment = freshBinding;
@@ -776,8 +791,8 @@ var ClickClackDiscussionService = class {
 		const current = resolveDiscussionBindingAccount(this.#currentConfig(), bindingForAttachment);
 		if (current.state !== "active") return;
 		const account = current.account;
-		const attached = this.#refreshSessionAttachment(sessionKey, bindingForAttachment);
-		if (!attached) return;
+		const attached = await this.#refreshSessionAttachment(sessionKey, bindingForAttachment);
+		if (!attached || attached.sessionId !== entry.sessionId) return;
 		const currentBinding = attached;
 		const fallback = fallbackDiscussionLabel(sessionKey, currentBinding.agentId);
 		const label = resolveDiscussionLabel(entry, sessionKey, currentBinding.agentId);
@@ -793,6 +808,15 @@ var ClickClackDiscussionService = class {
 		if (externalUrl !== currentBinding.externalUrl) patch.external_url = externalUrl;
 		if (Object.keys(patch).length === 0 && !labelChanged) return;
 		const client = this.#clientFactory(account);
+		const assertCurrentAuthority = () => {
+			const bound = this.#store.get(sessionKey);
+			if (!bound || bound.externalRef !== currentBinding.externalRef || bound.serverBaseUrl !== currentBinding.serverBaseUrl || bound.channelId !== currentBinding.channelId || !bindingMatchesActiveSessionIncarnation(this.#runtime, sessionKey, currentBinding) || resolveDiscussionBindingAccount(this.#currentConfig(), currentBinding).state !== "active" || isClickClackDiscussionChannelRevoked({
+				runtime: this.#runtime,
+				serverBaseUrl: currentBinding.serverBaseUrl,
+				channelId: currentBinding.channelId,
+				binding: bound
+			})) throw new Error("ClickClack discussion authority changed before channel update");
+		};
 		let updated;
 		if (labelChanged) updated = await this.#withChannelMutationLock(() => renameDiscussionChannel({
 			client,
@@ -801,27 +825,27 @@ var ClickClackDiscussionService = class {
 			label,
 			sessionKey,
 			agentId: currentBinding.agentId,
-			patch
+			patch,
+			assertCurrentAuthority
 		}));
 		else {
+			assertCurrentAuthority();
 			updated = await client.updateChannel(currentBinding.channelId, patch);
 			assertChannelPatch(updated, patch);
 		}
-		const latestBinding = this.#store.get(sessionKey);
-		if (!latestBinding || latestBinding.serverBaseUrl !== currentBinding.serverBaseUrl || latestBinding.channelId !== currentBinding.channelId || latestBinding.externalRef !== currentBinding.externalRef) return;
 		const nextBinding = {
-			...latestBinding,
+			...currentBinding,
 			externalUrl,
 			label,
 			section,
 			...updated.display_title !== void 0 ? { displayTitle: updated.display_title } : {}
 		};
 		if (updated.display_title === void 0) delete nextBinding.displayTitle;
-		this.#store.set(sessionKey, nextBinding);
+		await this.#store.setIfCurrent(sessionKey, currentBinding, nextBinding, { assertCurrent: assertCurrentAuthority });
 	}
-	#refreshSessionAttachment(sessionKey, binding) {
+	async #refreshSessionAttachment(sessionKey, binding) {
 		try {
-			return attachBindingToCurrentActiveSession({
+			return await attachBindingToCurrentActiveSession({
 				runtime: this.#runtime,
 				store: this.#store,
 				sessionKey,
@@ -844,20 +868,22 @@ var ClickClackDiscussionService = class {
 		});
 	}
 	async #releaseStaleBinding(sessionKey, binding) {
-		await clearDiscussionBindingGeneration({
+		const pending = await getPendingDiscussionOpen(this.#runtime, sessionKey);
+		if (pending?.externalRef === binding.externalRef) await clearDiscussionBindingGeneration({
 			runtime: this.#runtime,
-			sessionKey
+			sessionKey,
+			expectedGeneration: pending.generation
 		});
-		this.#revokeAndDeleteBinding(sessionKey, binding);
+		return await this.#revokeAndDeleteBinding(sessionKey, binding);
 	}
-	#revokeAndDeleteBinding(sessionKey, binding) {
-		markClickClackDiscussionChannelRevoked(this.#runtime, binding);
-		this.#store.delete(sessionKey);
+	async #revokeAndDeleteBinding(sessionKey, binding) {
+		if (!await markClickClackDiscussionChannelRevoked(this.#runtime, sessionKey, binding)) return false;
+		return await this.#store.deleteIfCurrent(sessionKey, binding);
 	}
 	async #finalizePendingBinding(sessionKey, binding) {
-		const pending = (await listPendingDiscussionOpens(this.#runtime)).find((candidate) => candidate.sessionKey === sessionKey && candidate.externalRef === binding.externalRef);
-		if (pending) {
-			clearClickClackDiscussionChannelRevoked({
+		const pending = await getPendingDiscussionOpen(this.#runtime, sessionKey);
+		if (pending?.externalRef === binding.externalRef) {
+			await clearClickClackDiscussionChannelRevoked({
 				runtime: this.#runtime,
 				serverBaseUrl: binding.serverBaseUrl,
 				channelId: binding.channelId
@@ -937,25 +963,52 @@ function isClickClackDiscussionSessionTarget(params) {
 	const { runtime, targetSessionKey } = params;
 	let binding;
 	try {
-		binding = getClickClackDiscussionBindingStore(runtime).get(targetSessionKey);
+		const store = getClickClackDiscussionBindingStore(runtime);
+		store.assertReadAvailable();
+		binding = store.get(targetSessionKey);
 	} catch {
 		return;
 	}
+	return currentDiscussionTarget(params, binding, (current) => isClickClackDiscussionChannelRevoked({
+		runtime,
+		serverBaseUrl: current.serverBaseUrl,
+		channelId: current.channelId,
+		binding: current
+	}));
+}
+function currentDiscussionTarget(params, binding, isRevoked) {
+	const { runtime, targetSessionKey } = params;
 	if (binding && discussionSessionKey({
 		runtime,
 		mainSessionKey: targetSessionKey,
 		...binding
-	}) === params.requesterSessionKey && !isClickClackDiscussionChannelRevoked({
-		runtime,
-		serverBaseUrl: binding.serverBaseUrl,
-		channelId: binding.channelId
-	}) && bindingMatchesActiveSessionIncarnation(runtime, targetSessionKey, binding) && resolveDiscussionBindingAccount(runtime.config.current(), binding).state === "active") return {
+	}) === params.requesterSessionKey && !isRevoked(binding) && bindingMatchesActiveSessionIncarnation(runtime, targetSessionKey, binding) && resolveDiscussionBindingAccount(runtime.config.current(), binding).state === "active") return {
 		sessionKey: targetSessionKey,
 		binding
 	};
 }
+async function resolveClickClackDiscussionSessionTarget(params) {
+	if (!isDiscussionSessionKey(params.requesterSessionKey)) return;
+	let facts;
+	let revocation;
+	try {
+		facts = await getClickClackDiscussionBindingStore(params.runtime).prepareRead(params.targetSessionKey);
+		const binding = facts.read();
+		if (!binding) return;
+		revocation = await prepareClickClackDiscussionChannelRevocation({
+			runtime: params.runtime,
+			...binding
+		});
+		return currentDiscussionTarget(params, facts.read(), revocation.isRevoked);
+	} catch {
+		return;
+	} finally {
+		revocation?.release();
+		facts?.release();
+	}
+}
 /** Restricts a discussion side session's session tools to its attached main session. */
-function enforceClickClackDiscussionToolTarget(params) {
+async function enforceClickClackDiscussionToolTarget(params) {
 	const callerSessionKey = params.context.sessionKey;
 	if (!callerSessionKey || !isDiscussionSessionKey(callerSessionKey)) return;
 	const { toolName } = params.event;
@@ -964,7 +1017,7 @@ function enforceClickClackDiscussionToolTarget(params) {
 	const mutatesStatus = toolName === "session_status" && params.event.params.model !== void 0;
 	const selectsHistoryIncarnation = toolName === "sessions_history" && params.event.params.sessionId !== void 0;
 	const targetSessionKey = params.event.params.sessionKey;
-	if (TARGETED_SESSION_TOOLS.has(toolName) && typeof targetSessionKey === "string" && !usesAlternateSendTarget && !mutatesStatus && !selectsHistoryIncarnation && isClickClackDiscussionSessionTarget({
+	if (TARGETED_SESSION_TOOLS.has(toolName) && typeof targetSessionKey === "string" && !usesAlternateSendTarget && !mutatesStatus && !selectsHistoryIncarnation && await resolveClickClackDiscussionSessionTarget({
 		runtime: params.runtime,
 		requesterSessionKey: callerSessionKey,
 		targetSessionKey
@@ -1033,7 +1086,14 @@ function registerClickClackDiscussions(api) {
 			targetSessionKey
 		});
 		return target ? { expectedSessionId: target.binding.sessionId } : void 0;
-	});
+	}, { async resolveAsync({ requesterSessionKey, targetSessionKey }) {
+		const target = await resolveClickClackDiscussionSessionTarget({
+			runtime: api.runtime,
+			requesterSessionKey,
+			targetSessionKey
+		});
+		return target ? { expectedSessionId: target.binding.sessionId } : void 0;
+	} });
 	registerSessionDiscussionProvider(service.provider);
 	api.lifecycle.registerRuntimeLifecycle({
 		id: "clickclack-discussions",

package/dist/.setup/secret-contract-api--45pFCg3.mjs

@@ -0,0 +1,2 @@
+export { t as channelSecrets, n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-CF7TKtkU.mjs";
+import "../secret-contract-api.js";

package/dist/.setup/{setup-claim-C-9Pvumz.mjs → setup-claim-BPuQuMKW.mjs}

@@ -1,4 +1,4 @@
-import { a as isClickClackSetupLoopbackHost, i as buildClickClackSetupClaimUrl, o as requireClickClackSetupApiBaseUrl } from "./setup-surface-BJ5D55LV.mjs";
+import { a as isClickClackSetupLoopbackHost, i as buildClickClackSetupClaimUrl, o as requireClickClackSetupApiBaseUrl } from "./setup-surface-BJ3jioqA.mjs";
 import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createProviderOperationDeadline, readProviderJsonResponse, readResponseTextLimited, resolveProviderOperationTimeoutMs } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithSsrFGuard, resolvePinnedHostnameWithPolicy, ssrfPolicyFromHttpBaseUrlAllowedHostname } from "openclaw/plugin-sdk/ssrf-runtime";

package/dist/.setup/setup-plugin-api-0RMVREuM.mjs

@@ -0,0 +1 @@
+export { t as clickClackSetupPlugin } from "./setup-plugin-api-Ccxm2ydn.mjs";

package/dist/.setup/{setup-plugin-api-Qi8u_lra.mjs → setup-plugin-api-Ccxm2ydn.mjs}

@@ -1,4 +1,4 @@
-import { l as clickClackConfigAdapter, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BJ5D55LV.mjs";
+import { l as clickClackConfigAdapter, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BJ3jioqA.mjs";
 //#region extensions/clickclack/src/channel.setup.ts
 const clickClackSetupPlugin = {
 	id: "clickclack",

package/dist/.setup/{setup-surface-BJ5D55LV.mjs → setup-surface-BJ3jioqA.mjs}

@@ -195,7 +195,7 @@ function resolveClickClackAccount(params) {
 		mentionPatterns: merged.mentionPatterns ?? [],
 		allowBots: merged.allowBots ?? false,
 		botLoopProtection: merged.botLoopProtection,
-		groups: mergeClickClackGroups(merged.groups),
+		groups: merged.groups ?? {},
 		config: {
 			...merged,
 			allowFrom: merged.allowFrom ?? ["*"]
@@ -322,7 +322,7 @@ function requireClickClackSetupApiBaseUrl(value, label) {
 		basePath = pathname;
 	}
 	const canonical = parsed.origin + basePath;
-	if (value !== canonical) throw new Error(`ClickClack ${label} is not canonical`);
+	if (value !== canonical) throw new Error(`ClickClack ${label} is not in the expected URL format`);
 	return canonical;
 }
 function requireClickClackSetupClaimUrl(value) {
@@ -331,7 +331,7 @@ function requireClickClackSetupClaimUrl(value) {
 	const basePath = parsed.pathname.slice(0, -26);
 	const apiBaseUrl = requireClickClackSetupApiBaseUrl(parsed.origin + basePath, "setup URL API base");
 	const claimUrl = apiBaseUrl + CLICKCLACK_SETUP_CODE_CLAIM_PATH;
-	if (value !== claimUrl) throw new Error("ClickClack setup URL has a non-canonical claim endpoint.");
+	if (value !== claimUrl) throw new Error("ClickClack setup URL has a claim endpoint in an unexpected URL format.");
 	return {
 		claimUrl,
 		apiBaseUrl
@@ -450,7 +450,7 @@ const clickClackSetupAdapter = {
 		const claimUrl = setup.exactClaimUrl && !privateApiBaseUrl ? setup.exactClaimUrl : buildClickClackSetupClaimUrl(privateApiBaseUrl ?? setup.baseUrl);
 		let claim;
 		try {
-			const { claimClickClackSetupCode } = await import("./setup-claim-C-9Pvumz.mjs");
+			const { claimClickClackSetupCode } = await import("./setup-claim-BPuQuMKW.mjs");
 			claim = await claimClickClackSetupCode({
 				claimUrl,
 				code: setup.code,
@@ -530,7 +530,7 @@ const clickClackSetupAdapter = {
 		});
 	},
 	afterAccountConfigWritten: async ({ cfg, accountId, runtime }) => {
-		const { verifyClickClackAccountAfterSetup } = await import("./setup-verify-2ruJKFPj.mjs");
+		const { verifyClickClackAccountAfterSetup } = await import("./setup-verify-DGsYtVh9.mjs");
 		await verifyClickClackAccountAfterSetup({
 			cfg,
 			accountId,
@@ -712,7 +712,7 @@ const clickClackSetupWizard = {
 		})
 	}],
 	finalize: async ({ cfg, accountId, credentialValues, prompter }) => {
-		const { checkClickClackSetupConnection } = await import("./setup-verify-2ruJKFPj.mjs");
+		const { checkClickClackSetupConnection } = await import("./setup-verify-DGsYtVh9.mjs");
 		const result = await checkClickClackSetupConnection({
 			cfg,
 			accountId,

package/dist/.setup/{setup-verify-2ruJKFPj.mjs → setup-verify-DGsYtVh9.mjs}

@@ -1,5 +1,5 @@
-import { h as resolveClickClackAccount } from "./setup-surface-BJ5D55LV.mjs";
-import { a as createClickClackClient, r as resolveWorkspaceId } from "./resolve-Br3ylpSz.mjs";
+import { h as resolveClickClackAccount } from "./setup-surface-BJ3jioqA.mjs";
+import { a as createClickClackClient, t as findClickClackWorkspace } from "./resolve-Br3ylpSz.mjs";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/setup";
@@ -32,8 +32,8 @@ async function checkClickClackSetupConnection(params) {
 			token
 		});
 		const me = await client.me();
-		const workspaceId = await resolveWorkspaceId(client, account.workspace);
-		const workspace = (await client.workspaces()).find((candidate) => candidate.id === workspaceId);
+		const workspaces = await client.workspaces();
+		const workspace = account.workspace.startsWith("wsp_") ? workspaces.find((candidate) => candidate.id === account.workspace) : findClickClackWorkspace(workspaces, account.workspace);
 		if (!workspace) throw new Error(`ClickClack workspace not found: ${account.workspace}`);
 		return {
 			status: "connected",
@@ -83,20 +83,12 @@ function formatClickClackConnectionLog(result) {
 	}
 }
 async function verifyClickClackAccountAfterSetup(params) {
-	try {
-		const message = formatClickClackConnectionLog(await checkClickClackSetupConnection({
-			cfg: params.cfg,
-			accountId: params.accountId
-		}));
-		if (message) params.runtime.log(message);
-	} catch (error) {
-		params.runtime.log(`Connection check failed: ${formatErrorMessage(error)}. Setup was saved; fix the connection and rerun setup.`);
-	}
-	try {
-		params.runtime.log(await probeClickClackGatewayStatus());
-	} catch {
-		params.runtime.log(GATEWAY_UNKNOWN_MESSAGE);
-	}
+	const message = formatClickClackConnectionLog(await checkClickClackSetupConnection({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}));
+	if (message) params.runtime.log(message);
+	params.runtime.log(await probeClickClackGatewayStatus());
 }
 //#endregion
 export { checkClickClackSetupConnection, verifyClickClackAccountAfterSetup };

package/dist/api.js

@@ -1,4 +1,4 @@
-import { _ as resolveDefaultClickClackAccountId, d as DEFAULT_ACCOUNT_ID, h as resolveClickClackAccount, m as listEnabledClickClackAccounts, p as listClickClackAccountIds, s as clickClackConfigSchema } from "./.setup/setup-surface-BJ5D55LV.mjs";
-import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-BFuhVeiX.mjs";
+import { _ as resolveDefaultClickClackAccountId, d as DEFAULT_ACCOUNT_ID, h as resolveClickClackAccount, m as listEnabledClickClackAccounts, p as listClickClackAccountIds, s as clickClackConfigSchema } from "./.setup/setup-surface-BJ3jioqA.mjs";
+import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-DRcZ_twH.mjs";
 import { a as createClickClackClient } from "./.setup/resolve-Br3ylpSz.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 @@
-import { t as clickClackPlugin } from "./.setup/channel-BFuhVeiX.mjs";
-export { clickClackPlugin };
+export { t as clickClackPlugin } from "./.setup/channel-DRcZ_twH.mjs";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-hAV5Muz-.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-BrlvVAQJ.mjs";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/clickclack/index.ts
 var clickclack_default = defineBundledChannelEntry({

package/dist/runtime-api.js

@@ -1,5 +1,5 @@
-import { h as resolveClickClackAccount } from "./.setup/setup-surface-BJ5D55LV.mjs";
-import { a as setClickClackRuntime, r as parseClickClackTarget } from "./.setup/channel-BFuhVeiX.mjs";
+import { h as resolveClickClackAccount } from "./.setup/setup-surface-BJ3jioqA.mjs";
+import { a as setClickClackRuntime, r as parseClickClackTarget } from "./.setup/channel-DRcZ_twH.mjs";
 import { a as createClickClackClient } from "./.setup/resolve-Br3ylpSz.mjs";
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-hAV5Muz-.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-BrlvVAQJ.mjs";
 export { createClickClackClient, parseClickClackTarget, registerClickClackDiscussions, resolveClickClackAccount, setClickClackRuntime };

package/dist/secret-contract-api.js

@@ -1,2 +1 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./.setup/secret-contract-CF7TKtkU.mjs";
-export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };
+export { t as channelSecrets, n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./.setup/secret-contract-CF7TKtkU.mjs";

package/dist/setup-entry.js

@@ -4,11 +4,11 @@ import { fileURLToPath } from "node:url";
 var setup_entry_default = defineBundledChannelSetupEntry({
 	importMetaUrl: import.meta.url,
 	plugin: {
-		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-DpKXmzV1.mjs", import.meta.url).href),
+		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-0RMVREuM.mjs", import.meta.url).href),
 		exportName: "clickClackSetupPlugin"
 	},
 	secrets: {
-		specifier: fileURLToPath(new URL(".setup/secret-contract-api-CBcsgIYZ.mjs", import.meta.url).href),
+		specifier: fileURLToPath(new URL(".setup/secret-contract-api--45pFCg3.mjs", import.meta.url).href),
 		exportName: "channelSecrets"
 	}
 });

package/dist/setup-plugin-api.js

@@ -1,2 +1 @@
-import { t as clickClackSetupPlugin } from "./.setup/setup-plugin-api-Qi8u_lra.mjs";
-export { clickClackSetupPlugin };
+export { t as clickClackSetupPlugin } from "./.setup/setup-plugin-api-Ccxm2ydn.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/clickclack",
-  "version": "2026.10.5-beta.4",
+  "version": "2026.10.10-beta.2",
   "description": "OpenClaw ClickClack channel plugin",
   "type": "module",
   "exports": {
@@ -13,7 +13,7 @@
     "zod": "4.6.5"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.10.5-beta.4"
+    "openclaw": ">=2026.10.10-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -139,10 +139,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.10.5-beta.4"
+      "pluginApi": ">=2026.10.10-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.10.5-beta.4",
+      "openclawVersion": "2026.10.10-beta.2",
       "bundledDist": false
     },
     "release": {

package/dist/.setup/secret-contract-api-CBcsgIYZ.mjs

@@ -1,3 +0,0 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-CF7TKtkU.mjs";
-import "../secret-contract-api.js";
-export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/.setup/setup-plugin-api-DpKXmzV1.mjs

@@ -1,2 +0,0 @@
-import { t as clickClackSetupPlugin } from "./setup-plugin-api-Qi8u_lra.mjs";
-export { clickClackSetupPlugin };