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

package/dist/{channel-DfcFlLjC.js → channel-DaHgaTy1.js}

@@ -1,722 +1,1078 @@
-import { _ as clickClackMeta, b as listEnabledClickClackAccounts, c as resolveChannelId, d as createClickClackClient, g as clickClackConfigAdapter, h as CLICKCLACK_CHANNEL_ID, l as resolveWorkspaceId, m as clickClackConfigSchema, n as clickClackSetupAdapter, p as normalizeClickClackCorrelationId, r as clickClackSetupContract, t as clickClackSetupWizard, v as DEFAULT_ACCOUNT_ID, x as resolveClickClackAccount } from "./setup-surface-CD6MUC1g.js";
+import { _ as DEFAULT_ACCOUNT_ID, b as resolveClickClackAccount, c as resolveWorkspaceId, f as normalizeClickClackCorrelationId, g as clickClackMeta, h as clickClackConfigAdapter, l as ClickClackHttpError, m as CLICKCLACK_CHANNEL_ID, n as clickClackSetupContract, p as clickClackConfigSchema, s as resolveChannelId, t as clickClackSetupWizard, u as createClickClackClient, y as listEnabledClickClackAccounts } from "./setup-surface-DjT-gmMe.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-BKkzzjBA.js";
+import { parseDateStringTimestampMs } from "openclaw/plugin-sdk/number-runtime";
+import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
+import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelOutboundSessionRoute, buildThreadAwareOutboundSessionRoute, createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { buildChannelProgressDraftLine, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, deriveDurableFinalDeliveryRequirements } from "openclaw/plugin-sdk/channel-outbound";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { channelReadyPatch, channelStoppedPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { rawDataToString } from "openclaw/plugin-sdk/webhook-ingress";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
-import { createChannelInboundEnvelopeBuilder } from "openclaw/plugin-sdk/channel-inbound";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { createHash, randomUUID } from "node:crypto";
+import { buildMentionRegexes, normalizeMentionText } from "openclaw/plugin-sdk/channel-mention-gating";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
+import { buildChannelInboundEventContext, createChannelInboundEnvelopeBuilder, recordChannelBotPairLoopAndCheckSuppression } from "openclaw/plugin-sdk/channel-inbound";
+import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
 import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 import { FormatCapabilityProfile, renderMarkdownWithMarkers, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
-//#region extensions/clickclack/src/runtime.ts
-/**
-* Runtime store for host-provided OpenClaw services used by the ClickClack
-* bundled plugin.
-*/
-const { setRuntime: setClickClackRuntime, getRuntime: getClickClackRuntime } = createPluginRuntimeStore({
-	pluginId: "clickclack",
-	errorMessage: "ClickClack runtime not initialized"
-});
-//#endregion
-//#region extensions/clickclack/src/access.ts
-/**
-* Maps ClickClack senders and conversations onto the shared channel ingress
-* allowlist/command authorization contract.
-*/
-const CHANNEL_ID$2 = "clickclack";
-function normalizeClickClackUserId(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	const withoutProvider = trimmed.replace(/^(clickclack|cc):/i, "").trim();
-	return withoutProvider.match(/^dm:(.+)$/i)?.[1]?.trim() || withoutProvider || null;
+//#region extensions/clickclack/src/discussions/binding-generation.ts
+const DISCUSSION_GENERATIONS_NAMESPACE = "discussion-binding-generations";
+const MAX_PENDING_DISCUSSION_GENERATIONS = 1e4;
+const storesByRuntime$2 = /* @__PURE__ */ new WeakMap();
+function getGenerationStore(runtime) {
+	const existing = storesByRuntime$2.get(runtime);
+	if (existing) return existing;
+	const created = runtime.state.openSyncKeyedStore({
+		namespace: DISCUSSION_GENERATIONS_NAMESPACE,
+		maxEntries: MAX_PENDING_DISCUSSION_GENERATIONS,
+		overflowPolicy: "reject-new"
+	});
+	storesByRuntime$2.set(runtime, created);
+	return created;
 }
-const clickClackIngressIdentity = {
-	key: "user-id",
-	normalizeEntry: normalizeClickClackUserId,
-	normalizeSubject: normalizeClickClackUserId,
-	isWildcardEntry: (entry) => normalizeClickClackUserId(entry) === "*",
-	entryIdPrefix: "clickclack-user"
-};
-/**
-* Resolves whether a ClickClack message should enter the agent pipeline and
-* whether its command-style body may run tools.
-*/
-async function resolveClickClackInboundAccess(params) {
-	const runtime = getClickClackRuntime();
-	const isDirect = Boolean(params.message.direct_conversation_id);
-	const cfg = params.config;
-	const shouldCheckCommand = runtime.channel.commands.shouldComputeCommandAuthorized(params.message.body, cfg);
-	const resolved = await resolveStableChannelMessageIngress({
-		channelId: CHANNEL_ID$2,
-		accountId: params.account.accountId,
-		identity: clickClackIngressIdentity,
-		cfg,
-		subject: { stableId: params.message.author_id },
-		conversation: {
-			kind: isDirect ? "direct" : "group",
-			id: isDirect ? params.message.direct_conversation_id ?? params.message.author_id : params.message.channel_id ?? params.message.thread_root_id
-		},
-		allowFrom: params.account.allowFrom,
-		dmPolicy: "allowlist",
-		groupPolicy: "allowlist",
-		command: shouldCheckCommand ? {
-			cfg,
-			modeWhenAccessGroupsOff: "configured"
-		} : false
+/** Reserves a generation so an interrupted channel create can be adopted on retry. */
+function reserveDiscussionBindingGeneration(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	const existingAccountId = existing?.accountId ?? existing?.pending?.accountId;
+	const existingCredentialFingerprint = existing?.credentialFingerprint ?? existing?.pending?.credentialFingerprint;
+	if (existing?.destinationIdentity === params.destinationIdentity && existingAccountId === params.accountId && existingCredentialFingerprint === params.credentialFingerprint) {
+		if (!existing.accountId || !existing.credentialFingerprint) store.register(params.sessionKey, {
+			...existing,
+			accountId: params.accountId,
+			credentialFingerprint: params.credentialFingerprint
+		});
+		return existing.generation;
+	}
+	const generation = (params.createGeneration ?? randomUUID)();
+	store.register(params.sessionKey, {
+		accountId: params.accountId,
+		credentialFingerprint: params.credentialFingerprint,
+		destinationIdentity: params.destinationIdentity,
+		generation
 	});
-	return {
-		shouldDispatch: resolved.ingress.admission === "dispatch",
-		commandAuthorized: resolved.commandAccess.requested ? resolved.commandAccess.authorized : resolved.senderAccess.allowed
-	};
+	return generation;
+}
+/** Clears only the completed reservation; future opens must mint a new ownership ref. */
+function clearDiscussionBindingGeneration(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	if (!existing) return;
+	if (params.expectedGeneration && existing.generation !== params.expectedGeneration) return;
+	store.delete(params.sessionKey);
+}
+/** Quarantines a destination before the first fallible channel create. */
+function recordPendingDiscussionOpen(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	if (!existing || existing.generation !== params.generation) throw new Error("ClickClack discussion generation changed before channel creation");
+	if (existing.accountId !== params.pending.accountId || existing.credentialFingerprint !== params.pending.credentialFingerprint) throw new Error("ClickClack discussion ownership changed before channel creation");
+	store.register(params.sessionKey, {
+		...existing,
+		pending: params.pending
+	});
+}
+function listPendingDiscussionOpens(runtime) {
+	return getGenerationStore(runtime).entries().flatMap((entry) => entry.value.pending ? [{
+		sessionKey: entry.key,
+		generation: entry.value.generation,
+		...entry.value.pending
+	}] : []);
+}
+/** Stops destination-wide quarantine after the exact remote channel is known. */
+function clearPendingDiscussionOpen(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	if (!existing || existing.generation !== params.expectedGeneration || !existing.pending) return;
+	store.register(params.sessionKey, {
+		accountId: existing.accountId ?? existing.pending.accountId,
+		credentialFingerprint: existing.credentialFingerprint ?? existing.pending.credentialFingerprint,
+		destinationIdentity: existing.destinationIdentity,
+		generation: existing.generation
+	});
+}
+function hasPendingDiscussionOpenForDestination(params) {
+	const serverBaseUrl = params.serverBaseUrl.replace(/\/+$/u, "");
+	return listPendingDiscussionOpens(params.runtime).some((pending) => pending.serverBaseUrl === serverBaseUrl && pending.workspaceId === params.workspaceId);
 }
 //#endregion
-//#region extensions/clickclack/src/command-menu.ts
-const CLICKCLACK_COMMAND_PATTERN = /^[a-z0-9_-]{1,32}$/u;
-const CLICKCLACK_MAX_COMMANDS = 100;
-const CLICKCLACK_MAX_DESCRIPTION_LENGTH = 100;
-const CLICKCLACK_MAX_ARGS_HINT_LENGTH = 100;
-function truncateCodePoints(value, maxLength) {
-	return Array.from(value).slice(0, maxLength).join("");
+//#region extensions/clickclack/src/discussions/naming.ts
+function shortSessionHash(sessionKey) {
+	return createHash("sha256").update(sessionKey).digest("hex").slice(0, 32);
 }
-function commandArgsHint(spec) {
-	if (spec.args?.length) return truncateCodePoints(spec.args.map((arg) => arg.required ? `<${arg.name}>` : `[${arg.name}]`).join(" "), CLICKCLACK_MAX_ARGS_HINT_LENGTH);
-	return spec.acceptsArgs ? "[args]" : "";
+function slugifyLabel(label) {
+	return label.normalize("NFKD").replace(/[\u0300-\u036f]/gu, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 80).replace(/-+$/gu, "");
 }
-function errorStatus(error) {
-	if (!error || typeof error !== "object" || !("status" in error)) return;
-	const status = error.status;
-	return typeof status === "number" ? status : void 0;
+function fallbackDiscussionLabel(sessionKey, agentId) {
+	const agentSegment = agentId?.trim() ? slugifyLabel(agentId) : "";
+	const hash = shortSessionHash(sessionKey).slice(0, 8);
+	return `s-${agentSegment ? `${agentSegment}-` : ""}${hash}`;
 }
-function mapNativeCommandSpecsToClickClackMenu(specs, log) {
-	const commands = [];
-	const seen = /* @__PURE__ */ new Set();
-	const invalidNames = /* @__PURE__ */ new Set();
-	for (const spec of specs) {
-		if (spec.isAlias) continue;
-		const command = spec.name.trim().toLowerCase();
-		if (!CLICKCLACK_COMMAND_PATTERN.test(command)) {
-			invalidNames.add(spec.name.trim() || "<empty>");
-			continue;
-		}
-		if (seen.has(command)) continue;
-		seen.add(command);
-		const description = spec.description.trim() || command;
-		commands.push({
-			command,
-			description: truncateCodePoints(description, CLICKCLACK_MAX_DESCRIPTION_LENGTH),
-			args_hint: commandArgsHint(spec)
-		});
-	}
-	if (invalidNames.size > 0) log?.warn?.(`ClickClack command menu skipped invalid native command names: ${[...invalidNames].map((name) => JSON.stringify(name)).join(", ")}`);
-	return commands.slice(0, CLICKCLACK_MAX_COMMANDS);
+function resolveDiscussionLabel(entry, sessionKey, agentId) {
+	return entry.label?.trim() || entry.displayName?.trim() || entry.subject?.trim() || fallbackDiscussionLabel(sessionKey, agentId);
 }
-async function syncClickClackCommandMenu(params) {
-	try {
-		const commands = mapNativeCommandSpecsToClickClackMenu(listNativeCommandSpecsForConfig(params.cfg, { provider: "clickclack" }), params.log);
-		await params.client.setBotCommands(commands);
-	} catch (error) {
-		const status = errorStatus(error);
-		if (status === 403) {
-			params.log?.warn?.("ClickClack command menu sync skipped: bot token lacks commands:write");
-			return;
-		}
-		if (status === 404) {
-			params.log?.debug?.("ClickClack command menu sync skipped: server does not support /api/bots/self/commands");
-			return;
+function truncateDiscussionDisplayTitle(label) {
+	return Array.from(label).slice(0, 200).join("").trim();
+}
+function slugifyDiscussionLabel(label, sessionKey) {
+	return slugifyLabel(label) || fallbackDiscussionLabel(sessionKey);
+}
+function discussionSessionPeerId(identity) {
+	return `disc-${createHash("sha256").update([
+		identity.mainSessionKey,
+		identity.sessionId,
+		identity.serverBaseUrl,
+		identity.channelId,
+		identity.externalRef
+	].join("\0")).digest("hex").slice(0, 32)}`;
+}
+function isDiscussionSessionKey(sessionKey) {
+	return sessionKey.includes(":clickclack:") && /:channel:disc-[0-9a-f]{32}$/u.test(sessionKey);
+}
+function discussionExternalRef(installationId, mainSessionKey, destinationIdentity, bindingGeneration) {
+	return `openclaw:${installationId}:${shortSessionHash([
+		mainSessionKey,
+		destinationIdentity,
+		bindingGeneration
+	].join("\0"))}`;
+}
+function discussionCredentialFingerprint(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+function discussionSessionKey(params) {
+	return params.runtime.channel.routing.buildAgentSessionKey({
+		agentId: params.agentId,
+		channel: "clickclack",
+		accountId: params.accountId,
+		peer: {
+			kind: "channel",
+			id: discussionSessionPeerId(params)
 		}
-		params.log?.warn?.(`ClickClack command menu sync failed: ${formatErrorMessage(error)}`);
-	}
+	});
 }
 //#endregion
-//#region extensions/clickclack/src/activity.ts
+//#region extensions/clickclack/src/discussions/binding-store.ts
+function bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
+	const entry = runtime.agent.session.getSessionEntry({
+		sessionKey,
+		readConsistency: "latest"
+	});
+	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId && entry.archivedAt === void 0);
+}
 /**
-* Publishes agent activity (streamed commentary + tool progress) into
-* ClickClack as durable `agent_commentary` / `agent_tool` message rows,
-* coalesced so one logical step becomes one row instead of a row per frame.
-*
-* Ported from the clickglass agent-bridge sidecar, adapted from gateway
-* websocket frames to the in-process `replyOptions.onItemEvent` seam:
-*
-* - Commentary/reasoning arrives as cumulative text snapshots per item id.
-*   Each segment becomes one durable row: POSTed when the segment starts
-*   streaming and PATCHed (debounced) as the snapshot grows, so prose
-*   interleaves chronologically with tool rows.
-* - Tool/step items can emit several frames (start/update/complete) for the
-*   same call, sometimes with lane-prefixed ids (`tool:X`, `command:X`).
-*   Normalize the prefix away to one key per call, POST one row on the first
-*   frame, and PATCH it when a later frame carries a strictly longer body.
+* 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.
 */
-/** Debounce window for PATCHing streaming commentary snapshots. */
-const CLICKCLACK_COMMENTARY_FLUSH_MS = 700;
-/** Item kinds rendered as agent_tool rows; everything else is commentary. */
-const TOOL_ITEM_KINDS = /* @__PURE__ */ new Set([
-	"tool",
-	"command",
-	"command_output",
-	"patch",
-	"search",
-	"api"
-]);
-/** Item kinds that never become durable rows (ephemeral or plumbing lanes). */
-const SKIPPED_ITEM_KINDS = /* @__PURE__ */ new Set(["lifecycle"]);
-/** Item kinds emitted as cumulative commentary snapshots. */
-const STREAMING_COMMENTARY_ITEM_KINDS = /* @__PURE__ */ new Set([
-	"preamble",
-	"commentary",
-	"analysis",
-	"thinking",
-	"reasoning"
-]);
-/** Provider-specific reasoning lanes normalized into one ClickClack label. */
-const THINKING_ITEM_KINDS = /* @__PURE__ */ new Set([
-	"analysis",
-	"thinking",
-	"reasoning"
-]);
-function normalizedItemKind(payload) {
-	return payload.kind?.trim().toLowerCase() ?? "";
-}
-function commentaryBody(payload) {
-	const text = payload.progressText?.trim() || payload.summary?.trim() || payload.meta?.trim() || "";
-	if (!text) return "";
-	const kind = normalizedItemKind(payload);
-	if (THINKING_ITEM_KINDS.has(kind)) return `**Thinking**\n\n${text}`;
-	return text;
+function attachBindingToCurrentActiveSession(params) {
+	const entry = params.runtime.agent.session.getSessionEntry({
+		sessionKey: params.sessionKey,
+		readConsistency: "latest"
+	});
+	if (!entry?.sessionId || entry.archivedAt !== void 0) return;
+	if (entry.sessionId === params.binding.sessionId) {
+		if (params.binding.detachedAt === void 0) return params.binding;
+		const { detachedAt: _detachedAt, ...attached } = params.binding;
+		params.store.set(params.sessionKey, attached);
+		return attached;
+	}
+	const { detachedAt: _detachedAt, ...retained } = params.binding;
+	const attached = {
+		...retained,
+		sessionId: entry.sessionId
+	};
+	params.store.set(params.sessionKey, attached);
+	return attached;
 }
-function activityBody(payload) {
-	const line = buildChannelProgressDraftLine({
-		event: "item",
-		itemId: payload.itemId,
-		toolCallId: payload.toolCallId,
-		itemKind: payload.kind,
-		title: payload.title,
-		name: payload.name,
-		phase: payload.phase,
-		status: payload.status,
-		summary: payload.summary,
-		progressText: payload.progressText,
-		meta: payload.meta
-	})?.text?.trim();
-	if (line) return line;
-	const head = payload.name?.trim() || payload.title?.trim();
-	const text = payload.progressText?.trim() || payload.summary?.trim();
-	if (head && text) return `**${head}**\n\n${text}`;
-	if (text) return text;
-	if (head) return head;
-	return payload.status?.trim() || payload.kind?.trim() || "";
+const DISCUSSION_BINDINGS_NAMESPACE = "discussion-bindings";
+const MAX_DISCUSSION_BINDINGS = 1e4;
+const MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS = 1e3;
+const storesByRuntime$1 = /* @__PURE__ */ new WeakMap();
+function channelKey(serverBaseUrl, channelId) {
+	return `${serverBaseUrl.replace(/\/+$/u, "")}\0${channelId}`;
 }
-/**
-* Creates a per-turn activity publisher. Publishing is best-effort: transport
-* failures are reported through `onError` and never interrupt the reply turn.
-*/
-function createClickClackActivityPublisher(params) {
-	const flushMs = params.flushMs ?? CLICKCLACK_COMMENTARY_FLUSH_MS;
-	const commentaryByItem = /* @__PURE__ */ new Map();
-	const toolRows = /* @__PURE__ */ new Map();
-	let provenance;
-	let chain = Promise.resolve();
-	const enqueue = (work) => {
-		chain = chain.then(work).catch((error) => {
-			params.onError?.(error);
+/** SQLite-backed session/channel bindings with a process-local inbound lookup index. */
+var ClickClackDiscussionBindingStore = class {
+	#store;
+	#sessionByChannel = /* @__PURE__ */ new Map();
+	#mainByDiscussionSession = /* @__PURE__ */ new Map();
+	#detachedAtBySession = /* @__PURE__ */ new Map();
+	#runtime;
+	constructor(runtime) {
+		this.#runtime = runtime;
+		this.#store = runtime.state.openSyncKeyedStore({
+			namespace: DISCUSSION_BINDINGS_NAMESPACE,
+			maxEntries: MAX_DISCUSSION_BINDINGS,
+			overflowPolicy: "reject-new"
 		});
-		return chain;
-	};
-	const postRow = (kind, body) => params.client.createActivityMessage({
-		channelId: params.target.channelId,
-		conversationId: params.target.conversationId,
-		body,
-		kind,
-		turnId: params.turnId,
-		provenance
-	});
-	const flushCommentary = (segmentKey) => {
-		const segment = commentaryByItem.get(segmentKey);
-		if (!segment) return Promise.resolve();
-		if (segment.timer) {
-			clearTimeout(segment.timer);
-			segment.timer = void 0;
+		for (const entry of this.#store.entries()) this.#index(entry.key, entry.value);
+	}
+	get(sessionKey) {
+		return this.#store.lookup(sessionKey);
+	}
+	hasCapacity(sessionKey) {
+		return this.get(sessionKey) !== void 0 || this.#store.entries().length < MAX_DISCUSSION_BINDINGS;
+	}
+	getByChannel(serverBaseUrl, channelId) {
+		const key = channelKey(serverBaseUrl, channelId);
+		const sessionKey = this.#sessionByChannel.get(key);
+		if (!sessionKey) return;
+		const binding = this.get(sessionKey);
+		if (!binding) {
+			this.#sessionByChannel.delete(key);
+			return;
 		}
-		if (!segment.dirty || !segment.body.trim()) return Promise.resolve();
-		segment.dirty = false;
-		const body = segment.body;
-		return enqueue(async () => {
-			if (segment.messageId) {
-				await params.client.updateMessageBody(segment.messageId, body);
-				return;
-			}
-			const posted = await postRow("agent_commentary", body);
-			segment.messageId = posted.id;
-		});
-	};
-	const flushAllCommentary = () => {
-		const flushes = [...commentaryByItem.keys()].map((key) => flushCommentary(key));
-		return Promise.all(flushes).then(() => void 0);
-	};
-	const handleCommentary = (payload) => {
-		const body = commentaryBody(payload);
-		if (!body.trim()) return;
-		const key = payload.itemId?.trim() || "turn";
-		let segment = commentaryByItem.get(key);
-		if (!segment) {
-			segment = {
-				body: "",
-				dirty: false
-			};
-			commentaryByItem.set(key, segment);
+		return {
+			sessionKey,
+			binding
+		};
+	}
+	set(sessionKey, binding) {
+		const previous = this.get(sessionKey);
+		this.#store.register(sessionKey, binding);
+		if (previous) this.#unindex(sessionKey, previous);
+		this.#index(sessionKey, binding);
+	}
+	delete(sessionKey) {
+		const previous = this.get(sessionKey);
+		const deleted = this.#store.delete(sessionKey);
+		if (deleted && previous) this.#unindex(sessionKey, previous);
+		return deleted;
+	}
+	getByDiscussionSession(sideSessionKey) {
+		const sessionKey = this.#mainByDiscussionSession.get(sideSessionKey);
+		if (!sessionKey) return;
+		const binding = this.get(sessionKey);
+		return binding ? {
+			sessionKey,
+			binding
+		} : void 0;
+	}
+	entries() {
+		return this.#store.entries().map((entry) => ({
+			sessionKey: entry.key,
+			binding: entry.value
+		}));
+	}
+	detachedCount() {
+		return this.#detachedAtBySession.size;
+	}
+	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)) {
+			oldestSessionKey = sessionKey;
+			oldestDetachedAt = detachedAt;
 		}
-		if (body.length < segment.body.length || body === segment.body) return;
-		segment.body = body;
-		segment.dirty = true;
-		if (!segment.timer) segment.timer = setTimeout(() => {
-			segment.timer = void 0;
-			flushCommentary(key);
-		}, flushMs);
-	};
-	const toolRowKey = (payload) => {
-		const toolCallId = payload.toolCallId?.trim();
-		if (toolCallId) return toolCallId;
-		return (payload.itemId?.trim() ?? "").replace(/^(tool|command):/, "");
-	};
-	const handleDiscreteItem = (payload) => {
-		const body = activityBody(payload);
-		if (!body) return;
-		const kind = TOOL_ITEM_KINDS.has(payload.kind?.trim().toLowerCase() ?? "") ? "agent_tool" : "agent_commentary";
-		flushAllCommentary();
-		const key = `${kind}:${toolRowKey(payload)}`;
-		const existing = toolRows.get(key);
-		if (!existing || !toolRowKey(payload)) {
-			const row = { body };
-			if (toolRowKey(payload)) toolRows.set(key, row);
-			enqueue(async () => {
-				const posted = await postRow(kind, row.body);
-				row.messageId = posted.id;
-				row.sentBody = row.body;
-			});
-			return;
+		if (!oldestSessionKey) return;
+		const binding = this.get(oldestSessionKey);
+		if (!binding || binding.detachedAt === void 0) {
+			this.#detachedAtBySession.delete(oldestSessionKey);
+			return this.oldestDetached();
 		}
-		if (body.length <= existing.body.length) return;
-		existing.body = body;
-		enqueue(async () => {
-			if (existing.messageId && existing.body !== existing.sentBody) {
-				await params.client.updateMessageBody(existing.messageId, existing.body);
-				existing.sentBody = existing.body;
-			}
+		return {
+			sessionKey: oldestSessionKey,
+			binding
+		};
+	}
+	#index(sessionKey, binding) {
+		this.#sessionByChannel.set(channelKey(binding.serverBaseUrl, binding.channelId), sessionKey);
+		const sideSessionKey = discussionSessionKey({
+			runtime: this.#runtime,
+			agentId: binding.agentId,
+			mainSessionKey: sessionKey,
+			sessionId: binding.sessionId,
+			accountId: binding.accountId,
+			serverBaseUrl: binding.serverBaseUrl,
+			channelId: binding.channelId,
+			externalRef: binding.externalRef
+		});
+		if (sideSessionKey) this.#mainByDiscussionSession.set(sideSessionKey, sessionKey);
+		if (binding.detachedAt !== void 0) this.#detachedAtBySession.set(sessionKey, binding.detachedAt);
+	}
+	#unindex(sessionKey, binding) {
+		this.#sessionByChannel.delete(channelKey(binding.serverBaseUrl, binding.channelId));
+		const sideSessionKey = discussionSessionKey({
+			runtime: this.#runtime,
+			agentId: binding.agentId,
+			mainSessionKey: sessionKey,
+			sessionId: binding.sessionId,
+			accountId: binding.accountId,
+			serverBaseUrl: binding.serverBaseUrl,
+			channelId: binding.channelId,
+			externalRef: binding.externalRef
 		});
+		if (sideSessionKey) this.#mainByDiscussionSession.delete(sideSessionKey);
+		this.#detachedAtBySession.delete(sessionKey);
+	}
+};
+function getClickClackDiscussionBindingStore(runtime) {
+	const existing = storesByRuntime$1.get(runtime);
+	if (existing) return existing;
+	const created = new ClickClackDiscussionBindingStore(runtime);
+	storesByRuntime$1.set(runtime, created);
+	return created;
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/eligibility.ts
+function discussionAccounts(cfg) {
+	return listEnabledClickClackAccounts(cfg).filter((account) => account.configured && account.discussions.enabled);
+}
+function normalizedServerBaseUrl(account) {
+	return account.baseUrl.replace(/\/+$/u, "");
+}
+/** Resolves the sole live account and rejects bindings pinned to an older destination. */
+function resolveDiscussionBindingAccount(cfg, binding) {
+	const accounts = discussionAccounts(cfg);
+	if (accounts.length !== 1) return { state: "unavailable" };
+	const account = accounts[0];
+	if (!account) return { state: "unavailable" };
+	if (account.accountId !== binding.accountId || normalizedServerBaseUrl(account) !== binding.serverBaseUrl || account.discussions.workspace !== binding.workspaceRef || binding.credentialFingerprint !== void 0 && discussionCredentialFingerprint(account.token) !== binding.credentialFingerprint) return {
+		state: "stale",
+		account
 	};
 	return {
-		onItemEvent: (payload) => {
-			const kind = normalizedItemKind(payload);
-			if (STREAMING_COMMENTARY_ITEM_KINDS.has(kind)) {
-				handleCommentary(payload);
-				return;
-			}
-			if (SKIPPED_ITEM_KINDS.has(kind)) return;
-			handleDiscreteItem(payload);
-		},
-		setProvenance: (next) => {
-			provenance = next;
-		},
-		finalize: async () => {
-			await flushAllCommentary();
-			await chain;
-		}
+		state: "active",
+		account
+	};
+}
+/** Public embed/open URLs for one bound discussion channel. */
+function discussionInfoForBinding(binding, account) {
+	const baseUrl = normalizedServerBaseUrl(account);
+	return {
+		state: "open",
+		embedUrl: `${baseUrl}/embed/channel/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}?openclawHostTheme=1`,
+		openUrl: `${baseUrl}/app/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}`
 	};
 }
 //#endregion
-//#region extensions/clickclack/src/discussions/binding-generation.ts
-const DISCUSSION_GENERATIONS_NAMESPACE = "discussion-binding-generations";
-const MAX_PENDING_DISCUSSION_GENERATIONS = 1e4;
-const storesByRuntime$2 = /* @__PURE__ */ new WeakMap();
-function getGenerationStore(runtime) {
-	const existing = storesByRuntime$2.get(runtime);
+//#region extensions/clickclack/src/discussions/revoked-channel-store.ts
+const REVOKED_CHANNELS_NAMESPACE = "discussion-revoked-channels";
+const MAX_REVOKED_CHANNELS = 1e5;
+const storesByRuntime = /* @__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: DISCUSSION_GENERATIONS_NAMESPACE,
-		maxEntries: MAX_PENDING_DISCUSSION_GENERATIONS,
+		namespace: REVOKED_CHANNELS_NAMESPACE,
+		maxEntries: MAX_REVOKED_CHANNELS,
 		overflowPolicy: "reject-new"
 	});
-	storesByRuntime$2.set(runtime, created);
+	storesByRuntime.set(runtime, created);
 	return created;
 }
-/** Reserves a generation so an interrupted channel create can be adopted on retry. */
-function reserveDiscussionBindingGeneration(params) {
-	const store = getGenerationStore(params.runtime);
-	const existing = store.lookup(params.sessionKey);
-	if (existing?.destinationIdentity === params.destinationIdentity) return existing.generation;
-	const generation = (params.createGeneration ?? randomUUID)();
-	store.register(params.sessionKey, {
-		destinationIdentity: params.destinationIdentity,
-		generation
-	});
-	return generation;
-}
-/** Clears only the completed reservation; future opens must mint a new ownership ref. */
-function clearDiscussionBindingGeneration(params) {
-	const store = getGenerationStore(params.runtime);
-	const existing = store.lookup(params.sessionKey);
-	if (!existing) return;
-	if (params.expectedGeneration && existing.generation !== params.expectedGeneration) return;
-	store.delete(params.sessionKey);
+/** Records managed ownership before its live binding is released. */
+function markClickClackDiscussionChannelRevoked(runtime, binding) {
+	const value = {
+		accountId: binding.accountId,
+		serverBaseUrl: binding.serverBaseUrl,
+		channelId: binding.channelId,
+		revokedAt: Date.now()
+	};
+	getStore(runtime).register(revokedChannelKey(value), value);
 }
-/** Quarantines a destination before the first fallible channel create. */
-function recordPendingDiscussionOpen(params) {
-	const store = getGenerationStore(params.runtime);
-	const existing = store.lookup(params.sessionKey);
-	if (!existing || existing.generation !== params.generation) throw new Error("ClickClack discussion generation changed before channel creation");
-	store.register(params.sessionKey, {
-		...existing,
-		pending: params.pending
-	});
+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);
 }
-function listPendingDiscussionOpens(runtime) {
-	return getGenerationStore(runtime).entries().flatMap((entry) => entry.value.pending ? [{
-		sessionKey: entry.key,
-		generation: entry.value.generation,
-		...entry.value.pending
-	}] : []);
+function clearClickClackDiscussionChannelRevoked(params) {
+	getStore(params.runtime).delete(revokedChannelKey(params));
 }
-function hasPendingDiscussionOpenForDestination(params) {
-	const serverBaseUrl = params.serverBaseUrl.replace(/\/+$/u, "");
-	return listPendingDiscussionOpens(params.runtime).some((pending) => pending.serverBaseUrl === serverBaseUrl && pending.workspaceId === params.workspaceId);
+/** Distinguishes a released managed channel from a genuinely ordinary channel. */
+function isClickClackDiscussionChannelRevoked(params) {
+	return Boolean(getStore(params.runtime).lookup(revokedChannelKey(params)));
 }
 //#endregion
-//#region extensions/clickclack/src/discussions/naming.ts
-function shortSessionHash(sessionKey) {
-	return createHash("sha256").update(sessionKey).digest("hex").slice(0, 32);
-}
-function slugifyLabel(label) {
-	return label.normalize("NFKD").replace(/[\u0300-\u036f]/gu, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 80).replace(/-+$/gu, "");
+//#region extensions/clickclack/src/discussions/routing.ts
+function resolveClickClackDiscussionRoute(params) {
+	if (isClickClackDiscussionChannelRevoked(params)) return { state: "revoked" };
+	const store = getClickClackDiscussionBindingStore(params.runtime);
+	const matched = store.getByChannel(params.serverBaseUrl, params.channelId);
+	if (!matched) return { state: hasPendingDiscussionOpenForDestination(params) ? "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.config, matched.binding).state !== "active") return { state: "revoked" };
+	let binding;
+	try {
+		binding = 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 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(" ")
+		}
+	};
 }
-function fallbackDiscussionLabel(sessionKey, agentId) {
-	const agentSegment = agentId?.trim() ? slugifyLabel(agentId) : "";
-	const hash = shortSessionHash(sessionKey).slice(0, 8);
-	return `s-${agentSegment ? `${agentSegment}-` : ""}${hash}`;
+//#endregion
+//#region extensions/clickclack/src/group-policy.ts
+/**
+* Resolves bot-authored message policy using the same exact, wildcard, and
+* account-level precedence as mention gating.
+*/
+function resolveClickClackBotPolicy(params) {
+	const { account, channelId } = params;
+	const channelKey = channelId?.trim();
+	const groups = channelKey ? account.groups : void 0;
+	const wildcard = groups?.["*"];
+	const exact = channelKey ? groups?.[channelKey] : void 0;
+	return {
+		allowBots: exact?.allowBots ?? wildcard?.allowBots ?? account.allowBots ?? false,
+		botLoopProtection: mergePairLoopGuardConfig(account.botLoopProtection, wildcard?.botLoopProtection, exact?.botLoopProtection)
+	};
 }
-function resolveDiscussionLabel(entry, sessionKey, agentId) {
-	return entry.label?.trim() || entry.displayName?.trim() || entry.subject?.trim() || fallbackDiscussionLabel(sessionKey, agentId);
+/**
+* Resolves the effective group policy for a ClickClack channel.
+*
+* Lookup order:
+*  1. Exact channel ID in `groups`
+*  2. Wildcard `'*'` entry in `groups`
+*  3. Account-level `requireMention` / `mentionPatterns`
+*  4. Backward-compatible default: { requireMention: false, mentionPatterns: [] }
+*/
+function resolveClickClackGroupPolicy(params) {
+	const { account, channelId } = params;
+	const accountPolicy = {
+		requireMention: account.requireMention === true,
+		mentionPatterns: account.mentionPatterns ?? []
+	};
+	const channelKey = channelId?.trim();
+	const groups = channelKey ? account.groups : void 0;
+	const wildcard = groups?.["*"];
+	const exact = channelKey ? groups?.[channelKey] : void 0;
+	return {
+		requireMention: exact?.requireMention ?? wildcard?.requireMention ?? accountPolicy.requireMention,
+		mentionPatterns: exact?.mentionPatterns ?? wildcard?.mentionPatterns ?? accountPolicy.mentionPatterns
+	};
 }
-function truncateDiscussionDisplayTitle(label) {
-	return Array.from(label).slice(0, 200).join("").trim();
+//#endregion
+//#region extensions/clickclack/src/mention-facts.ts
+/**
+* Detects whether a ClickClack group message contains a direct mention of the
+* current account.
+*
+* Pure helper – no side effects, no runtime imports.
+*/
+const CLICKCLACK_MENTION_PATTERN = /(?:^|[^a-z0-9_@-])@([a-z0-9][a-z0-9_-]{1,31})(?![a-z0-9_-])/giu;
+function buildLocalMentionRegexes(params) {
+	if (params.mentionPatterns.length === 0) return [];
+	const cfg = params.cfg;
+	return buildMentionRegexes({
+		...cfg,
+		messages: {
+			...cfg?.messages,
+			groupChat: {
+				...cfg?.messages?.groupChat,
+				mentionPatterns: params.mentionPatterns
+			}
+		}
+	}, void 0, {
+		provider: "clickclack",
+		conversationId: params.channelId
+	});
 }
-function slugifyDiscussionLabel(label, sessionKey) {
-	return slugifyLabel(label) || fallbackDiscussionLabel(sessionKey);
+function resolveMentionHandles(body) {
+	return [...body.matchAll(CLICKCLACK_MENTION_PATTERN)].map((match) => match[1]?.toLowerCase()).filter((handle) => Boolean(handle));
 }
-function discussionSessionPeerId(identity) {
-	return `disc-${createHash("sha256").update([
-		identity.mainSessionKey,
-		identity.sessionId,
-		identity.serverBaseUrl,
-		identity.channelId,
-		identity.externalRef
-	].join("\0")).digest("hex").slice(0, 32)}`;
+/**
+* Builds mention facts for a ClickClack message.
+*
+* Rules:
+* - DMs always have canDetectMention: false, wasMentioned: false
+*   (DMs bypass mention gating).
+* - Group messages: canDetectMention: true when body text is available.
+* - Checks the message body against shared and account-local mention patterns.
+* - If botHandle is provided and the message body contains its ClickClack
+*   `@handle`, treat it as a mention.
+* - Plain display names do not count unless explicitly configured as a pattern.
+*/
+function resolveClickClackMentionFacts(params) {
+	const { isDirect, body, mentionPatterns, botHandle, cfg, agentId, channelId } = params;
+	if (isDirect) return {
+		canDetectMention: false,
+		wasMentioned: false
+	};
+	if (!body) return {
+		canDetectMention: true,
+		wasMentioned: false,
+		hasAnyMention: false
+	};
+	const sharedMentionRegexes = buildMentionRegexes(cfg, agentId, {
+		provider: "clickclack",
+		conversationId: channelId
+	});
+	const localMentionRegexes = buildLocalMentionRegexes({
+		cfg,
+		mentionPatterns,
+		channelId
+	});
+	const mentionRegexes = [...sharedMentionRegexes, ...localMentionRegexes];
+	const bodyForRegex = normalizeMentionText(body);
+	const hasConfiguredMention = mentionRegexes.some((regex) => regex.test(bodyForRegex));
+	const mentionHandles = resolveMentionHandles(body);
+	const normalizedBotHandle = botHandle?.replace(/^@/u, "").trim().toLowerCase();
+	return {
+		canDetectMention: true,
+		wasMentioned: (normalizedBotHandle ? mentionHandles.includes(normalizedBotHandle) : false) || hasConfiguredMention,
+		hasAnyMention: mentionHandles.length > 0 || hasConfiguredMention
+	};
 }
-function isDiscussionSessionKey(sessionKey) {
-	return sessionKey.includes(":clickclack:") && /:channel:disc-[0-9a-f]{32}$/u.test(sessionKey);
+//#endregion
+//#region extensions/clickclack/src/runtime.ts
+/**
+* Runtime store for host-provided OpenClaw services used by the ClickClack
+* bundled plugin.
+*/
+const { setRuntime: setClickClackRuntime, getRuntime: getClickClackRuntime } = createPluginRuntimeStore({
+	pluginId: "clickclack",
+	errorMessage: "ClickClack runtime not initialized"
+});
+//#endregion
+//#region extensions/clickclack/src/target.ts
+/**
+* Parses `channel:name`, `thread:msg_id`, `dm:usr_id`, or a bare channel name.
+*/
+function parseClickClackTarget(raw) {
+	const value = raw.trim();
+	if (!value) throw new Error("ClickClack target is required");
+	const [prefix, ...rest] = value.split(":");
+	const body = rest.join(":").trim();
+	if (prefix === "channel" && body) return {
+		chatType: "group",
+		kind: "channel",
+		id: body
+	};
+	if (prefix === "thread" && body) return {
+		chatType: "group",
+		kind: "thread",
+		id: body
+	};
+	if (prefix === "dm" && body) return {
+		chatType: "direct",
+		kind: "dm",
+		id: body
+	};
+	if (!body) return {
+		chatType: "group",
+		kind: "channel",
+		id: value
+	};
+	throw new Error(`Unsupported ClickClack target: ${raw}`);
 }
-function discussionExternalRef(installationId, mainSessionKey, sessionId, destinationIdentity, bindingGeneration) {
-	return `openclaw:${installationId}:${shortSessionHash([
-		mainSessionKey,
-		sessionId,
-		destinationIdentity,
-		bindingGeneration
-	].join("\0"))}`;
+/** Formats a parsed ClickClack target back into canonical target syntax. */
+function buildClickClackTarget(target) {
+	return `${target.kind}:${target.id}`;
 }
-function discussionCredentialFingerprint(token) {
-	return createHash("sha256").update(token).digest("hex");
+/** Normalizes user-entered ClickClack target text for channel routing. */
+function normalizeClickClackTarget(raw) {
+	return buildClickClackTarget(parseClickClackTarget(raw));
 }
-function discussionSessionKey(params) {
-	return params.runtime.channel.routing.buildAgentSessionKey({
-		agentId: params.agentId,
-		channel: "clickclack",
-		accountId: params.accountId,
-		peer: {
-			kind: "channel",
-			id: discussionSessionPeerId(params)
-		}
-	});
+/** Reports whether a target string can be offered to the ClickClack parser. */
+function looksLikeClickClackTarget(raw) {
+	return /^(channel|thread|dm):/i.test(raw.trim()) || raw.trim().length > 0;
 }
 //#endregion
-//#region extensions/clickclack/src/discussions/binding-store.ts
-function bindingMatchesSessionIncarnation(runtime, sessionKey, binding) {
-	const entry = runtime.agent.session.getSessionEntry({
-		sessionKey,
-		readConsistency: "latest"
-	});
-	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId);
-}
-function bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
-	const entry = runtime.agent.session.getSessionEntry({
-		sessionKey,
-		readConsistency: "latest"
-	});
-	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId && entry.archivedAt === void 0);
-}
-const DISCUSSION_BINDINGS_NAMESPACE = "discussion-bindings";
-const MAX_DISCUSSION_BINDINGS = 1e4;
-const storesByRuntime$1 = /* @__PURE__ */ new WeakMap();
-function channelKey(serverBaseUrl, channelId) {
-	return `${serverBaseUrl.replace(/\/+$/u, "")}\0${channelId}`;
+//#region extensions/clickclack/src/access.ts
+/**
+* Maps ClickClack senders and conversations onto the shared channel ingress
+* allowlist/command authorization contract.
+*/
+const CHANNEL_ID$2 = "clickclack";
+function normalizeClickClackUserId(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	const withoutProvider = trimmed.replace(/^(clickclack|cc):/i, "").trim();
+	return withoutProvider.match(/^dm:(.+)$/i)?.[1]?.trim() || withoutProvider || null;
 }
-/** SQLite-backed session/channel bindings with a process-local inbound lookup index. */
-var ClickClackDiscussionBindingStore = class {
-	#store;
-	#sessionByChannel = /* @__PURE__ */ new Map();
-	#mainByDiscussionSession = /* @__PURE__ */ new Map();
-	#runtime;
-	constructor(runtime) {
-		this.#runtime = runtime;
-		this.#store = runtime.state.openSyncKeyedStore({
-			namespace: DISCUSSION_BINDINGS_NAMESPACE,
-			maxEntries: MAX_DISCUSSION_BINDINGS,
-			overflowPolicy: "reject-new"
-		});
-		for (const entry of this.#store.entries()) this.#index(entry.key, entry.value);
-	}
-	get(sessionKey) {
-		return this.#store.lookup(sessionKey);
-	}
-	hasCapacity(sessionKey) {
-		return this.get(sessionKey) !== void 0 || this.#store.entries().length < MAX_DISCUSSION_BINDINGS;
-	}
-	getByChannel(serverBaseUrl, channelId) {
-		const key = channelKey(serverBaseUrl, channelId);
-		const sessionKey = this.#sessionByChannel.get(key);
-		if (!sessionKey) return;
-		const binding = this.get(sessionKey);
-		if (!binding) {
-			this.#sessionByChannel.delete(key);
-			return;
-		}
-		return {
-			sessionKey,
-			binding
-		};
-	}
-	set(sessionKey, binding) {
-		const previous = this.get(sessionKey);
-		this.#store.register(sessionKey, binding);
-		if (previous) this.#unindex(sessionKey, previous);
-		this.#index(sessionKey, binding);
-	}
-	delete(sessionKey) {
-		const previous = this.get(sessionKey);
-		const deleted = this.#store.delete(sessionKey);
-		if (deleted && previous) this.#unindex(sessionKey, previous);
-		return deleted;
-	}
-	getByDiscussionSession(sideSessionKey) {
-		const sessionKey = this.#mainByDiscussionSession.get(sideSessionKey);
-		if (!sessionKey) return;
-		const binding = this.get(sessionKey);
-		return binding ? {
-			sessionKey,
-			binding
-		} : void 0;
-	}
-	entries() {
-		return this.#store.entries().map((entry) => ({
-			sessionKey: entry.key,
-			binding: entry.value
-		}));
-	}
-	#index(sessionKey, binding) {
-		this.#sessionByChannel.set(channelKey(binding.serverBaseUrl, binding.channelId), sessionKey);
-		const sideSessionKey = discussionSessionKey({
-			runtime: this.#runtime,
-			agentId: binding.agentId,
-			mainSessionKey: sessionKey,
-			sessionId: binding.sessionId,
-			accountId: binding.accountId,
-			serverBaseUrl: binding.serverBaseUrl,
-			channelId: binding.channelId,
-			externalRef: binding.externalRef
-		});
-		if (sideSessionKey) this.#mainByDiscussionSession.set(sideSessionKey, sessionKey);
-	}
-	#unindex(sessionKey, binding) {
-		this.#sessionByChannel.delete(channelKey(binding.serverBaseUrl, binding.channelId));
-		const sideSessionKey = discussionSessionKey({
-			runtime: this.#runtime,
-			agentId: binding.agentId,
-			mainSessionKey: sessionKey,
-			sessionId: binding.sessionId,
-			accountId: binding.accountId,
-			serverBaseUrl: binding.serverBaseUrl,
-			channelId: binding.channelId,
-			externalRef: binding.externalRef
-		});
-		if (sideSessionKey) this.#mainByDiscussionSession.delete(sideSessionKey);
-	}
+const clickClackIngressIdentity = {
+	key: "user-id",
+	normalizeEntry: normalizeClickClackUserId,
+	normalizeSubject: normalizeClickClackUserId,
+	isWildcardEntry: (entry) => normalizeClickClackUserId(entry) === "*",
+	entryIdPrefix: "clickclack-user"
 };
-function getClickClackDiscussionBindingStore(runtime) {
-	const existing = storesByRuntime$1.get(runtime);
-	if (existing) return existing;
-	const created = new ClickClackDiscussionBindingStore(runtime);
-	storesByRuntime$1.set(runtime, created);
-	return created;
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/eligibility.ts
-function discussionAccounts(cfg) {
-	return listEnabledClickClackAccounts(cfg).filter((account) => account.configured && account.discussions.enabled);
-}
-function normalizedServerBaseUrl(account) {
-	return account.baseUrl.replace(/\/+$/u, "");
+function resolveClickClackBotLoopConversationId(params) {
+	if (params.message.parent_message_id && params.message.thread_root_id) return params.message.thread_root_id;
+	return params.isDirect ? params.message.direct_conversation_id ?? params.message.author_id : params.message.channel_id ?? params.message.thread_root_id ?? params.message.author_id;
 }
-/** Resolves the sole live account and rejects bindings pinned to an older destination. */
-function resolveDiscussionBindingAccount(cfg, binding) {
-	const accounts = discussionAccounts(cfg);
-	if (accounts.length !== 1) return { state: "unavailable" };
-	const account = accounts[0];
-	if (!account) return { state: "unavailable" };
-	if (account.accountId !== binding.accountId || normalizedServerBaseUrl(account) !== binding.serverBaseUrl || account.discussions.workspace !== binding.workspaceRef || binding.credentialFingerprint !== void 0 && discussionCredentialFingerprint(account.token) !== binding.credentialFingerprint) return {
-		state: "stale",
-		account
+function resolveAccountAgentRoute(params) {
+	const runtime = getClickClackRuntime();
+	const peer = {
+		kind: params.isDirect ? "direct" : "channel",
+		id: params.target
+	};
+	const route = runtime.channel.routing.resolveAgentRoute({
+		cfg: params.cfg,
+		channel: CHANNEL_ID$2,
+		accountId: params.account.accountId,
+		peer
+	});
+	const agentId = normalizeAgentId(params.account.agentId ?? route.agentId);
+	if (agentId === route.agentId) return route;
+	const dmScope = params.cfg.session?.dmScope ?? "main";
+	const sessionKey = runtime.channel.routing.buildAgentSessionKey({
+		agentId,
+		mainKey: params.cfg.session?.mainKey,
+		channel: CHANNEL_ID$2,
+		accountId: params.account.accountId,
+		peer,
+		dmScope,
+		identityLinks: params.cfg.session?.identityLinks
+	});
+	const mainSessionKey = runtime.channel.routing.buildAgentSessionKey({
+		agentId,
+		mainKey: params.cfg.session?.mainKey,
+		channel: CHANNEL_ID$2,
+		accountId: params.account.accountId,
+		dmScope: "main"
+	});
+	return {
+		...route,
+		agentId,
+		dmScope,
+		sessionKey,
+		mainSessionKey,
+		lastRoutePolicy: sessionKey === mainSessionKey ? "main" : "session"
 	};
+}
+function resolvePreparedInboundRoute(params) {
+	const runtime = getClickClackRuntime();
+	const isDirect = Boolean(params.message.direct_conversation_id);
+	const target = buildClickClackTarget(isDirect ? {
+		chatType: "direct",
+		kind: "dm",
+		id: params.message.author_id
+	} : {
+		chatType: "group",
+		kind: "channel",
+		id: params.message.channel_id ?? ""
+	});
+	const accountRoute = resolveAccountAgentRoute({
+		cfg: params.config,
+		account: params.account,
+		target,
+		isDirect
+	});
+	const discussionResolution = !isDirect && params.message.channel_id ? resolveClickClackDiscussionRoute({
+		runtime,
+		config: params.config,
+		accountId: params.account.accountId,
+		serverBaseUrl: params.account.baseUrl,
+		workspaceId: params.message.workspace_id,
+		channelId: params.message.channel_id
+	}) : { state: "unbound" };
+	const discussionRoute = discussionResolution.state === "active" ? discussionResolution.route : void 0;
 	return {
-		state: "active",
-		account
+		isDirect,
+		target,
+		route: discussionRoute ? {
+			...accountRoute,
+			agentId: discussionRoute.agentId,
+			sessionKey: discussionRoute.sessionKey,
+			lastRoutePolicy: "session"
+		} : accountRoute,
+		discussionRoute,
+		revoked: discussionResolution.state === "revoked"
 	};
 }
-/** Public embed/open URLs for one bound discussion channel. */
-function discussionInfoForBinding(binding, account) {
-	const baseUrl = normalizedServerBaseUrl(account);
+/**
+* Resolves whether a ClickClack message should enter the agent pipeline and
+* whether its command-style body may run tools.
+*/
+async function resolveClickClackInboundAccess(params) {
+	const runtime = getClickClackRuntime();
+	const cfg = params.config;
+	const preparedRoute = resolvePreparedInboundRoute(params);
+	const shouldCheckCommand = runtime.channel.commands.shouldComputeCommandAuthorized(params.message.body, cfg);
+	const effectiveGroupPolicy = resolveClickClackGroupPolicy({
+		account: params.account,
+		channelId: params.message.channel_id
+	});
+	const mentionFacts = resolveClickClackMentionFacts({
+		isDirect: preparedRoute.isDirect,
+		body: params.message.body,
+		mentionPatterns: effectiveGroupPolicy.mentionPatterns,
+		botHandle: params.account.botHandle,
+		cfg,
+		agentId: preparedRoute.route.agentId,
+		channelId: params.message.channel_id
+	});
+	if (params.message.kind !== void 0 && params.message.kind !== "message") return {
+		shouldDispatch: false,
+		commandAuthorized: false,
+		requireMention: effectiveGroupPolicy.requireMention,
+		mentionFacts,
+		preparedRoute
+	};
+	const effectiveBotPolicy = resolveClickClackBotPolicy({
+		account: params.account,
+		channelId: params.message.channel_id
+	});
+	const isBotAuthor = params.message.author?.kind === "bot";
+	const ingressAllowFrom = isBotAuthor ? params.account.allowFrom.filter((entry) => normalizeClickClackUserId(entry) !== "*") : params.account.allowFrom;
+	if (!(!isBotAuthor || effectiveBotPolicy.allowBots === true || effectiveBotPolicy.allowBots === "mentions" && (preparedRoute.isDirect || mentionFacts.wasMentioned))) return {
+		shouldDispatch: false,
+		commandAuthorized: false,
+		requireMention: effectiveGroupPolicy.requireMention,
+		mentionFacts,
+		preparedRoute
+	};
+	const botLoopNowMs = parseDateStringTimestampMs(params.message.created_at);
+	const botLoopProtection = isBotAuthor && params.message.author_id !== params.account.botUserId && params.account.botUserId ? {
+		scopeId: params.account.workspace,
+		conversationId: resolveClickClackBotLoopConversationId({
+			message: params.message,
+			isDirect: preparedRoute.isDirect
+		}),
+		senderId: params.message.author_id,
+		receiverId: params.account.botUserId,
+		eventId: params.message.id,
+		...botLoopNowMs !== void 0 ? { nowMs: botLoopNowMs } : {},
+		config: effectiveBotPolicy.botLoopProtection,
+		defaultsConfig: cfg.channels?.defaults?.botLoopProtection,
+		defaultEnabled: true
+	} : void 0;
+	const allowTextCommands = params.account.replyMode === "agent" && runtime.channel.commands.shouldHandleTextCommands({
+		cfg,
+		surface: CHANNEL_ID$2,
+		commandSource: "text"
+	});
+	const resolved = await resolveStableChannelMessageIngress({
+		channelId: CHANNEL_ID$2,
+		accountId: params.account.accountId,
+		identity: clickClackIngressIdentity,
+		cfg,
+		subject: { stableId: params.message.author_id },
+		conversation: {
+			kind: preparedRoute.isDirect ? "direct" : "group",
+			id: preparedRoute.isDirect ? params.message.direct_conversation_id ?? params.message.author_id : params.message.channel_id ?? params.message.thread_root_id
+		},
+		contextBinding: {
+			agentId: preparedRoute.route.agentId,
+			sessionKey: preparedRoute.route.sessionKey,
+			messageId: params.message.id,
+			inboundEventKind: "user_request"
+		},
+		allowFrom: ingressAllowFrom,
+		dmPolicy: "allowlist",
+		groupPolicy: "allowlist",
+		mentionFacts,
+		policy: { activation: {
+			requireMention: effectiveGroupPolicy.requireMention,
+			allowTextCommands
+		} },
+		command: shouldCheckCommand ? {
+			cfg,
+			modeWhenAccessGroupsOff: "configured"
+		} : false
+	});
 	return {
-		state: "open",
-		embedUrl: `${baseUrl}/embed/channel/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}?openclawHostTheme=1`,
-		openUrl: `${baseUrl}/app/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}`
+		shouldDispatch: !preparedRoute.revoked && resolved.ingress.admission === "dispatch",
+		commandAuthorized: resolved.commandAccess.requested ? resolved.commandAccess.authorized : resolved.senderAccess.allowed,
+		requireMention: effectiveGroupPolicy.requireMention,
+		mentionFacts,
+		botLoopProtection,
+		preparedRoute,
+		channelIngress: resolved
 	};
 }
 //#endregion
-//#region extensions/clickclack/src/discussions/revoked-channel-store.ts
-const REVOKED_CHANNELS_NAMESPACE = "discussion-revoked-channels";
-const MAX_REVOKED_CHANNELS = 1e5;
-const storesByRuntime = /* @__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"
-	});
-	storesByRuntime.set(runtime, created);
-	return created;
+//#region extensions/clickclack/src/command-menu.ts
+const CLICKCLACK_COMMAND_PATTERN = /^[a-z0-9_-]{1,32}$/u;
+const CLICKCLACK_MAX_COMMANDS = 100;
+const CLICKCLACK_MAX_DESCRIPTION_LENGTH = 100;
+const CLICKCLACK_MAX_ARGS_HINT_LENGTH = 100;
+function truncateCodePoints(value, maxLength) {
+	return Array.from(value).slice(0, maxLength).join("");
 }
-/** Records managed ownership before its live binding is released. */
-function markClickClackDiscussionChannelRevoked(runtime, binding) {
-	const value = {
-		accountId: binding.accountId,
-		serverBaseUrl: binding.serverBaseUrl,
-		channelId: binding.channelId,
-		revokedAt: Date.now()
-	};
-	getStore(runtime).register(revokedChannelKey(value), value);
+function commandArgsHint(spec) {
+	if (spec.args?.length) return truncateCodePoints(spec.args.map((arg) => arg.required ? `<${arg.name}>` : `[${arg.name}]`).join(" "), CLICKCLACK_MAX_ARGS_HINT_LENGTH);
+	return spec.acceptsArgs ? "[args]" : "";
 }
-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);
+function errorStatus(error) {
+	if (!error || typeof error !== "object" || !("status" in error)) return;
+	const status = error.status;
+	return typeof status === "number" ? status : void 0;
 }
-function clearClickClackDiscussionChannelRevoked(params) {
-	getStore(params.runtime).delete(revokedChannelKey(params));
+function mapNativeCommandSpecsToClickClackMenu(specs, log) {
+	const commands = [];
+	const seen = /* @__PURE__ */ new Set();
+	const invalidNames = /* @__PURE__ */ new Set();
+	for (const spec of specs) {
+		if (spec.isAlias) continue;
+		const command = spec.name.trim().toLowerCase();
+		if (!CLICKCLACK_COMMAND_PATTERN.test(command)) {
+			invalidNames.add(spec.name.trim() || "<empty>");
+			continue;
+		}
+		if (seen.has(command)) continue;
+		seen.add(command);
+		const description = spec.description.trim() || command;
+		commands.push({
+			command,
+			description: truncateCodePoints(description, CLICKCLACK_MAX_DESCRIPTION_LENGTH),
+			args_hint: commandArgsHint(spec)
+		});
+	}
+	if (invalidNames.size > 0) log?.warn?.(`ClickClack command menu skipped invalid native command names: ${[...invalidNames].map((name) => JSON.stringify(name)).join(", ")}`);
+	return commands.slice(0, CLICKCLACK_MAX_COMMANDS);
 }
-/** Distinguishes a released managed channel from a genuinely ordinary channel. */
-function isClickClackDiscussionChannelRevoked(params) {
-	return Boolean(getStore(params.runtime).lookup(revokedChannelKey(params)));
+async function syncClickClackCommandMenu(params) {
+	try {
+		const commands = mapNativeCommandSpecsToClickClackMenu(listNativeCommandSpecsForConfig(params.cfg, { provider: "clickclack" }), params.log);
+		await params.client.setBotCommands(commands);
+	} catch (error) {
+		const status = errorStatus(error);
+		if (status === 403) {
+			params.log?.warn?.("ClickClack command menu sync skipped: bot token lacks commands:write");
+			return;
+		}
+		if (status === 404) {
+			params.log?.debug?.("ClickClack command menu sync skipped: server does not support /api/bots/self/commands");
+			return;
+		}
+		params.log?.warn?.(`ClickClack command menu sync failed: ${formatErrorMessage(error)}`);
+	}
 }
 //#endregion
-//#region extensions/clickclack/src/discussions/routing.ts
-function resolveClickClackDiscussionRoute(params) {
-	if (isClickClackDiscussionChannelRevoked(params)) return { state: "revoked" };
-	const matched = getClickClackDiscussionBindingStore(params.runtime).getByChannel(params.serverBaseUrl, params.channelId);
-	if (!matched) return { state: hasPendingDiscussionOpenForDestination(params) ? "revoked" : "unbound" };
-	if (matched.binding.accountId !== params.accountId) return { state: "revoked" };
-	if (matched.binding.serverBaseUrl !== params.serverBaseUrl.replace(/\/+$/u, "")) return { state: "revoked" };
-	if (matched.binding.archived) return { state: "revoked" };
-	if (resolveDiscussionBindingAccount(params.config, matched.binding).state !== "active") return { state: "revoked" };
-	if (!bindingMatchesActiveSessionIncarnation(params.runtime, matched.sessionKey, matched.binding)) return { state: "revoked" };
-	const sessionKey = discussionSessionKey({
-		runtime: params.runtime,
-		agentId: matched.binding.agentId,
-		mainSessionKey: matched.sessionKey,
-		sessionId: matched.binding.sessionId,
-		accountId: params.accountId,
-		serverBaseUrl: matched.binding.serverBaseUrl,
-		channelId: matched.binding.channelId,
-		externalRef: matched.binding.externalRef
+//#region extensions/clickclack/src/activity.ts
+/**
+* Publishes agent activity (streamed commentary + tool progress) into
+* ClickClack as durable `agent_commentary` / `agent_tool` message rows,
+* coalesced so one logical step becomes one row instead of a row per frame.
+*
+* Ported from the clickglass agent-bridge sidecar, adapted from gateway
+* websocket frames to the in-process `replyOptions.onItemEvent` seam:
+*
+* - Commentary/reasoning arrives as cumulative text snapshots per item id.
+*   Each segment becomes one durable row: POSTed when the segment starts
+*   streaming and PATCHed (debounced) as the snapshot grows, so prose
+*   interleaves chronologically with tool rows.
+* - Tool/step items can emit several frames (start/update/complete) for the
+*   same call, sometimes with lane-prefixed ids (`tool:X`, `command:X`).
+*   Normalize the prefix away to one key per call, POST one row on the first
+*   frame, and PATCH it when a later frame carries a strictly longer body.
+*/
+/** Debounce window for PATCHing streaming commentary snapshots. */
+const CLICKCLACK_COMMENTARY_FLUSH_MS = 700;
+/** Item kinds rendered as agent_tool rows; everything else is commentary. */
+const TOOL_ITEM_KINDS = /* @__PURE__ */ new Set([
+	"tool",
+	"command",
+	"command_output",
+	"patch",
+	"search",
+	"api"
+]);
+/** Item kinds that never become durable rows (ephemeral or plumbing lanes). */
+const SKIPPED_ITEM_KINDS = /* @__PURE__ */ new Set(["lifecycle"]);
+/** Item kinds emitted as cumulative commentary snapshots. */
+const STREAMING_COMMENTARY_ITEM_KINDS = /* @__PURE__ */ new Set([
+	"preamble",
+	"commentary",
+	"analysis",
+	"thinking",
+	"reasoning"
+]);
+/** Provider-specific reasoning lanes normalized into one ClickClack label. */
+const THINKING_ITEM_KINDS = /* @__PURE__ */ new Set([
+	"analysis",
+	"thinking",
+	"reasoning"
+]);
+function normalizedItemKind(payload) {
+	return payload.kind?.trim().toLowerCase() ?? "";
+}
+function commentaryBody(payload) {
+	const text = payload.progressText?.trim() || payload.summary?.trim() || payload.meta?.trim() || "";
+	if (!text) return "";
+	const kind = normalizedItemKind(payload);
+	if (THINKING_ITEM_KINDS.has(kind)) return `**Thinking**\n\n${text}`;
+	return text;
+}
+function activityBody(payload) {
+	const line = buildChannelProgressDraftLine({
+		event: "item",
+		itemId: payload.itemId,
+		toolCallId: payload.toolCallId,
+		itemKind: payload.kind,
+		title: payload.title,
+		name: payload.name,
+		phase: payload.phase,
+		status: payload.status,
+		summary: payload.summary,
+		progressText: payload.progressText,
+		meta: payload.meta,
+		commandBearing: payload.commandBearing
+	})?.text?.trim();
+	if (line) return line;
+	const head = payload.name?.trim() || payload.title?.trim();
+	const text = payload.progressText?.trim() || payload.summary?.trim();
+	if (head && text) return `**${head}**\n\n${text}`;
+	if (text) return text;
+	if (head) return head;
+	return payload.status?.trim() || payload.kind?.trim() || "";
+}
+/**
+* Creates a per-turn activity publisher. Publishing is best-effort: transport
+* failures are reported through `onError` and never interrupt the reply turn.
+*/
+function createClickClackActivityPublisher(params) {
+	const flushMs = params.flushMs ?? CLICKCLACK_COMMENTARY_FLUSH_MS;
+	const commentaryByItem = /* @__PURE__ */ new Map();
+	const toolRows = /* @__PURE__ */ new Map();
+	let provenance;
+	let chain = Promise.resolve();
+	const enqueue = (work) => {
+		chain = chain.then(work).catch((error) => {
+			params.onError?.(error);
+		});
+		return chain;
+	};
+	const postRow = (kind, body) => params.client.createActivityMessage({
+		channelId: params.target.channelId,
+		conversationId: params.target.conversationId,
+		body,
+		kind,
+		turnId: params.turnId,
+		provenance
 	});
-	if (!sessionKey) return { state: "revoked" };
-	return {
-		state: "active",
-		route: {
-			agentId: matched.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(" ")
+	const flushCommentary = (segmentKey) => {
+		const segment = commentaryByItem.get(segmentKey);
+		if (!segment) return Promise.resolve();
+		if (segment.timer) {
+			clearTimeout(segment.timer);
+			segment.timer = void 0;
 		}
+		if (!segment.dirty || !segment.body.trim()) return Promise.resolve();
+		segment.dirty = false;
+		const body = segment.body;
+		return enqueue(async () => {
+			if (segment.messageId) {
+				await params.client.updateMessageBody(segment.messageId, body);
+				return;
+			}
+			const posted = await postRow("agent_commentary", body);
+			segment.messageId = posted.id;
+		});
+	};
+	const flushAllCommentary = () => {
+		const flushes = [...commentaryByItem.keys()].map((key) => flushCommentary(key));
+		return Promise.all(flushes).then(() => void 0);
 	};
-}
-//#endregion
-//#region extensions/clickclack/src/target.ts
-/**
-* Parses `channel:name`, `thread:msg_id`, `dm:usr_id`, or a bare channel name.
-*/
-function parseClickClackTarget(raw) {
-	const value = raw.trim();
-	if (!value) throw new Error("ClickClack target is required");
-	const [prefix, ...rest] = value.split(":");
-	const body = rest.join(":").trim();
-	if (prefix === "channel" && body) return {
-		chatType: "group",
-		kind: "channel",
-		id: body
+	const handleCommentary = (payload) => {
+		const body = commentaryBody(payload);
+		if (!body.trim()) return;
+		const key = payload.itemId?.trim() || "turn";
+		let segment = commentaryByItem.get(key);
+		if (!segment) {
+			segment = {
+				body: "",
+				dirty: false
+			};
+			commentaryByItem.set(key, segment);
+		}
+		if (body.length < segment.body.length || body === segment.body) return;
+		segment.body = body;
+		segment.dirty = true;
+		if (!segment.timer) segment.timer = setTimeout(() => {
+			segment.timer = void 0;
+			flushCommentary(key);
+		}, flushMs);
 	};
-	if (prefix === "thread" && body) return {
-		chatType: "group",
-		kind: "thread",
-		id: body
+	const toolRowKey = (payload) => {
+		const toolCallId = payload.toolCallId?.trim();
+		if (toolCallId) return toolCallId;
+		return (payload.itemId?.trim() ?? "").replace(/^(tool|command):/, "");
 	};
-	if (prefix === "dm" && body) return {
-		chatType: "direct",
-		kind: "dm",
-		id: body
+	const handleDiscreteItem = (payload) => {
+		const body = activityBody(payload);
+		if (!body) return;
+		const kind = TOOL_ITEM_KINDS.has(payload.kind?.trim().toLowerCase() ?? "") ? "agent_tool" : "agent_commentary";
+		flushAllCommentary();
+		const key = `${kind}:${toolRowKey(payload)}`;
+		const existing = toolRows.get(key);
+		if (!existing || !toolRowKey(payload)) {
+			const row = { body };
+			if (toolRowKey(payload)) toolRows.set(key, row);
+			enqueue(async () => {
+				const posted = await postRow(kind, row.body);
+				row.messageId = posted.id;
+				row.sentBody = row.body;
+			});
+			return;
+		}
+		if (body.length <= existing.body.length) return;
+		existing.body = body;
+		enqueue(async () => {
+			if (existing.messageId && existing.body !== existing.sentBody) {
+				await params.client.updateMessageBody(existing.messageId, existing.body);
+				existing.sentBody = existing.body;
+			}
+		});
 	};
-	if (!body) return {
-		chatType: "group",
-		kind: "channel",
-		id: value
+	return {
+		onItemEvent: (payload) => {
+			const kind = normalizedItemKind(payload);
+			if (STREAMING_COMMENTARY_ITEM_KINDS.has(kind)) {
+				handleCommentary(payload);
+				return false;
+			}
+			if (SKIPPED_ITEM_KINDS.has(kind)) return false;
+			handleDiscreteItem(payload);
+			return false;
+		},
+		setProvenance: (next) => {
+			provenance = next;
+		},
+		finalize: async () => {
+			await flushAllCommentary();
+			await chain;
+		}
 	};
-	throw new Error(`Unsupported ClickClack target: ${raw}`);
-}
-/** Formats a parsed ClickClack target back into canonical target syntax. */
-function buildClickClackTarget(target) {
-	return `${target.kind}:${target.id}`;
-}
-/** Normalizes user-entered ClickClack target text for channel routing. */
-function normalizeClickClackTarget(raw) {
-	return buildClickClackTarget(parseClickClackTarget(raw));
-}
-/** Reports whether a target string can be offered to the ClickClack parser. */
-function looksLikeClickClackTarget(raw) {
-	return /^(channel|thread|dm):/i.test(raw.trim()) || raw.trim().length > 0;
 }
 //#endregion
 //#region extensions/clickclack/src/outbound.ts
@@ -876,9 +1232,9 @@ async function sendClickClackMedia(params) {
 			mediaLocalRoots: params.mediaLocalRoots,
 			mediaReadFile: params.mediaReadFile
 		});
-		const filename = media.fileName?.trim() || "attachment";
-		mediaFilename = filename;
 		const contentType = media.contentType?.trim() || "application/octet-stream";
+		const filename = media.fileName?.trim() || `attachment${extensionForMime(contentType) ?? ""}`;
+		mediaFilename = filename;
 		await dispatch();
 		upload = await client.createUpload({
 			workspaceId,
@@ -1011,6 +1367,219 @@ async function reconcileClickClackUnknownSend(ctx) {
 	};
 }
 //#endregion
+//#region extensions/clickclack/src/progress.ts
+/**
+* Publishes ClickClack's native ephemeral agent.progress signal for one
+* OpenClaw turn. ClickClack renders this as its compact "Agent is
+* responding" status and the detailed progress lines above the composer.
+*/
+function normalizedKind(payload) {
+	const kind = payload.kind?.trim().toLowerCase();
+	if (!kind || kind === "preamble" || kind === "analysis" || kind === "thinking" || kind === "reasoning" || kind === "missing") return "commentary";
+	return kind;
+}
+function progressText(payload) {
+	const line = buildChannelProgressDraftLine({
+		event: "item",
+		itemId: payload.itemId,
+		toolCallId: payload.toolCallId,
+		itemKind: payload.kind,
+		title: payload.title,
+		name: payload.name,
+		phase: payload.phase,
+		status: payload.status,
+		summary: payload.summary,
+		progressText: payload.progressText,
+		meta: payload.meta,
+		commandBearing: payload.commandBearing
+	})?.text?.trim();
+	if (line) return line;
+	return payload.progressText?.trim() || payload.summary?.trim() || payload.title?.trim() || payload.name?.trim() || payload.meta?.trim() || payload.status?.trim() || "Working";
+}
+function isFinal(payload) {
+	const phase = payload.phase?.trim().toLowerCase();
+	const status = payload.status?.trim().toLowerCase();
+	return phase === "end" || status === "completed" || status === "failed" || status === "blocked";
+}
+function createLineIdResolver() {
+	const lineIdsByIdentity = /* @__PURE__ */ new Map();
+	const anonymousLinesByKind = /* @__PURE__ */ new Map();
+	let anonymousSequence = 0;
+	return (payload) => {
+		const identities = [payload.itemId?.replace(/^(tool|command):/, ""), payload.toolCallId].map((value) => value?.trim()).filter((value) => Boolean(value));
+		const existingId = identities.map((identity) => lineIdsByIdentity.get(identity)).find(Boolean);
+		if (existingId) {
+			for (const identity of identities) lineIdsByIdentity.set(identity, existingId);
+			return existingId;
+		}
+		if (identities.length > 0) {
+			const id = `item:${identities[0]}`;
+			for (const identity of identities) lineIdsByIdentity.set(identity, id);
+			return id;
+		}
+		const kind = normalizedKind(payload);
+		const anonymousLines = anonymousLinesByKind.get(kind) ?? [];
+		const line = (payload.phase?.trim().toLowerCase() === "start" ? void 0 : anonymousLines.toReversed().find((line) => line.active)) ?? (() => {
+			const created = {
+				id: `item:${kind}:${++anonymousSequence}`,
+				active: true
+			};
+			anonymousLines.push(created);
+			anonymousLinesByKind.set(kind, anonymousLines);
+			return created;
+		})();
+		if (isFinal(payload)) line.active = false;
+		return line.id;
+	};
+}
+const CLICKCLACK_PROGRESS_UPDATE_INTERVAL_MS = 100;
+const CLICKCLACK_PROGRESS_FINALIZE_GRACE_MS = 1e3;
+function createClickClackAgentProgressPublisher(params) {
+	let sequence = 0;
+	const queue = [];
+	const queuedLines = /* @__PURE__ */ new Map();
+	let drainPromise;
+	let lineDrainTimer;
+	let started = false;
+	let cleared = false;
+	const seenLines = /* @__PURE__ */ new Set();
+	const resolveLineId = createLineIdResolver();
+	const drain = () => {
+		if (drainPromise) return drainPromise;
+		drainPromise = (async () => {
+			while (queue.length > 0) {
+				const frame = queue.shift();
+				if (!frame) continue;
+				if (frame.lineId) queuedLines.delete(frame.lineId);
+				try {
+					await params.client.publishEphemeral({
+						...params.target,
+						type: "agent.progress",
+						payload: {
+							turn_id: params.turnId,
+							seq: ++sequence,
+							...frame.payload
+						}
+					});
+				} catch (error) {
+					try {
+						params.onError?.(error);
+					} catch {}
+				}
+			}
+		})().finally(() => {
+			drainPromise = void 0;
+			if (queue.length > 0) drain();
+		});
+		return drainPromise;
+	};
+	const enqueue = (payload) => {
+		queue.push({ payload });
+		drain();
+	};
+	const flushQueuedLines = () => {
+		for (const [lineId, frame] of queuedLines) {
+			queuedLines.delete(lineId);
+			queue.push(frame);
+		}
+		drain();
+	};
+	const discardQueuedLines = () => {
+		queuedLines.clear();
+		const controlFrames = queue.filter((frame) => !frame.lineId);
+		queue.splice(0, queue.length, ...controlFrames);
+	};
+	const waitForDrainWithinFinalizeGrace = async (pending) => {
+		let timeout;
+		let drained = false;
+		try {
+			await Promise.race([pending.then(() => {
+				drained = true;
+			}), new Promise((resolve) => {
+				timeout = setTimeout(resolve, CLICKCLACK_PROGRESS_FINALIZE_GRACE_MS);
+			})]);
+			return drained;
+		} finally {
+			if (timeout) clearTimeout(timeout);
+		}
+	};
+	const scheduleLineDrain = () => {
+		if (lineDrainTimer) return;
+		lineDrainTimer = setTimeout(() => {
+			lineDrainTimer = void 0;
+			flushQueuedLines();
+		}, CLICKCLACK_PROGRESS_UPDATE_INTERVAL_MS);
+	};
+	const enqueueLine = (lineId, payload) => {
+		const queued = queuedLines.get(lineId);
+		if (queued) {
+			const op = payload.op === "finalize" ? "finalize" : queued.payload.op === "append" ? "append" : payload.op;
+			queued.payload = {
+				...payload,
+				...op ? { op } : {}
+			};
+			return;
+		}
+		const frame = {
+			lineId,
+			payload
+		};
+		queuedLines.set(lineId, frame);
+		scheduleLineDrain();
+	};
+	return {
+		start() {
+			if (started) return;
+			started = true;
+			enqueue({
+				op: "append",
+				line: {
+					id: "turn",
+					kind: "commentary",
+					text: params.agentLabel ? `${params.agentLabel} is responding` : "Agent is responding",
+					status: "running"
+				}
+			});
+		},
+		onItemEvent(payload) {
+			if (!started || cleared) return false;
+			const id = resolveLineId(payload);
+			const final = isFinal(payload);
+			const kind = normalizedKind(payload);
+			const retractsExistingCommentary = kind === "commentary" && seenLines.has(id) && payload.progressText !== void 0 && payload.progressText.trim() === "";
+			if (retractsExistingCommentary && queuedLines.get(id)?.payload.op === "append") {
+				queuedLines.delete(id);
+				seenLines.delete(id);
+				return false;
+			}
+			const line = {
+				id,
+				kind,
+				text: retractsExistingCommentary ? "" : progressText(payload),
+				status: payload.status?.trim() || (final ? "completed" : "running")
+			};
+			if (payload.name?.trim()) line.tool_name = payload.name.trim();
+			enqueueLine(id, {
+				op: final ? "finalize" : seenLines.has(id) ? "update" : "append",
+				line
+			});
+			seenLines.add(id);
+			return false;
+		},
+		async finalize() {
+			if (!started || cleared) return;
+			cleared = true;
+			if (lineDrainTimer) {
+				clearTimeout(lineDrainTimer);
+				lineDrainTimer = void 0;
+			}
+			flushQueuedLines();
+			enqueue({ op: "clear" });
+			if (!await waitForDrainWithinFinalizeGrace(drain())) discardQueuedLines();
+		}
+	};
+}
+//#endregion
 //#region extensions/clickclack/src/inbound.ts
 const CHANNEL_ID$1 = "clickclack";
 const CLICKCLACK_MESSAGE_ID_PATTERN = /^msg_[0-9a-hjkmnp-tv-z]{26}$/u;
@@ -1020,49 +1589,6 @@ function hasClickClackReplyMedia(payload) {
 function resolveClickClackAgentRunId(messageId) {
 	return CLICKCLACK_MESSAGE_ID_PATTERN.test(messageId) ? `${CHANNEL_ID$1}:${messageId}` : void 0;
 }
-function resolveAccountAgentRoute(params) {
-	const runtime = getClickClackRuntime();
-	const route = runtime.channel.routing.resolveAgentRoute({
-		cfg: params.cfg,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		peer: {
-			kind: params.isDirect ? "direct" : "channel",
-			id: params.target
-		}
-	});
-	const agentId = normalizeAgentId(params.account.agentId ?? route.agentId);
-	if (agentId === route.agentId) return route;
-	const peer = {
-		kind: params.isDirect ? "direct" : "channel",
-		id: params.target
-	};
-	const dmScope = params.cfg.session?.dmScope ?? "main";
-	const sessionKey = runtime.channel.routing.buildAgentSessionKey({
-		agentId,
-		mainKey: params.cfg.session?.mainKey,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		peer,
-		dmScope,
-		identityLinks: params.cfg.session?.identityLinks
-	});
-	const mainSessionKey = runtime.channel.routing.buildAgentSessionKey({
-		agentId,
-		mainKey: params.cfg.session?.mainKey,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		dmScope: "main"
-	});
-	return {
-		...route,
-		agentId,
-		dmScope,
-		sessionKey,
-		mainSessionKey,
-		lastRoutePolicy: sessionKey === mainSessionKey ? "main" : "session"
-	};
-}
 async function dispatchModelReply(params) {
 	const runtime = getClickClackRuntime();
 	const text = (await runtime.llm.complete({
@@ -1104,50 +1630,56 @@ async function handleClickClackInbound(params) {
 		config: params.config,
 		message
 	});
-	if (!access.shouldDispatch) return;
+	if (!access.shouldDispatch || !access.channelIngress) return;
 	const conversationId = message.channel_id || message.direct_conversation_id;
 	if (!conversationId) return;
-	const isDirect = Boolean(message.direct_conversation_id);
-	const target = buildClickClackTarget(isDirect ? {
-		chatType: "direct",
-		kind: "dm",
-		id: message.author_id
-	} : {
-		chatType: "group",
-		kind: "channel",
-		id: message.channel_id ?? ""
-	});
-	const accountRoute = resolveAccountAgentRoute({
-		cfg: params.config,
-		account: params.account,
-		target,
-		isDirect
-	});
-	const discussionResolution = !isDirect && message.channel_id ? resolveClickClackDiscussionRoute({
-		runtime,
-		config: params.config,
-		accountId: params.account.accountId,
-		serverBaseUrl: params.account.baseUrl,
-		workspaceId: message.workspace_id,
-		channelId: message.channel_id
-	}) : { state: "unbound" };
-	if (discussionResolution.state === "revoked") return;
-	const discussionRoute = discussionResolution.state === "active" ? discussionResolution.route : void 0;
-	const route = discussionRoute ? {
-		...accountRoute,
-		agentId: discussionRoute.agentId,
-		sessionKey: discussionRoute.sessionKey,
-		lastRoutePolicy: "session"
-	} : accountRoute;
-	if (params.account.replyMode === "model" && !discussionRoute) {
-		await dispatchModelReply({
-			account: params.account,
-			cfg: params.config,
-			message,
-			route,
-			target,
+	const { discussionRoute, isDirect, route, target } = access.preparedRoute;
+	const progress = params.account.nativeProgress ? createClickClackAgentProgressPublisher({
+		client: createClickClackClient({
+			baseUrl: params.account.apiEndpoint,
+			token: params.account.token,
 			correlationId: params.correlationId
-		});
+		}),
+		target: message.channel_id ? {
+			workspaceId: message.workspace_id,
+			channelId: message.channel_id
+		} : {
+			workspaceId: message.workspace_id,
+			conversationId
+		},
+		turnId: message.id,
+		agentLabel: params.account.name?.trim() || params.account.botHandle?.trim() || params.account.agentId?.trim() || params.account.accountId,
+		onError: (error) => {
+			runtime.logging.getChildLogger({
+				plugin: "clickclack",
+				feature: "agent-progress"
+			}).warn(`clickclack progress publish failed: ${String(error)}`);
+		}
+	}) : void 0;
+	if (params.account.replyMode === "model" && !discussionRoute) {
+		if (access.botLoopProtection) {
+			const loopResult = recordChannelBotPairLoopAndCheckSuppression(access.botLoopProtection);
+			if (loopResult.suppressed) {
+				runtime.logging.getChildLogger({
+					plugin: "clickclack",
+					feature: "bot-loop-protection"
+				}).warn(`[${params.account.accountId}] ClickClack bot-pair loop suppressed for ${Math.max(0, Math.ceil((loopResult.cooldownUntilMs - Date.now()) / 1e3))}s`);
+				return;
+			}
+		}
+		progress?.start();
+		try {
+			await dispatchModelReply({
+				account: params.account,
+				cfg: params.config,
+				message,
+				route,
+				target,
+				correlationId: params.correlationId
+			});
+		} finally {
+			await progress?.finalize();
+		}
 		return;
 	}
 	let turnProvenance;
@@ -1177,7 +1709,8 @@ async function handleClickClackInbound(params) {
 		timestamp: new Date(message.created_at),
 		body: message.body
 	});
-	const ctxPayload = runtime.channel.inbound.buildContext({
+	const ctxPayload = (params.buildContext ?? buildChannelInboundEventContext)({
+		channelIngress: access.channelIngress,
 		channel: CHANNEL_ID$1,
 		accountId: route.accountId ?? params.account.accountId,
 		messageId: message.id,
@@ -1216,10 +1749,7 @@ async function handleClickClackInbound(params) {
 		},
 		access: {
 			commands: { authorized: access.commandAuthorized },
-			mentions: {
-				canDetectMention: !isDirect,
-				wasMentioned: !isDirect
-			}
+			mentions: access.mentionFacts
 		},
 		extra: {
 			GroupChannel: message.channel_id,
@@ -1227,20 +1757,27 @@ async function handleClickClackInbound(params) {
 		}
 	});
 	const runId = resolveClickClackAgentRunId(message.id);
-	const activityReplyOptions = activity ? {
-		onModelSelected: (ctx) => {
+	const activityReplyOptions = {
+		...activity ? { onModelSelected: (ctx) => {
 			turnProvenance = {
 				model: ctx.provider && ctx.model ? `${ctx.provider}/${ctx.model}` : ctx.model,
 				thinking: ctx.thinkLevel
 			};
-			activity?.setProvenance(turnProvenance);
-		},
-		onItemEvent: activity.onItemEvent,
-		commentaryProgressEnabled: true,
-		suppressDefaultToolProgressMessages: true,
-		allowProgressCallbacksWhenSourceDeliverySuppressed: true
-	} : void 0;
-	const dispatchPromise = runtime.channel.inbound.dispatch({
+			activity.setProvenance(turnProvenance);
+		} } : {},
+		...progress || activity ? {
+			onItemEvent: (payload) => {
+				progress?.onItemEvent(payload);
+				activity?.onItemEvent(payload);
+				return false;
+			},
+			commentaryProgressEnabled: true,
+			suppressDefaultToolProgressMessages: true,
+			allowProgressCallbacksWhenSourceDeliverySuppressed: true
+		} : {}
+	};
+	progress?.start();
+	const dispatch = () => runtime.channel.inbound.dispatch({
 		cfg: params.config,
 		channel: CHANNEL_ID$1,
 		accountId: params.account.accountId,
@@ -1250,11 +1787,12 @@ async function handleClickClackInbound(params) {
 			sessionKey: route.sessionKey
 		},
 		ctxPayload,
+		botLoopProtection: access.botLoopProtection,
 		toolsAllow: params.account.toolsAllow,
-		replyOptions: runId || activityReplyOptions ? {
+		replyOptions: {
 			...runId ? { runId } : {},
 			...activityReplyOptions
-		} : void 0,
+		},
 		delivery: {
 			deliver: async (payload) => {
 				if (hasClickClackReplyMedia(payload)) throw new Error("ClickClack media reply requires durable delivery");
@@ -1296,8 +1834,9 @@ async function handleClickClackInbound(params) {
 		} }
 	});
 	try {
-		await dispatchPromise;
+		await dispatch();
 	} finally {
+		await progress?.finalize();
 		await activity?.finalize();
 	}
 }
@@ -1305,8 +1844,7 @@ async function handleClickClackInbound(params) {
 //#region extensions/clickclack/src/gateway.ts
 const CLICKCLACK_EVENT_PAGE_LIMIT = 500;
 function payloadString(event, key) {
-	const value = event.payload?.[key];
-	return typeof value === "string" ? value : "";
+	return readStringField(event.payload, key) ?? "";
 }
 function eventCorrelationId(event) {
 	return normalizeClickClackCorrelationId(event.payload?.correlation_id);
@@ -1314,25 +1852,16 @@ function eventCorrelationId(event) {
 async function resolveEventMessage(params) {
 	const messageId = payloadString(params.event, "message_id");
 	if (!messageId) return null;
-	const directConversationId = payloadString(params.event, "direct_conversation_id");
-	if (directConversationId && typeof params.event.seq === "number") return (await params.client.directMessages(directConversationId, params.event.seq - 1, 10)).find((message) => message.id === messageId) ?? null;
-	if (params.event.type === "thread.reply_created") {
-		const rootId = payloadString(params.event, "root_message_id");
-		if (!rootId) return null;
-		return (await params.client.thread(rootId)).replies.find((message) => message.id === messageId) ?? null;
+	try {
+		return await params.client.message(messageId);
+	} catch (error) {
+		if (error instanceof ClickClackHttpError && error.status === 404) return null;
+		throw error;
 	}
-	if (params.event.channel_id && typeof params.event.seq === "number") return (await params.client.channelMessages(params.event.channel_id, params.event.seq - 1, 10)).find((message) => message.id === messageId) ?? null;
-	return null;
-}
-function decodeSocketMessage(data) {
-	if (typeof data === "string") return data;
-	if (Buffer.isBuffer(data)) return data.toString("utf8");
-	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
-	return Buffer.concat(data).toString("utf8");
 }
 function parseSocketEvent(data) {
 	try {
-		return JSON.parse(decodeSocketMessage(data));
+		return JSON.parse(rawDataToString(data));
 	} catch {
 		return null;
 	}
@@ -1349,19 +1878,26 @@ async function processEvent(params) {
 		}) : params.client,
 		event: params.event
 	});
-	if (!message || message.author_id === params.botUserId) return;
-	if (message.author?.kind === "bot") return;
+	if (!message) {
+		params.log?.warn?.(`[${params.account.accountId}] skipped unreadable ClickClack message before agent dispatch: type=${params.event.type} messageId=${payloadString(params.event, "message_id") || "unknown"}`);
+		return;
+	}
+	if (message.author_id === params.botUserId) return;
 	const access = await resolveClickClackInboundAccess({
 		account: params.account,
 		config: params.config,
 		message
 	});
-	if (!access.shouldDispatch) return;
+	if (!access.shouldDispatch) {
+		params.log?.info(`[${params.account.accountId}] skipped ClickClack message before agent dispatch: kind=${message.direct_conversation_id ? "dm" : "group"} requireMention=${access.requireMention ?? "unknown"} wasMentioned=${access.mentionFacts.wasMentioned} hasAnyMention=${access.mentionFacts.hasAnyMention ?? "unknown"} commandAuthorized=${access.commandAuthorized}`);
+		return;
+	}
 	await handleClickClackInbound({
 		account: params.account,
 		config: params.config,
 		message,
 		access,
+		buildContext: params.buildContext,
 		...correlationId ? { correlationId } : {}
 	});
 }
@@ -1397,14 +1933,17 @@ async function startClickClackGatewayAccount(ctx) {
 	const account = {
 		...configuredAccount,
 		workspace: workspaceId,
-		botUserId: configuredAccount.botUserId ?? me.id
+		botUserId: configuredAccount.botUserId ?? me.id,
+		botHandle: me.handle
 	};
 	const processIncomingEvent = (event) => processEvent({
 		account,
 		config: ctx.cfg,
 		client,
 		event,
-		botUserId: account.botUserId
+		botUserId: account.botUserId,
+		buildContext: ctx.channelRuntime?.inbound.buildContext,
+		log: ctx.log
 	});
 	if (account.commandMenu) await syncClickClackCommandMenu({
 		cfg: ctx.cfg,
@@ -1414,6 +1953,7 @@ async function startClickClackGatewayAccount(ctx) {
 	ctx.setStatus({
 		accountId: account.accountId,
 		running: true,
+		lifecycle: "starting",
 		configured: true,
 		enabled: account.enabled,
 		baseUrl: account.baseUrl
@@ -1469,6 +2009,9 @@ async function startClickClackGatewayAccount(ctx) {
 				};
 				ctx.abortSignal.addEventListener("abort", abort, { once: true });
 				removeAbortListener = () => ctx.abortSignal.removeEventListener("abort", abort);
+				socket.on("open", () => {
+					ctx.setStatus(channelReadyPatch({ accountId: account.accountId }));
+				});
 				socket.on("message", (data) => {
 					if (closing || settled) return;
 					messageQueue = messageQueue.then(async () => {
@@ -1484,6 +2027,11 @@ async function startClickClackGatewayAccount(ctx) {
 				});
 				socket.on("close", () => {
 					closing = true;
+					if (!ctx.abortSignal.aborted) ctx.setStatus({
+						accountId: account.accountId,
+						connected: false,
+						lifecycle: "recovering"
+					});
 					finishAfterQueuedMessages();
 				});
 				socket.on("error", (error) => {
@@ -1493,6 +2041,12 @@ async function startClickClackGatewayAccount(ctx) {
 					}
 					if (closing) return;
 					ctx.log?.warn?.(`[${account.accountId}] ClickClack websocket error; reconnecting: ${error instanceof Error ? error.message : String(error)}`);
+					ctx.setStatus({
+						accountId: account.accountId,
+						connected: false,
+						lifecycle: "recovering",
+						lastError: error instanceof Error ? error.message : String(error)
+					});
 					closing = true;
 					socket.close();
 				});
@@ -1504,10 +2058,7 @@ async function startClickClackGatewayAccount(ctx) {
 			}
 		}
 	} finally {
-		ctx.setStatus({
-			accountId: account.accountId,
-			running: false
-		});
+		ctx.setStatus(channelStoppedPatch({ accountId: account.accountId }));
 	}
 }
 //#endregion
@@ -1610,7 +2161,6 @@ const clickClackPlugin = createChatChannelPlugin({
 		reload: { configPrefixes: ["channels.clickclack"] },
 		configSchema: clickClackConfigSchema,
 		config: clickClackConfigAdapter,
-		setup: clickClackSetupAdapter,
 		setupContract: clickClackSetupContract,
 		setupWizard: clickClackSetupWizard,
 		secrets: {
@@ -1717,4 +2267,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { listPendingDiscussionOpens as C, setClickClackRuntime as D, getClickClackRuntime as E, clearDiscussionBindingGeneration as S, reserveDiscussionBindingGeneration as T, fallbackDiscussionLabel as _, isClickClackDiscussionChannelRevoked as a, slugifyDiscussionLabel as b, discussionAccounts as c, resolveDiscussionBindingAccount as d, bindingMatchesActiveSessionIncarnation as f, discussionExternalRef as g, discussionCredentialFingerprint as h, clearClickClackDiscussionChannelRevoked as i, discussionInfoForBinding as l, getClickClackDiscussionBindingStore as m, buildClickClackTarget as n, markClickClackDiscussionChannelIdentityRevoked as o, bindingMatchesSessionIncarnation as p, parseClickClackTarget as r, markClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, normalizedServerBaseUrl as u, isDiscussionSessionKey as v, recordPendingDiscussionOpen as w, truncateDiscussionDisplayTitle as x, resolveDiscussionLabel as y };
+export { slugifyDiscussionLabel as C, listPendingDiscussionOpens as D, clearPendingDiscussionOpen as E, recordPendingDiscussionOpen as O, resolveDiscussionLabel as S, clearDiscussionBindingGeneration as T, getClickClackDiscussionBindingStore as _, setClickClackRuntime as a, fallbackDiscussionLabel as b, markClickClackDiscussionChannelIdentityRevoked as c, discussionInfoForBinding as d, normalizedServerBaseUrl as f, bindingMatchesActiveSessionIncarnation as g, attachBindingToCurrentActiveSession as h, getClickClackRuntime as i, reserveDiscussionBindingGeneration as k, markClickClackDiscussionChannelRevoked as l, MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS as m, buildClickClackTarget as n, clearClickClackDiscussionChannelRevoked as o, resolveDiscussionBindingAccount as p, parseClickClackTarget as r, isClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, discussionAccounts as u, discussionCredentialFingerprint as v, truncateDiscussionDisplayTitle as w, isDiscussionSessionKey as x, discussionExternalRef as y };