@openclaw/clickclack 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{runtime-api-CZ1rmHjv.js → runtime-api-CPL3m5AD.js}

@@ -1,104 +1,70 @@
-import { d as createClickClackClient, f as isClickClackChannelNameConflict, u as ClickClackHttpError, x as resolveClickClackAccount, y as listClickClackAccountIds } from "./setup-surface-DAy8vDJK.js";
-import { C as truncateDiscussionDisplayTitle, D as reserveDiscussionBindingGeneration, E as recordPendingDiscussionOpen, S as slugifyDiscussionLabel, T as listPendingDiscussionOpens, _ as discussionCredentialFingerprint, b as isDiscussionSessionKey, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as getClickClackDiscussionBindingStore, h as bindingMatchesSessionIncarnation, l as markClickClackDiscussionChannelRevoked, m as bindingMatchesActiveSessionIncarnation, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionExternalRef, w as clearDiscussionBindingGeneration, x as resolveDiscussionLabel, y as fallbackDiscussionLabel } from "./channel-CECIpaS0.js";
+import { b as resolveClickClackAccount, d as isClickClackChannelNameConflict, l as ClickClackHttpError, u as createClickClackClient, v as listClickClackAccountIds } from "./setup-surface-DjT-gmMe.js";
+import { C as slugifyDiscussionLabel, D as listPendingDiscussionOpens, E as clearPendingDiscussionOpen, O as recordPendingDiscussionOpen, S as resolveDiscussionLabel, T as clearDiscussionBindingGeneration, _ as getClickClackDiscussionBindingStore, b as fallbackDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as bindingMatchesActiveSessionIncarnation, h as attachBindingToCurrentActiveSession, k as reserveDiscussionBindingGeneration, l as markClickClackDiscussionChannelRevoked, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionCredentialFingerprint, w as truncateDiscussionDisplayTitle, x as isDiscussionSessionKey, y as discussionExternalRef } from "./channel-DaHgaTy1.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 { buildControlUiSessionPath, registerSessionDiscussionProvider } from "openclaw/plugin-sdk/session-discussion";
 import { createSessionVisibilityChecker } from "openclaw/plugin-sdk/session-visibility";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveSessionAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { textResult } from "openclaw/plugin-sdk/tool-results";
-//#region extensions/clickclack/src/discussions/control-session-url.ts
-const SESSION_UUID_SUFFIX_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/iu;
-const SHORT_SESSION_REF_RE = /^(?:.*-)?([0-9a-f]{8,32})$/iu;
-const VALID_AGENT_ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/iu;
-const INVALID_AGENT_ID_CHARS_RE = /[^a-z0-9_-]+/giu;
-const FIXED_RESERVED_SESSION_RESTS = /* @__PURE__ */ new Set([
-	"main",
-	"global",
-	"boot",
-	"sessions"
-]);
-const SESSION_SLUG_MAX_LENGTH = 48;
-const DEFAULT_AGENT_ID = "main";
-const DEFAULT_MAIN_KEY = "main";
-function optionalString(value) {
-	return (value?.trim() ?? "") || null;
-}
-function normalizeAgentId$1(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return DEFAULT_AGENT_ID;
-	if (VALID_AGENT_ID_RE.test(trimmed)) return trimmed.toLowerCase();
-	return trimmed.toLowerCase().replace(INVALID_AGENT_ID_CHARS_RE, "-").replace(/^-+|-+$/gu, "").slice(0, 64) || DEFAULT_AGENT_ID;
-}
-function normalizeBasePath(basePath) {
-	const trimmed = basePath.trim().replace(/^\/+|\/+$/gu, "");
-	return trimmed ? `/${trimmed}` : "";
-}
-function agentSessionKeyParts(sessionKey) {
-	const parts = sessionKey.split(":");
-	if (parts.length < 3 || parts[0]?.toLowerCase() !== "agent") return null;
-	const agentId = optionalString(parts[1]);
-	const restSegments = parts.slice(2);
-	if (!agentId || restSegments.some((segment) => !segment)) return null;
-	return {
-		agentId: normalizeAgentId$1(agentId),
-		rest: restSegments.join(":")
-	};
-}
-function encodePathSegment(segment) {
-	if (segment === ".") return "~dot";
-	if (segment === "..") return "~dotdot";
-	const encoded = encodeURIComponent(segment).replaceAll(".", "%2E");
-	return encoded.startsWith("~") ? `~${encoded}` : encoded;
-}
-function isReservedSessionRest(rest, mainKey) {
-	const normalized = rest.toLowerCase();
-	return FIXED_RESERVED_SESSION_RESTS.has(normalized) || normalized === (optionalString(mainKey)?.toLowerCase() ?? DEFAULT_MAIN_KEY);
-}
-function sessionSlug(displayName) {
-	const tokens = (displayName ?? "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").split("-").filter(Boolean);
-	while (tokens.length > 0 && /^[0-9a-f]+$/u.test(tokens.at(-1) ?? "")) tokens.pop();
-	return tokens.join("-").slice(0, SESSION_SLUG_MAX_LENGTH).replace(/-+$/gu, "");
-}
-function sessionKeyUuid(sessionKey) {
-	const uuid = (agentSessionKeyParts(sessionKey)?.rest)?.match(SESSION_UUID_SUFFIX_RE)?.[1];
-	return uuid ? uuid.toLowerCase().replaceAll("-", "") : null;
-}
-function sessionPath(params) {
-	const rawKey = optionalString(params.sessionKey);
-	const parsed = rawKey ? agentSessionKeyParts(rawKey) : null;
-	const fallbackAgentId = optionalString(params.fallbackAgentId);
-	const agentId = parsed?.agentId ?? (fallbackAgentId ? normalizeAgentId$1(fallbackAgentId) : null);
-	if (!rawKey || !agentId || !parsed && rawKey.toLowerCase().startsWith("agent:")) return null;
-	const namespace = `${normalizeBasePath(params.basePath)}/chat`;
-	const encodedAgentId = encodePathSegment(agentId);
-	const rest = parsed?.rest ?? rawKey;
-	const normalizedRest = rest.toLowerCase();
-	const mainKey = optionalString(params.mainKey)?.toLowerCase() ?? DEFAULT_MAIN_KEY;
-	if (!parsed && normalizedRest === DEFAULT_MAIN_KEY || normalizedRest === mainKey || normalizedRest === "global") return `${namespace}/${encodedAgentId}`;
-	const uuid = parsed ? sessionKeyUuid(rawKey) : null;
-	if (uuid) {
-		let length = 8;
-		const slug = sessionSlug(params.displayName);
-		let sessionRef = `${slug ? `${slug}-` : ""}${uuid.slice(0, length)}`;
-		while (length < uuid.length && isReservedSessionRest(sessionRef, params.mainKey)) {
-			length += 1;
-			sessionRef = `${slug ? `${slug}-` : ""}${uuid.slice(0, length)}`;
+//#region extensions/clickclack/src/discussions/binding-retention.ts
+var DetachedDiscussionBindingRetention = class {
+	#runtime;
+	#store;
+	#maxRetained;
+	constructor(options) {
+		this.#runtime = options.runtime;
+		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, {
+			...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");
+	}
+	clear(sessionKey, binding) {
+		const current = this.#store.get(sessionKey);
+		if (!current || !this.#sameRoom(current, binding)) return;
+		if (current.detachedAt === void 0) return current;
+		const { detachedAt: _detachedAt, ...retained } = current;
+		this.#store.set(sessionKey, retained);
+		return retained;
+	}
+	ensureCapacity(sessionKey) {
+		while (!this.#store.hasCapacity(sessionKey)) if (!this.#pruneOldest()) throw new Error("ClickClack discussion binding capacity is exhausted");
+	}
+	#pruneOldest() {
+		for (;;) {
+			const oldest = this.#store.oldestDetached();
+			if (!oldest) return false;
+			const current = this.#store.get(oldest.sessionKey);
+			if (!current || current.detachedAt === void 0) continue;
+			if (this.#runtime.agent.session.getSessionEntry({
+				sessionKey: oldest.sessionKey,
+				readConsistency: "latest"
+			})) {
+				this.clear(oldest.sessionKey, current);
+				continue;
+			}
+			markClickClackDiscussionChannelRevoked(this.#runtime, current);
+			this.#store.delete(oldest.sessionKey);
+			return true;
 		}
-		return isReservedSessionRest(sessionRef, params.mainKey) ? null : `${namespace}/${encodedAgentId}/${sessionRef}`;
 	}
-	const segments = rest.split(":");
-	if (segments.some((segment) => !segment)) return null;
-	if (segments.length === 1) {
-		const segment = segments[0] ?? "";
-		if (!isReservedSessionRest(segment, params.mainKey) && SHORT_SESSION_REF_RE.test(segment)) return `${namespace}/${encodedAgentId}/~key/${encodePathSegment(segment)}`;
+	#sameRoom(left, right) {
+		return left.serverBaseUrl === right.serverBaseUrl && left.channelId === right.channelId && left.externalRef === right.externalRef;
 	}
-	return `${namespace}/${encodedAgentId}/${segments.map(encodePathSegment).join("/")}`;
-}
+};
+//#endregion
+//#region extensions/clickclack/src/discussions/control-session-url.ts
 function controlSessionUrl(baseUrl, sessionKey, fallbackAgentId, mainKey, displayName) {
 	if (!baseUrl) return;
 	const url = new URL(baseUrl);
-	const path = sessionPath({
+	const path = buildControlUiSessionPath({
+		namespace: "chat",
 		sessionKey,
 		fallbackAgentId,
 		basePath: url.pathname,
@@ -277,7 +243,7 @@ async function openClickClackDiscussionBinding(params) {
 		sessionKey,
 		readConsistency: "latest"
 	});
-	if (!entry) return;
+	if (!entry || entry.archivedAt !== void 0) 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);
@@ -286,30 +252,34 @@ async function openClickClackDiscussionBinding(params) {
 	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)) {
+	if (unresolved && (unresolved.accountId !== account.accountId || unresolved.credentialFingerprint !== credentialFingerprint || unresolved.serverBaseUrl !== serverBaseUrl || unresolved.workspaceId !== workspace.id)) {
 		await params.reconcilePendingOpen(unresolved);
 		if (listPendingDiscussionOpens(runtime).some((pending) => pending.sessionKey === sessionKey)) throw new Error("A previous ClickClack discussion open is still unresolved; restore its credential and retry");
 	}
 	const config = runtime.config.current();
-	const agentId = resolveAgentIdFromSessionKey(sessionKey, resolveDefaultAgentId(config));
+	const agentId = resolveSessionAgentId({
+		config,
+		sessionKey
+	});
 	const fallback = fallbackDiscussionLabel(sessionKey, agentId);
 	const label = resolveDiscussionLabel(entry, sessionKey, agentId);
 	const displayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
 	const section = entry.category?.trim() || account.discussions.section;
-	const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? "main", config.session?.mainKey, label);
-	const archived = entry.archivedAt !== void 0;
+	const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? agentId, config.session?.mainKey, label);
 	return await params.withChannelMutationLock(async () => {
-		if (!store.hasCapacity(sessionKey)) throw new Error("ClickClack discussion binding capacity is exhausted");
+		params.ensureBindingCapacity(sessionKey);
 		let channels = await client.channels(workspace.id);
 		assertManagedChannelListContract(channels);
 		const destinationIdentity = [serverBaseUrl, workspace.id].join("\0");
 		const bindingGeneration = reserveDiscussionBindingGeneration({
 			runtime,
 			sessionKey,
+			accountId: account.accountId,
+			credentialFingerprint,
 			destinationIdentity,
 			createGeneration: params.bindingGenerationFactory
 		});
-		const externalRef = discussionExternalRef(params.installationId, sessionKey, entry.sessionId, destinationIdentity, bindingGeneration);
+		const externalRef = discussionExternalRef(params.installationId, sessionKey, destinationIdentity, bindingGeneration);
 		let adopted;
 		let managedFields;
 		let resolved;
@@ -353,10 +323,7 @@ async function openClickClackDiscussionBinding(params) {
 						serverBaseUrl,
 						channelId: adopted.id
 					});
-					resolved = await client.updateChannel(adopted.id, {
-						...managedFields,
-						archived
-					});
+					resolved = await client.updateChannel(adopted.id, managedFields);
 				} else {
 					resolved = await client.createChannel(workspace.id, {
 						...managedFields,
@@ -389,10 +356,7 @@ async function openClickClackDiscussionBinding(params) {
 							serverBaseUrl,
 							channelId: recovered.id
 						});
-						resolved = await client.updateChannel(recovered.id, {
-							...managedFields,
-							archived
-						});
+						resolved = await client.updateChannel(recovered.id, managedFields);
 						break;
 					}
 					if (definitiveNoCreate) clearDiscussionBindingGeneration({
@@ -419,89 +383,104 @@ async function openClickClackDiscussionBinding(params) {
 				externalUrl,
 				displayTitle
 			});
-			if (adopted) assertChannelPatch(resolved, {
-				...managedFields,
-				archived
-			});
+			if (adopted) assertChannelPatch(resolved, managedFields);
 		} 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)}`);
-			}
+			clearPendingDiscussionOpen({
+				runtime,
+				sessionKey,
+				expectedGeneration: bindingGeneration
+			});
+			params.warn(`incompatible discussion channel remains quarantined: ${resolved.id}`);
 			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)}`);
-			}
+			clearPendingDiscussionOpen({
+				runtime,
+				sessionKey,
+				expectedGeneration: bindingGeneration
+			});
+			params.warn(`route-less discussion channel remains quarantined: ${resolved.id}`);
 			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 channel = resolved;
+		const currentEntry = runtime.agent.session.getSessionEntry({
+			sessionKey,
+			readConsistency: "latest"
+		});
+		if (!currentEntry?.sessionId || currentEntry.archivedAt !== void 0) {
+			clearPendingDiscussionOpen({
+				runtime,
+				sessionKey,
+				expectedGeneration: bindingGeneration
+			});
+			params.warn(`unattached discussion channel remains quarantined: ${channel.id}`);
+			throw new Error("OpenClaw session became inactive while opening its ClickClack discussion");
+		}
+		const currentLabel = resolveDiscussionLabel(currentEntry, sessionKey, agentId);
+		const currentDisplayTitle = currentLabel === fallback ? "" : truncateDiscussionDisplayTitle(currentLabel);
+		const currentSection = currentEntry.category?.trim() || account.discussions.section;
+		const currentExternalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? agentId, config.session?.mainKey, currentLabel) ?? "";
+		let currentChannel = channel;
+		if (currentEntry.sessionId !== entry.sessionId || currentLabel !== label || currentDisplayTitle !== displayTitle || currentSection !== section || currentExternalUrl !== (externalUrl ?? "")) try {
+			for (let attempt = 0; attempt < CHANNEL_NAME_MUTATION_ATTEMPTS$1; attempt += 1) {
+				const latestManagedFields = {
+					...managedFields,
+					name: await resolveAvailableChannelName({
+						client,
+						workspaceId: workspace.id,
+						label: currentLabel,
+						sessionKey,
+						agentId,
+						ownChannelId: channel.id
+					}),
+					external_url: currentExternalUrl,
+					sidebar_section: currentSection,
+					display_title: currentDisplayTitle
+				};
+				try {
+					currentChannel = await client.updateChannel(channel.id, latestManagedFields);
+					assertChannelPatch(currentChannel, latestManagedFields);
+					break;
+				} catch (error) {
+					if (!isClickClackChannelNameConflict(error) || attempt === CHANNEL_NAME_MUTATION_ATTEMPTS$1 - 1) throw error;
+				}
+			}
+		} catch (error) {
+			clearPendingDiscussionOpen({
+				runtime,
+				sessionKey,
+				expectedGeneration: bindingGeneration
+			});
+			params.warn(`unattached discussion channel remains quarantined: ${channel.id}`);
+			throw error;
 		}
 		const nextBinding = {
 			accountId: account.accountId,
 			agentId,
-			sessionId: entry.sessionId,
+			sessionId: currentEntry.sessionId,
 			serverBaseUrl,
 			credentialFingerprint,
 			externalRef,
-			externalUrl: externalUrl ?? "",
+			externalUrl: currentExternalUrl,
 			workspaceRef: account.discussions.workspace,
 			workspaceId: workspace.id,
 			channelId: channel.id,
 			channelRouteId: channel.route_id,
 			workspaceRouteId: workspace.route_id,
-			section,
-			archived,
-			label,
-			displayTitle: "display_title" in channel ? channel.display_title : void 0
+			section: currentSection,
+			archived: false,
+			label: currentLabel,
+			...currentChannel.display_title !== void 0 ? { displayTitle: currentChannel.display_title } : {}
 		};
-		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)}`);
-			}
+			clearPendingDiscussionOpen({
+				runtime,
+				sessionKey,
+				expectedGeneration: bindingGeneration
+			});
+			params.warn(`unbound discussion channel remains quarantined: ${channel.id}`);
 			throw error;
 		}
 		params.finalizePendingBinding(sessionKey, nextBinding);
@@ -518,6 +497,7 @@ var ClickClackDiscussionService = class {
 	#clientFactory;
 	#installationId;
 	#bindingGenerationFactory;
+	#detachedBindings;
 	#timersEnabled;
 	#sessionLocks = /* @__PURE__ */ new Map();
 	#reconcileScheduler = new DiscussionReconcileScheduler({
@@ -539,6 +519,11 @@ var ClickClackDiscussionService = class {
 		}));
 		this.#installationId = options.installationId ?? getClickClackDiscussionInstallationId(runtime);
 		this.#bindingGenerationFactory = options.bindingGenerationFactory ?? randomUUID;
+		this.#detachedBindings = new DetachedDiscussionBindingRetention({
+			runtime,
+			store: this.#store,
+			maxRetained: options.maxRetainedDetachedBindings ?? 1e3
+		});
 		this.#timersEnabled = options.startTimer !== false;
 		this.provider = {
 			id: "clickclack",
@@ -616,6 +601,7 @@ var ClickClackDiscussionService = class {
 					ensureTimer: () => this.#ensureTimer(),
 					reconcilePendingOpen: async (pending) => await this.#reconcilePendingOpen(pending, { allowRetry: false }),
 					withChannelMutationLock: async (run) => await this.#withChannelMutationLock(run),
+					ensureBindingCapacity: (key) => this.#detachedBindings.ensureCapacity(key),
 					finalizePendingBinding: (key, nextBinding) => this.#finalizePendingBinding(key, nextBinding),
 					warn: (message) => this.#logger().warn(message)
 				});
@@ -658,15 +644,16 @@ var ClickClackDiscussionService = class {
 		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." };
+		const attached = this.#refreshSessionAttachment(sessionKey, binding);
+		if (!attached) return { text: "No discussion is bound to this session." };
 		if (isClickClackDiscussionChannelRevoked({
 			runtime: this.#runtime,
 			serverBaseUrl: binding.serverBaseUrl,
 			channelId: binding.channelId
 		})) return { text: "No discussion is bound to this session." };
 		return {
-			binding,
-			text: formatDiscussionHistory(await this.#clientFactory(resolved.account).latestChannelMessages(binding.channelId, limit)) || "The bound discussion has no messages yet."
+			binding: attached,
+			text: formatDiscussionHistory(await this.#clientFactory(resolved.account).latestChannelMessages(attached.channelId, limit)) || "The bound discussion has no messages yet."
 		};
 	}
 	cleanup() {
@@ -690,62 +677,62 @@ var ClickClackDiscussionService = class {
 			this.#store.delete(sessionKey);
 			return;
 		}
+		const entry = this.#runtime.agent.session.getSessionEntry({
+			sessionKey,
+			readConsistency: "latest"
+		});
+		if (!entry) {
+			this.#detachedBindings.mark(sessionKey, binding);
+			return;
+		}
+		const activeBinding = this.#detachedBindings.clear(sessionKey, binding);
+		if (!activeBinding) return;
 		const resolved = resolvedAccount ? {
 			state: "active",
 			account: resolvedAccount
-		} : await this.#resolveBindingForUse(binding);
+		} : await this.#resolveBindingForUse(activeBinding);
 		if (resolved.state === "retargeted") {
-			this.#revokeAndDeleteBinding(sessionKey, binding);
+			this.#revokeAndDeleteBinding(sessionKey, activeBinding);
 			return;
 		}
 		if (resolved.state === "stale") {
-			await this.#releaseStaleBinding(sessionKey, binding);
+			await this.#releaseStaleBinding(sessionKey, activeBinding);
 			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 fallback = fallbackDiscussionLabel(sessionKey, binding.agentId);
-		const label = entry ? resolveDiscussionLabel(entry, sessionKey, binding.agentId) : binding.label;
-		const section = entry?.category?.trim() || account.discussions.section;
+		if (!account.baseUrl || !account.token) throw new Error(`ClickClack discussion account is no longer configured: ${activeBinding.accountId}`);
+		if (entry.archivedAt !== void 0) return;
+		const attached = this.#refreshSessionAttachment(sessionKey, activeBinding);
+		if (!attached) return;
+		const currentBinding = attached;
+		const fallback = fallbackDiscussionLabel(sessionKey, currentBinding.agentId);
+		const label = resolveDiscussionLabel(entry, sessionKey, currentBinding.agentId);
+		const section = entry.category?.trim() || account.discussions.section;
 		const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? "main", this.#currentConfig().session?.mainKey, label) ?? "";
 		const patch = {};
-		if (archived !== binding.archived) patch.archived = archived;
-		const labelChanged = label !== binding.label;
+		const labelChanged = label !== currentBinding.label;
 		const desiredDisplayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
-		const serverSupportsDisplayTitle = this.#store.entries().some(({ binding: candidate }) => candidate.displayTitle !== void 0 && candidate.serverBaseUrl === binding.serverBaseUrl && candidate.accountId === binding.accountId);
-		const shouldBackfillDisplayTitle = desiredDisplayTitle !== "" && binding.displayTitle !== desiredDisplayTitle && serverSupportsDisplayTitle;
+		const serverSupportsDisplayTitle = this.#store.entries().some(({ binding: candidate }) => candidate.displayTitle !== void 0 && candidate.serverBaseUrl === currentBinding.serverBaseUrl && candidate.accountId === currentBinding.accountId);
+		const shouldBackfillDisplayTitle = desiredDisplayTitle !== "" && currentBinding.displayTitle !== desiredDisplayTitle && serverSupportsDisplayTitle;
 		if (labelChanged || shouldBackfillDisplayTitle) patch.display_title = desiredDisplayTitle;
-		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;
-		}
+		if (section !== currentBinding.section) patch.sidebar_section = section;
+		if (externalUrl !== currentBinding.externalUrl) patch.external_url = externalUrl;
+		if (Object.keys(patch).length === 0 && !labelChanged) return;
 		const client = this.#clientFactory(account);
 		let updated;
 		if (labelChanged) updated = await this.#withChannelMutationLock(async () => {
 			for (let attempt = 0; attempt < CHANNEL_NAME_MUTATION_ATTEMPTS; attempt += 1) {
 				patch.name = await resolveAvailableChannelName({
 					client,
-					workspaceId: binding.workspaceId,
+					workspaceId: currentBinding.workspaceId,
 					label,
 					sessionKey,
-					agentId: binding.agentId,
-					ownChannelId: binding.channelId
+					agentId: currentBinding.agentId,
+					ownChannelId: currentBinding.channelId
 				});
 				try {
-					const renamed = await client.updateChannel(binding.channelId, patch);
+					const renamed = await client.updateChannel(currentBinding.channelId, patch);
 					assertChannelPatch(renamed, patch);
 					return renamed;
 				} catch (error) {
@@ -755,21 +742,33 @@ var ClickClackDiscussionService = class {
 			throw new Error("ClickClack discussion channel name retries were exhausted");
 		});
 		else {
-			updated = await client.updateChannel(binding.channelId, patch);
+			updated = await client.updateChannel(currentBinding.channelId, patch);
 			assertChannelPatch(updated, patch);
 		}
-		if (deleted) {
-			this.#revokeAndDeleteBinding(sessionKey, binding);
-			return;
-		}
-		this.#store.set(sessionKey, {
-			...binding,
-			archived,
+		const latestBinding = this.#store.get(sessionKey);
+		if (!latestBinding || latestBinding.serverBaseUrl !== currentBinding.serverBaseUrl || latestBinding.channelId !== currentBinding.channelId || latestBinding.externalRef !== currentBinding.externalRef) return;
+		const nextBinding = {
+			...latestBinding,
 			externalUrl,
 			label,
 			section,
-			displayTitle: "display_title" in updated ? updated.display_title : void 0
-		});
+			...updated.display_title !== void 0 ? { displayTitle: updated.display_title } : {}
+		};
+		if (updated.display_title === void 0) delete nextBinding.displayTitle;
+		this.#store.set(sessionKey, nextBinding);
+	}
+	#refreshSessionAttachment(sessionKey, binding) {
+		try {
+			return attachBindingToCurrentActiveSession({
+				runtime: this.#runtime,
+				store: this.#store,
+				sessionKey,
+				binding
+			});
+		} catch (error) {
+			this.#logger().warn(`discussion attachment refresh failed for ${sessionKey}: ${String(error)}`);
+			return;
+		}
 	}
 	async #reconcilePendingOpen(pending, options = {}) {
 		const currentBinding = this.#store.get(pending.sessionKey);
@@ -790,7 +789,7 @@ var ClickClackDiscussionService = class {
 		});
 		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 (options.allowRetry !== false && entry?.sessionId && entry.archivedAt === void 0 && retryAccount && normalizedServerBaseUrl(retryAccount) === pending.serverBaseUrl && discussionCredentialFingerprint(retryAccount.token) === pending.credentialFingerprint) {
 			if ((await this.#clientFactory(retryAccount).workspaces()).find((candidate) => candidate.id === retryAccount.discussions.workspace || candidate.slug === retryAccount.discussions.workspace || candidate.name === retryAccount.discussions.workspace)?.id === pending.workspaceId) {
 				await this.open(pending.sessionKey);
 				return;
@@ -806,7 +805,12 @@ var ClickClackDiscussionService = class {
 				serverBaseUrl: pending.serverBaseUrl,
 				channelId: channel.id
 			});
-			assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
+			clearPendingDiscussionOpen({
+				runtime: this.#runtime,
+				sessionKey: pending.sessionKey,
+				expectedGeneration: pending.generation
+			});
+			return;
 		}
 		clearDiscussionBindingGeneration({
 			runtime: this.#runtime,
@@ -819,23 +823,6 @@ var ClickClackDiscussionService = class {
 			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) {
@@ -928,7 +915,7 @@ function isClickClackDiscussionSessionTarget(params) {
 		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;
+	}) && 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) {

package/dist/runtime-api.js

@@ -1,4 +1,4 @@
-import { d as createClickClackClient, x as resolveClickClackAccount } from "./setup-surface-DAy8vDJK.js";
-import { a as setClickClackRuntime, r as parseClickClackTarget } from "./channel-CECIpaS0.js";
-import { t as registerClickClackDiscussions } from "./runtime-api-CZ1rmHjv.js";
+import { b as resolveClickClackAccount, u as createClickClackClient } from "./setup-surface-DjT-gmMe.js";
+import { a as setClickClackRuntime, r as parseClickClackTarget } from "./channel-DaHgaTy1.js";
+import { t as registerClickClackDiscussions } from "./runtime-api-CPL3m5AD.js";
 export { createClickClackClient, parseClickClackTarget, registerClickClackDiscussions, resolveClickClackAccount, setClickClackRuntime };