@openclaw/clickclack 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/runtime-api-CV1cOqFO.js

@@ -0,0 +1,782 @@
+import { d as createClickClackClient, f as isClickClackChannelNameConflict, u as ClickClackHttpError, x as resolveClickClackAccount, y as listClickClackAccountIds } from "./setup-surface-Baf26N-D.js";
+import { C as reserveDiscussionBindingGeneration, S as recordPendingDiscussionOpen, _ as isDiscussionSessionKey, a as isClickClackDiscussionChannelRevoked, b as clearDiscussionBindingGeneration, c as discussionAccounts, d as bindingMatchesActiveSessionIncarnation, f as bindingMatchesSessionIncarnation, g as fallbackDiscussionLabel, h as discussionExternalRef, i as clearClickClackDiscussionChannelRevoked, l as normalizedServerBaseUrl, m as discussionCredentialFingerprint, o as markClickClackDiscussionChannelIdentityRevoked, p as getClickClackDiscussionBindingStore, s as markClickClackDiscussionChannelRevoked, u as resolveDiscussionBindingAccount, v as resolveDiscussionLabel, x as listPendingDiscussionOpens, y as slugifyDiscussionLabel } from "./channel-BDq0KWDB.js";
+import "./api.js";
+import { resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { randomUUID } from "node:crypto";
+import { registerSessionDiscussionProvider } from "openclaw/plugin-sdk/session-discussion";
+import { createSessionVisibilityChecker } from "openclaw/plugin-sdk/session-visibility";
+import { textResult } from "openclaw/plugin-sdk/tool-results";
+//#region extensions/clickclack/src/discussions/installation.ts
+const INSTALLATION_NAMESPACE = "discussion-installation";
+const INSTALLATION_KEY = "current";
+/** Returns the durable installation namespace used in server-visible ownership refs. */
+function getClickClackDiscussionInstallationId(runtime) {
+	const store = runtime.state.openSyncKeyedStore({
+		namespace: INSTALLATION_NAMESPACE,
+		maxEntries: 1,
+		overflowPolicy: "reject-new"
+	});
+	const existing = store.lookup(INSTALLATION_KEY)?.id;
+	if (existing) return existing;
+	const id = randomUUID();
+	store.registerIfAbsent(INSTALLATION_KEY, { id });
+	return store.lookup(INSTALLATION_KEY)?.id ?? id;
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/service-open.ts
+const CHANNEL_NAME_MUTATION_ATTEMPTS$1 = 4;
+function isDefinitiveNoCreateHttpError(error) {
+	if (!(error instanceof ClickClackHttpError) || error.status < 400 || error.status >= 500) return false;
+	return ![
+		408,
+		409,
+		425,
+		429
+	].includes(error.status);
+}
+function controlSessionUrl(baseUrl, sessionKey) {
+	if (!baseUrl) return;
+	const url = new URL(baseUrl);
+	url.pathname = `${url.pathname.replace(/\/+$/u, "")}/chat`;
+	url.hash = "";
+	url.searchParams.set("session", sessionKey);
+	return url.toString();
+}
+async function resolveAvailableChannelName(params) {
+	const desired = slugifyDiscussionLabel(params.label, params.sessionKey);
+	const channels = params.channels ?? await params.client.channels(params.workspaceId);
+	const occupied = new Set(channels.filter((channel) => channel.id !== params.ownChannelId).map((channel) => channel.name));
+	if (!occupied.has(desired)) return desired;
+	const fallback = fallbackDiscussionLabel(params.sessionKey);
+	if (!occupied.has(fallback)) return fallback;
+	for (let suffix = 2;; suffix += 1) {
+		const candidate = `${fallback}-${suffix}`;
+		if (!occupied.has(candidate)) return candidate;
+	}
+}
+function assertChannelPatch(channel, patch) {
+	for (const key of [
+		"archived",
+		"external_managed",
+		"external_ref",
+		"external_url",
+		"name",
+		"sidebar_section"
+	]) {
+		const expected = patch[key];
+		if (expected === void 0) continue;
+		if ((key === "external_ref" || key === "external_url" || key === "sidebar_section" ? channel[key] ?? "" : channel[key]) !== expected) throw new Error(`ClickClack channel update did not apply ${key}`);
+	}
+}
+function assertManagedChannelContract(channel, expected) {
+	if (channel.external_managed !== true || (channel.external_ref ?? "") !== (expected.externalRef ?? "") || (channel.sidebar_section ?? "") !== (expected.section ?? "") || (channel.external_url ?? "") !== (expected.externalUrl ?? "")) throw new Error(`ClickClack server does not support the managed discussion channel contract for ${expected.sessionKey}`);
+}
+function assertManagedChannelListContract(channels) {
+	if (channels.some((channel) => typeof channel.external_managed !== "boolean" || channel.external_ref !== void 0 && typeof channel.external_ref !== "string" || channel.external_url !== void 0 && typeof channel.external_url !== "string" || channel.sidebar_section !== void 0 && typeof channel.sidebar_section !== "string")) throw new Error("ClickClack server does not advertise the managed discussion contract");
+}
+async function openClickClackDiscussionBinding(params) {
+	const { account, runtime, sessionKey, store } = params;
+	const entry = runtime.agent.session.getSessionEntry({
+		sessionKey,
+		readConsistency: "latest"
+	});
+	if (!entry) return;
+	if (!entry.sessionId?.trim()) throw new Error("OpenClaw session does not yet have a concrete session id");
+	const client = params.clientFactory(account);
+	const workspace = (await client.workspaces()).find((candidate) => candidate.id === account.discussions.workspace || candidate.slug === account.discussions.workspace || candidate.name === account.discussions.workspace);
+	if (!workspace) throw new Error(`ClickClack discussions workspace not found: ${account.discussions.workspace}`);
+	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);
+	if (unresolved && (unresolved.accountId !== account.accountId || unresolved.credentialFingerprint !== credentialFingerprint || unresolved.sessionId !== entry.sessionId || 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");
+	}
+	const label = resolveDiscussionLabel(entry.label, sessionKey);
+	const section = entry.category?.trim() || account.discussions.section;
+	const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey);
+	const archived = entry.archivedAt !== void 0;
+	return await params.withChannelMutationLock(async () => {
+		if (!store.hasCapacity(sessionKey)) throw new Error("ClickClack discussion binding capacity is exhausted");
+		let channels = await client.channels(workspace.id);
+		assertManagedChannelListContract(channels);
+		const destinationIdentity = [serverBaseUrl, workspace.id].join("\0");
+		const bindingGeneration = reserveDiscussionBindingGeneration({
+			runtime,
+			sessionKey,
+			destinationIdentity,
+			createGeneration: params.bindingGenerationFactory
+		});
+		const externalRef = discussionExternalRef(params.installationId, sessionKey, entry.sessionId, destinationIdentity, bindingGeneration);
+		let adopted;
+		let managedFields;
+		let resolved;
+		for (let attempt = 0; attempt < CHANNEL_NAME_MUTATION_ATTEMPTS$1; attempt += 1) {
+			adopted = channels.find((candidate) => candidate.external_managed === true && candidate.external_ref === externalRef);
+			managedFields = {
+				name: await resolveAvailableChannelName({
+					client,
+					workspaceId: workspace.id,
+					label,
+					sessionKey,
+					channels,
+					ownChannelId: adopted?.id
+				}),
+				external_managed: true,
+				external_ref: externalRef,
+				external_url: externalUrl ?? "",
+				sidebar_section: section
+			};
+			recordPendingDiscussionOpen({
+				runtime,
+				sessionKey,
+				generation: bindingGeneration,
+				pending: {
+					accountId: account.accountId,
+					serverBaseUrl,
+					workspaceId: workspace.id,
+					sessionId: entry.sessionId,
+					externalRef,
+					credentialFingerprint
+				}
+			});
+			params.ensureTimer();
+			try {
+				if (adopted) {
+					markClickClackDiscussionChannelIdentityRevoked({
+						runtime,
+						accountId: account.accountId,
+						serverBaseUrl,
+						channelId: adopted.id
+					});
+					resolved = await client.updateChannel(adopted.id, {
+						...managedFields,
+						archived
+					});
+				} else {
+					resolved = await client.createChannel(workspace.id, {
+						...managedFields,
+						kind: "public"
+					});
+					markClickClackDiscussionChannelIdentityRevoked({
+						runtime,
+						accountId: account.accountId,
+						serverBaseUrl,
+						channelId: resolved.id
+					});
+				}
+				break;
+			} catch (error) {
+				if (isClickClackChannelNameConflict(error) && attempt < CHANNEL_NAME_MUTATION_ATTEMPTS$1 - 1) {
+					channels = await client.channels(workspace.id);
+					assertManagedChannelListContract(channels);
+					continue;
+				}
+				const definitiveNoCreate = isDefinitiveNoCreateHttpError(error);
+				try {
+					const relisted = await client.channels(workspace.id);
+					assertManagedChannelListContract(relisted);
+					const recovered = relisted.find((candidate) => candidate.external_managed === true && candidate.external_ref === externalRef);
+					if (recovered) {
+						adopted = recovered;
+						markClickClackDiscussionChannelIdentityRevoked({
+							runtime,
+							accountId: account.accountId,
+							serverBaseUrl,
+							channelId: recovered.id
+						});
+						resolved = await client.updateChannel(recovered.id, {
+							...managedFields,
+							archived
+						});
+						break;
+					}
+					if (definitiveNoCreate) clearDiscussionBindingGeneration({
+						runtime,
+						sessionKey,
+						expectedGeneration: bindingGeneration
+					});
+				} catch {
+					if (definitiveNoCreate && !adopted) clearDiscussionBindingGeneration({
+						runtime,
+						sessionKey,
+						expectedGeneration: bindingGeneration
+					});
+				}
+				throw error;
+			}
+		}
+		if (!resolved || !managedFields) throw new Error("ClickClack discussion channel name retries were exhausted");
+		try {
+			assertManagedChannelContract(resolved, {
+				sessionKey,
+				externalRef,
+				section,
+				externalUrl
+			});
+			if (adopted) assertChannelPatch(resolved, {
+				...managedFields,
+				archived
+			});
+		} catch (error) {
+			try {
+				assertChannelPatch(await client.updateChannel(resolved.id, { archived: true }), { archived: true });
+				clearDiscussionBindingGeneration({
+					runtime,
+					sessionKey,
+					expectedGeneration: bindingGeneration
+				});
+			} catch (archiveError) {
+				params.warn(`failed to archive incompatible discussion channel ${resolved.id}: ${String(archiveError)}`);
+			}
+			throw error;
+		}
+		if (!resolved.route_id) {
+			try {
+				assertChannelPatch(await client.updateChannel(resolved.id, { archived: true }), { archived: true });
+				clearDiscussionBindingGeneration({
+					runtime,
+					sessionKey,
+					expectedGeneration: bindingGeneration
+				});
+			} catch (archiveError) {
+				params.warn(`failed to archive route-less discussion channel ${resolved.id}: ${String(archiveError)}`);
+			}
+			throw new Error("ClickClack discussion channel is missing its route id");
+		}
+		let channel = resolved;
+		if (!adopted && archived) {
+			channel = await client.updateChannel(resolved.id, { archived: true });
+			assertChannelPatch(channel, { archived: true });
+		}
+		const nextBinding = {
+			accountId: account.accountId,
+			agentId: resolveAgentIdFromSessionKey(sessionKey),
+			sessionId: entry.sessionId,
+			serverBaseUrl,
+			credentialFingerprint,
+			externalRef,
+			externalUrl: externalUrl ?? "",
+			workspaceRef: account.discussions.workspace,
+			workspaceId: workspace.id,
+			channelId: channel.id,
+			channelRouteId: channel.route_id,
+			workspaceRouteId: workspace.route_id,
+			section,
+			archived,
+			label
+		};
+		const currentEntry = runtime.agent.session.getSessionEntry({
+			sessionKey,
+			readConsistency: "latest"
+		});
+		if (!currentEntry || currentEntry.sessionId !== entry.sessionId) {
+			try {
+				assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
+				clearDiscussionBindingGeneration({
+					runtime,
+					sessionKey,
+					expectedGeneration: bindingGeneration
+				});
+			} catch (archiveError) {
+				params.warn(`failed to archive superseded discussion channel ${channel.id}: ${String(archiveError)}`);
+			}
+			throw new Error("OpenClaw session changed while opening its ClickClack discussion");
+		}
+		try {
+			store.set(sessionKey, nextBinding);
+		} catch (error) {
+			try {
+				assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
+				clearDiscussionBindingGeneration({
+					runtime,
+					sessionKey,
+					expectedGeneration: bindingGeneration
+				});
+			} catch (archiveError) {
+				params.warn(`failed to archive unbound discussion channel ${channel.id}: ${String(archiveError)}`);
+			}
+			throw error;
+		}
+		params.finalizePendingBinding(sessionKey, nextBinding);
+		return nextBinding;
+	});
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/service.ts
+const RECONCILE_INTERVAL_MS = 6e4;
+const CHANNEL_NAME_MUTATION_ATTEMPTS = 4;
+function discussionInfoForBinding(binding, account) {
+	const baseUrl = normalizedServerBaseUrl(account);
+	return {
+		state: "open",
+		embedUrl: `${baseUrl}/embed/channel/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}`,
+		openUrl: `${baseUrl}/app/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}`
+	};
+}
+function discussionRecordJson(value) {
+	return JSON.stringify(value).replace(/[\u0085\u2028\u2029]/gu, (separator) => `\\u${separator.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+var ClickClackDiscussionService = class {
+	#runtime;
+	#store;
+	#clientFactory;
+	#installationId;
+	#bindingGenerationFactory;
+	#timersEnabled;
+	#sessionLocks = /* @__PURE__ */ new Map();
+	#channelMutationLock = Promise.resolve();
+	#timer;
+	#reconcileAllPromise;
+	constructor(runtime, options = {}) {
+		this.#runtime = runtime;
+		this.#store = getClickClackDiscussionBindingStore(runtime);
+		this.#clientFactory = options.clientFactory ?? ((account) => createClickClackClient({
+			baseUrl: account.apiEndpoint,
+			token: account.token
+		}));
+		this.#installationId = options.installationId ?? getClickClackDiscussionInstallationId(runtime);
+		this.#bindingGenerationFactory = options.bindingGenerationFactory ?? randomUUID;
+		this.#timersEnabled = options.startTimer !== false;
+		this.provider = {
+			id: "clickclack",
+			info: async ({ sessionKey }) => await this.info(sessionKey),
+			open: async ({ sessionKey }) => await this.open(sessionKey)
+		};
+		if (this.#timersEnabled) this.#ensureTimer();
+	}
+	hasEnabledAccount() {
+		return discussionAccounts(this.#currentConfig()).length === 1;
+	}
+	async info(sessionKey) {
+		return await this.#withSessionLock(sessionKey, async () => {
+			if (discussionAccounts(this.#currentConfig()).length !== 1) 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);
+					return { state: "available" };
+				}
+				if (resolved.state === "stale") {
+					await this.#releaseStaleBinding(sessionKey, existing);
+					return { state: "available" };
+				}
+				if (resolved.state !== "active") return { state: "none" };
+				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 () => {
+			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);
+				}
+			}
+			const 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),
+				finalizePendingBinding: (key, nextBinding) => this.#finalizePendingBinding(key, nextBinding),
+				warn: (message) => this.#logger().warn(message)
+			});
+			if (!binding) return { state: "available" };
+			this.#ensureTimer();
+			return discussionInfoForBinding(binding, account);
+		});
+	}
+	async reconcile(sessionKey) {
+		await this.#withSessionLock(sessionKey, async () => {
+			const binding = this.#store.get(sessionKey);
+			if (binding) await this.#reconcileBinding(sessionKey, binding);
+		});
+	}
+	async reconcileAll() {
+		if (this.#reconcileAllPromise) return await this.#reconcileAllPromise;
+		this.#reconcileAllPromise = (async () => {
+			for (const { sessionKey } of this.#store.entries()) try {
+				await this.reconcile(sessionKey);
+			} catch (error) {
+				this.#logger().warn(`discussion reconcile failed for ${sessionKey}: ${String(error)}`);
+			}
+			for (const pending of listPendingDiscussionOpens(this.#runtime)) try {
+				await this.#reconcilePendingOpen(pending);
+			} catch (error) {
+				this.#logger().warn(`discussion pending-open reconcile failed for ${pending.sessionKey}: ${String(error)}`);
+			}
+		})().finally(() => {
+			this.#reconcileAllPromise = void 0;
+		});
+		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." };
+		if (!bindingMatchesSessionIncarnation(this.#runtime, sessionKey, binding)) 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." };
+		const history = await this.#clientFactory(resolved.account).latestChannelMessages(binding.channelId, limit);
+		const text = history.messages.map((message) => {
+			const author = message.author?.display_name || message.author?.handle || message.author_id || "Unknown";
+			return `timestamp=${discussionRecordJson(message.created_at)} [Author ${discussionRecordJson(author)} id=${discussionRecordJson(message.author_id)}] text=${discussionRecordJson(message.body)}`;
+		}).join("\n");
+		const truncationNote = history.truncated ? "\n[History scan reached its safety bound; older active threads may be omitted.]" : "";
+		return {
+			binding,
+			text: text ? `${text}${truncationNote}` : "The bound discussion has no messages yet."
+		};
+	}
+	cleanup() {
+		if (this.#timer) {
+			clearInterval(this.#timer);
+			this.#timer = void 0;
+		}
+	}
+	async #reconcileBinding(sessionKey, binding, resolvedAccount) {
+		this.#finalizePendingBinding(sessionKey, binding);
+		if (isClickClackDiscussionChannelRevoked({
+			runtime: this.#runtime,
+			serverBaseUrl: binding.serverBaseUrl,
+			channelId: binding.channelId
+		})) {
+			this.#store.delete(sessionKey);
+			return;
+		}
+		const resolved = resolvedAccount ? {
+			state: "active",
+			account: resolvedAccount
+		} : await this.#resolveBindingForUse(binding);
+		if (resolved.state === "retargeted") {
+			this.#revokeAndDeleteBinding(sessionKey, binding);
+			return;
+		}
+		if (resolved.state === "stale") {
+			await this.#releaseStaleBinding(sessionKey, binding);
+			return;
+		}
+		if (resolved.state !== "active") return;
+		const account = resolved.account;
+		if (!account.baseUrl || !account.token) throw new Error(`ClickClack discussion account is no longer configured: ${binding.accountId}`);
+		const entry = this.#runtime.agent.session.getSessionEntry({
+			sessionKey,
+			readConsistency: "latest"
+		});
+		if (entry && (!binding.sessionId || entry.sessionId !== binding.sessionId)) {
+			await this.#archiveAndDeleteBinding(sessionKey, binding, account);
+			return;
+		}
+		const archived = entry ? entry.archivedAt !== void 0 : true;
+		const deleted = entry === void 0;
+		const label = entry ? resolveDiscussionLabel(entry.label, sessionKey) : binding.label;
+		const section = entry?.category?.trim() || account.discussions.section;
+		const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey) ?? "";
+		const patch = {};
+		if (archived !== binding.archived) patch.archived = archived;
+		const labelChanged = label !== binding.label;
+		if (section !== binding.section) patch.sidebar_section = section;
+		if (externalUrl !== binding.externalUrl) patch.external_url = externalUrl;
+		if (Object.keys(patch).length === 0 && !labelChanged) {
+			if (deleted) this.#revokeAndDeleteBinding(sessionKey, binding);
+			return;
+		}
+		const client = this.#clientFactory(account);
+		if (labelChanged) await this.#withChannelMutationLock(async () => {
+			for (let attempt = 0; attempt < CHANNEL_NAME_MUTATION_ATTEMPTS; attempt += 1) {
+				patch.name = await resolveAvailableChannelName({
+					client,
+					workspaceId: binding.workspaceId,
+					label,
+					sessionKey,
+					ownChannelId: binding.channelId
+				});
+				try {
+					assertChannelPatch(await client.updateChannel(binding.channelId, patch), patch);
+					return;
+				} catch (error) {
+					if (!isClickClackChannelNameConflict(error) || attempt === CHANNEL_NAME_MUTATION_ATTEMPTS - 1) throw error;
+				}
+			}
+		});
+		else assertChannelPatch(await client.updateChannel(binding.channelId, patch), patch);
+		if (deleted) {
+			this.#revokeAndDeleteBinding(sessionKey, binding);
+			return;
+		}
+		this.#store.set(sessionKey, {
+			...binding,
+			archived,
+			externalUrl,
+			label,
+			section
+		});
+	}
+	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 === pending.sessionId && 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
+			});
+			assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
+		}
+		clearDiscussionBindingGeneration({
+			runtime: this.#runtime,
+			sessionKey: pending.sessionKey,
+			expectedGeneration: pending.generation
+		});
+	}
+	async #releaseStaleBinding(sessionKey, binding) {
+		clearDiscussionBindingGeneration({
+			runtime: this.#runtime,
+			sessionKey
+		});
+		const boundAccount = resolveClickClackAccount({
+			cfg: this.#currentConfig(),
+			accountId: binding.accountId
+		});
+		if (!boundAccount.configured || binding.serverBaseUrl !== normalizedServerBaseUrl(boundAccount) || !binding.credentialFingerprint || binding.credentialFingerprint !== discussionCredentialFingerprint(boundAccount.token)) {
+			this.#revokeAndDeleteBinding(sessionKey, binding);
+			return;
+		}
+		assertChannelPatch(await this.#clientFactory(boundAccount).updateChannel(binding.channelId, { archived: true }), { archived: true });
+		this.#revokeAndDeleteBinding(sessionKey, binding);
+	}
+	async #archiveAndDeleteBinding(sessionKey, binding, account) {
+		clearDiscussionBindingGeneration({
+			runtime: this.#runtime,
+			sessionKey
+		});
+		assertChannelPatch(await this.#clientFactory(account).updateChannel(binding.channelId, { archived: true }), { archived: true });
+		this.#revokeAndDeleteBinding(sessionKey, binding);
+	}
+	#revokeAndDeleteBinding(sessionKey, binding) {
+		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);
+		if (pending) {
+			clearClickClackDiscussionChannelRevoked({
+				runtime: this.#runtime,
+				serverBaseUrl: binding.serverBaseUrl,
+				channelId: binding.channelId
+			});
+			clearDiscussionBindingGeneration({
+				runtime: this.#runtime,
+				sessionKey,
+				expectedGeneration: pending.generation
+			});
+		}
+	}
+	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" };
+	}
+	#currentConfig() {
+		return this.#runtime.config.current();
+	}
+	#ensureTimer() {
+		if (!this.#timersEnabled || this.#timer || this.#store.entries().length === 0 && listPendingDiscussionOpens(this.#runtime).length === 0) return;
+		this.#timer = setInterval(() => {
+			this.reconcileAll().catch((error) => {
+				this.#logger().warn(`discussion reconcile pass failed: ${String(error)}`);
+			}).finally(() => {
+				if (this.#store.entries().length === 0 && listPendingDiscussionOpens(this.#runtime).length === 0 && this.#timer) {
+					clearInterval(this.#timer);
+					this.#timer = void 0;
+				}
+			});
+		}, RECONCILE_INTERVAL_MS);
+		this.#timer.unref?.();
+	}
+	#logger() {
+		return this.#runtime.logging.getChildLogger({
+			plugin: "clickclack",
+			feature: "discussions"
+		});
+	}
+	async #withSessionLock(sessionKey, run) {
+		const current = (this.#sessionLocks.get(sessionKey) ?? Promise.resolve()).catch(() => void 0).then(run);
+		this.#sessionLocks.set(sessionKey, current);
+		try {
+			return await current;
+		} finally {
+			if (this.#sessionLocks.get(sessionKey) === current) this.#sessionLocks.delete(sessionKey);
+		}
+	}
+	async #withChannelMutationLock(run) {
+		const current = this.#channelMutationLock.catch(() => void 0).then(run);
+		this.#channelMutationLock = current;
+		return await current;
+	}
+};
+//#endregion
+//#region extensions/clickclack/src/discussions/tool-policy.ts
+const TARGETED_SESSION_TOOLS = /* @__PURE__ */ new Set([
+	"sessions_history",
+	"sessions_send",
+	"session_status"
+]);
+function blockedResult() {
+	return {
+		block: true,
+		blockReason: `ClickClack discussion sessions may use ${[...TARGETED_SESSION_TOOLS].join(", ")} only with their attached main session.`
+	};
+}
+function isClickClackDiscussionSessionTarget(params) {
+	const matched = getClickClackDiscussionBindingStore(params.runtime).getByDiscussionSession(params.requesterSessionKey);
+	if (matched && matched.sessionKey === params.targetSessionKey && !isClickClackDiscussionChannelRevoked({
+		runtime: params.runtime,
+		serverBaseUrl: matched.binding.serverBaseUrl,
+		channelId: matched.binding.channelId
+	}) && !matched.binding.archived && bindingMatchesActiveSessionIncarnation(params.runtime, matched.sessionKey, matched.binding) && resolveDiscussionBindingAccount(params.runtime.config.current(), matched.binding).state === "active") return matched;
+}
+/** Restricts a discussion side session's session tools to its attached main session. */
+function enforceClickClackDiscussionToolTarget(params) {
+	const callerSessionKey = params.context.sessionKey;
+	if (!callerSessionKey) return;
+	const { toolName } = params.event;
+	if (toolName !== "session_status" && !toolName.startsWith("sessions_")) return;
+	const matched = getClickClackDiscussionBindingStore(params.runtime).getByDiscussionSession(callerSessionKey);
+	if (!matched) return isDiscussionSessionKey(callerSessionKey) ? blockedResult() : void 0;
+	const targetsMain = Boolean(isClickClackDiscussionSessionTarget({
+		runtime: params.runtime,
+		requesterSessionKey: callerSessionKey,
+		targetSessionKey: matched.sessionKey
+	})) && TARGETED_SESSION_TOOLS.has(toolName) && params.event.params.sessionKey === matched.sessionKey;
+	const usesAlternateSendTarget = toolName === "sessions_send" && (params.event.params.label !== void 0 || params.event.params.agentId !== void 0);
+	const mutatesStatus = toolName === "session_status" && params.event.params.model !== void 0;
+	const selectsHistoryIncarnation = toolName === "sessions_history" && params.event.params.sessionId !== void 0;
+	if (targetsMain && !usesAlternateSendTarget && !mutatesStatus && !selectsHistoryIncarnation) return;
+	return blockedResult();
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/tool.ts
+const DEFAULT_MESSAGE_LIMIT = 30;
+const MAX_MESSAGE_LIMIT = 200;
+function createClickClackDiscussionTool(params) {
+	return {
+		name: "discussion",
+		label: "Discussion",
+		description: "Read the latest messages from the ClickClack discussion bound to this session.",
+		parameters: {
+			type: "object",
+			properties: { limit: {
+				type: "integer",
+				minimum: 1,
+				maximum: MAX_MESSAGE_LIMIT,
+				description: `Maximum messages to return (default ${DEFAULT_MESSAGE_LIMIT}).`
+			} },
+			additionalProperties: false
+		},
+		async execute(_toolCallId, input) {
+			if (!params.sessionKey) return textResult("No discussion is bound to this session.", { bound: false });
+			const requested = typeof input === "object" && input !== null && "limit" in input ? Number(input.limit) : DEFAULT_MESSAGE_LIMIT;
+			const limit = Number.isInteger(requested) ? Math.max(1, Math.min(MAX_MESSAGE_LIMIT, requested)) : DEFAULT_MESSAGE_LIMIT;
+			const result = await params.service.readLatestMessages(params.sessionKey, limit);
+			return textResult(result.text, {
+				bound: Boolean(result.binding),
+				limit,
+				...result.binding ? { channelId: result.binding.channelId } : {}
+			});
+		}
+	};
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/register.ts
+function registerClickClackDiscussions(api) {
+	if (api.registrationMode === "tool-discovery") {
+		api.registerTool(() => null, { name: "discussion" });
+		return;
+	}
+	const service = new ClickClackDiscussionService(api.runtime);
+	api.registerTool((context) => createClickClackDiscussionTool({
+		service,
+		sessionKey: context.sessionKey
+	}));
+	api.on("before_tool_call", (event, context) => enforceClickClackDiscussionToolTarget({
+		runtime: api.runtime,
+		event,
+		context
+	}));
+	const unregisterSessionAccess = createSessionVisibilityChecker.registerScopedAccessProvider(({ requesterSessionKey, targetSessionKey }) => {
+		const target = isClickClackDiscussionSessionTarget({
+			runtime: api.runtime,
+			requesterSessionKey,
+			targetSessionKey
+		});
+		return target ? { expectedSessionId: target.binding.sessionId } : void 0;
+	});
+	registerSessionDiscussionProvider(service.provider);
+	api.lifecycle.registerRuntimeLifecycle({
+		id: "clickclack-discussions",
+		description: "Stops the lifecycle reconciler for managed ClickClack discussions.",
+		cleanup: () => {
+			unregisterSessionAccess();
+			service.cleanup();
+		}
+	});
+}
+//#endregion
+export { registerClickClackDiscussions as t };