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

package/dist/{channel-CECIpaS0.js → channel-ChO3E9i2.js}

@@ -1,17 +1,23 @@
-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-DAy8vDJK.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-BQ1Zyohu.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 { 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 { createChannelInboundEnvelopeBuilder } from "openclaw/plugin-sdk/channel-inbound";
+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/discussions/binding-generation.ts
@@ -33,9 +39,20 @@ function getGenerationStore(runtime) {
 function reserveDiscussionBindingGeneration(params) {
 	const store = getGenerationStore(params.runtime);
 	const existing = store.lookup(params.sessionKey);
-	if (existing?.destinationIdentity === params.destinationIdentity) return existing.generation;
+	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
 	});
@@ -54,6 +71,7 @@ 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
@@ -66,6 +84,18 @@ function listPendingDiscussionOpens(runtime) {
 		...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);
@@ -104,10 +134,9 @@ function discussionSessionPeerId(identity) {
 function isDiscussionSessionKey(sessionKey) {
 	return sessionKey.includes(":clickclack:") && /:channel:disc-[0-9a-f]{32}$/u.test(sessionKey);
 }
-function discussionExternalRef(installationId, mainSessionKey, sessionId, destinationIdentity, bindingGeneration) {
+function discussionExternalRef(installationId, mainSessionKey, destinationIdentity, bindingGeneration) {
 	return `openclaw:${installationId}:${shortSessionHash([
 		mainSessionKey,
-		sessionId,
 		destinationIdentity,
 		bindingGeneration
 	].join("\0"))}`;
@@ -128,22 +157,41 @@ function discussionSessionKey(params) {
 }
 //#endregion
 //#region extensions/clickclack/src/discussions/binding-store.ts
-function bindingMatchesSessionIncarnation(runtime, sessionKey, binding) {
+function bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
 	const entry = runtime.agent.session.getSessionEntry({
 		sessionKey,
 		readConsistency: "latest"
 	});
-	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId);
+	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId && entry.archivedAt === void 0);
 }
-function bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
-	const entry = runtime.agent.session.getSessionEntry({
-		sessionKey,
+/**
+* Refresh the replaceable session attachment without changing the durable room identity.
+* The store registers persisted state before reindexing, so a failed write leaves the
+* previous attachment authoritative in both persistence and memory.
+*/
+function attachBindingToCurrentActiveSession(params) {
+	const entry = params.runtime.agent.session.getSessionEntry({
+		sessionKey: params.sessionKey,
 		readConsistency: "latest"
 	});
-	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId && entry.archivedAt === void 0);
+	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;
 }
 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}`;
@@ -153,6 +201,7 @@ var ClickClackDiscussionBindingStore = class {
 	#store;
 	#sessionByChannel = /* @__PURE__ */ new Map();
 	#mainByDiscussionSession = /* @__PURE__ */ new Map();
+	#detachedAtBySession = /* @__PURE__ */ new Map();
 	#runtime;
 	constructor(runtime) {
 		this.#runtime = runtime;
@@ -210,6 +259,27 @@ var ClickClackDiscussionBindingStore = class {
 			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 (!oldestSessionKey) return;
+		const binding = this.get(oldestSessionKey);
+		if (!binding || binding.detachedAt === void 0) {
+			this.#detachedAtBySession.delete(oldestSessionKey);
+			return this.oldestDetached();
+		}
+		return {
+			sessionKey: oldestSessionKey,
+			binding
+		};
+	}
 	#index(sessionKey, binding) {
 		this.#sessionByChannel.set(channelKey(binding.serverBaseUrl, binding.channelId), sessionKey);
 		const sideSessionKey = discussionSessionKey({
@@ -223,6 +293,7 @@ var ClickClackDiscussionBindingStore = class {
 			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));
@@ -237,6 +308,7 @@ var ClickClackDiscussionBindingStore = class {
 			externalRef: binding.externalRef
 		});
 		if (sideSessionKey) this.#mainByDiscussionSession.delete(sideSessionKey);
+		this.#detachedAtBySession.delete(sessionKey);
 	}
 };
 function getClickClackDiscussionBindingStore(runtime) {
@@ -327,28 +399,43 @@ function isClickClackDiscussionChannelRevoked(params) {
 //#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);
+	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 (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" };
+	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: matched.binding.agentId,
+		agentId: binding.agentId,
 		mainSessionKey: matched.sessionKey,
-		sessionId: matched.binding.sessionId,
+		sessionId: binding.sessionId,
 		accountId: params.accountId,
-		serverBaseUrl: matched.binding.serverBaseUrl,
-		channelId: matched.binding.channelId,
-		externalRef: matched.binding.externalRef
+		serverBaseUrl: binding.serverBaseUrl,
+		channelId: binding.channelId,
+		externalRef: binding.externalRef
 	});
 	if (!sessionKey) return { state: "revoked" };
 	return {
 		state: "active",
 		route: {
-			agentId: matched.binding.agentId,
+			agentId: binding.agentId,
 			sessionKey,
 			systemPrompt: [
 				"You are the side agent for a ClickClack discussion attached to an OpenClaw session.",
@@ -363,6 +450,21 @@ function resolveClickClackDiscussionRoute(params) {
 //#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)
+	};
+}
+/**
 * Resolves the effective group policy for a ClickClack channel.
 *
 * Lookup order:
@@ -377,9 +479,10 @@ function resolveClickClackGroupPolicy(params) {
 		requireMention: account.requireMention === true,
 		mentionPatterns: account.mentionPatterns ?? []
 	};
-	const wildcard = account.groups?.["*"];
 	const channelKey = channelId?.trim();
-	const exact = channelKey ? account.groups?.[channelKey] : void 0;
+	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
@@ -531,6 +634,10 @@ const clickClackIngressIdentity = {
 	isWildcardEntry: (entry) => normalizeClickClackUserId(entry) === "*",
 	entryIdPrefix: "clickclack-user"
 };
+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;
+}
 function resolveAccountAgentRoute(params) {
 	const runtime = getClickClackRuntime();
 	const peer = {
@@ -633,6 +740,41 @@ async function resolveClickClackInboundAccess(params) {
 		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,
@@ -648,7 +790,13 @@ async function resolveClickClackInboundAccess(params) {
 			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
 		},
-		allowFrom: params.account.allowFrom,
+		contextBinding: {
+			agentId: preparedRoute.route.agentId,
+			sessionKey: preparedRoute.route.sessionKey,
+			messageId: params.message.id,
+			inboundEventKind: "user_request"
+		},
+		allowFrom: ingressAllowFrom,
 		dmPolicy: "allowlist",
 		groupPolicy: "allowlist",
 		mentionFacts,
@@ -666,7 +814,9 @@ async function resolveClickClackInboundAccess(params) {
 		commandAuthorized: resolved.commandAccess.requested ? resolved.commandAccess.authorized : resolved.senderAccess.allowed,
 		requireMention: effectiveGroupPolicy.requireMention,
 		mentionFacts,
-		preparedRoute
+		botLoopProtection,
+		preparedRoute,
+		channelIngress: resolved
 	};
 }
 //#endregion
@@ -716,15 +866,16 @@ async function syncClickClackCommandMenu(params) {
 		await params.client.setBotCommands(commands);
 	} catch (error) {
 		const status = errorStatus(error);
+		const messagePrefix = `[${params.accountId}] ClickClack command menu sync`;
 		if (status === 403) {
-			params.log?.warn?.("ClickClack command menu sync skipped: bot token lacks commands:write");
+			params.log?.warn?.(`${messagePrefix} skipped: ${formatErrorMessage(error)}; verify token/workspace command permissions or set commandMenu: false if menus are not needed`);
 			return;
 		}
 		if (status === 404) {
-			params.log?.debug?.("ClickClack command menu sync skipped: server does not support /api/bots/self/commands");
+			params.log?.debug?.(`${messagePrefix} skipped: server does not support /api/bots/self/commands`);
 			return;
 		}
-		params.log?.warn?.(`ClickClack command menu sync failed: ${formatErrorMessage(error)}`);
+		params.log?.warn?.(`${messagePrefix} failed: ${formatErrorMessage(error)}`);
 	}
 }
 //#endregion
@@ -795,7 +946,8 @@ function activityBody(payload) {
 		status: payload.status,
 		summary: payload.summary,
 		progressText: payload.progressText,
-		meta: payload.meta
+		meta: payload.meta,
+		commandBearing: payload.commandBearing
 	})?.text?.trim();
 	if (line) return line;
 	const head = payload.name?.trim() || payload.title?.trim();
@@ -908,10 +1060,11 @@ function createClickClackActivityPublisher(params) {
 			const kind = normalizedItemKind(payload);
 			if (STREAMING_COMMENTARY_ITEM_KINDS.has(kind)) {
 				handleCommentary(payload);
-				return;
+				return false;
 			}
-			if (SKIPPED_ITEM_KINDS.has(kind)) return;
+			if (SKIPPED_ITEM_KINDS.has(kind)) return false;
 			handleDiscreteItem(payload);
+			return false;
 		},
 		setProvenance: (next) => {
 			provenance = next;
@@ -1080,9 +1233,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,
@@ -1215,6 +1368,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;
@@ -1265,19 +1631,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 { discussionRoute, isDirect, route, target } = access.preparedRoute;
-	if (params.account.replyMode === "model" && !discussionRoute) {
-		await dispatchModelReply({
-			account: params.account,
-			cfg: params.config,
-			message,
-			route,
-			target,
+	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;
@@ -1307,7 +1710,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,
@@ -1354,20 +1758,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,
@@ -1377,11 +1788,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");
@@ -1423,8 +1835,9 @@ async function handleClickClackInbound(params) {
 		} }
 	});
 	try {
-		await dispatchPromise;
+		await dispatch();
 	} finally {
+		await progress?.finalize();
 		await activity?.finalize();
 	}
 }
@@ -1432,8 +1845,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);
@@ -1441,25 +1853,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;
 	}
@@ -1476,8 +1879,11 @@ 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,
@@ -1492,6 +1898,7 @@ async function processEvent(params) {
 		config: params.config,
 		message,
 		access,
+		buildContext: params.buildContext,
 		...correlationId ? { correlationId } : {}
 	});
 }
@@ -1536,16 +1943,19 @@ async function startClickClackGatewayAccount(ctx) {
 		client,
 		event,
 		botUserId: account.botUserId,
+		buildContext: ctx.channelRuntime?.inbound.buildContext,
 		log: ctx.log
 	});
 	if (account.commandMenu) await syncClickClackCommandMenu({
 		cfg: ctx.cfg,
 		client,
-		log: ctx.log
+		log: ctx.log,
+		accountId: account.accountId
 	});
 	ctx.setStatus({
 		accountId: account.accountId,
 		running: true,
+		lifecycle: "starting",
 		configured: true,
 		enabled: account.enabled,
 		baseUrl: account.baseUrl
@@ -1601,6 +2011,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 () => {
@@ -1616,6 +2029,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) => {
@@ -1625,6 +2043,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();
 				});
@@ -1636,10 +2060,7 @@ async function startClickClackGatewayAccount(ctx) {
 			}
 		}
 	} finally {
-		ctx.setStatus({
-			accountId: account.accountId,
-			running: false
-		});
+		ctx.setStatus(channelStoppedPatch({ accountId: account.accountId }));
 	}
 }
 //#endregion
@@ -1737,12 +2158,12 @@ const clickClackPlugin = createChatChannelPlugin({
 		capabilities: {
 			chatTypes: ["direct", "group"],
 			threads: true,
+			media: true,
 			blockStreaming: true
 		},
 		reload: { configPrefixes: ["channels.clickclack"] },
 		configSchema: clickClackConfigSchema,
 		config: clickClackConfigAdapter,
-		setup: clickClackSetupAdapter,
 		setupContract: clickClackSetupContract,
 		setupWizard: clickClackSetupWizard,
 		secrets: {
@@ -1804,7 +2225,11 @@ const clickClackPlugin = createChatChannelPlugin({
 				name: account.name,
 				enabled: account.enabled,
 				configured: account.configured,
-				baseUrl: account.baseUrl
+				extra: {
+					baseUrl: account.baseUrl,
+					tokenSource: account.tokenSource,
+					tokenStatus: account.tokenStatus
+				}
 			})
 		}),
 		gateway: { startAccount: startClickClackGatewayAccount },
@@ -1849,4 +2274,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { truncateDiscussionDisplayTitle as C, reserveDiscussionBindingGeneration as D, recordPendingDiscussionOpen as E, slugifyDiscussionLabel as S, listPendingDiscussionOpens as T, discussionCredentialFingerprint as _, setClickClackRuntime as a, isDiscussionSessionKey as b, markClickClackDiscussionChannelIdentityRevoked as c, discussionInfoForBinding as d, normalizedServerBaseUrl as f, getClickClackDiscussionBindingStore as g, bindingMatchesSessionIncarnation as h, getClickClackRuntime as i, markClickClackDiscussionChannelRevoked as l, bindingMatchesActiveSessionIncarnation as m, buildClickClackTarget as n, clearClickClackDiscussionChannelRevoked as o, resolveDiscussionBindingAccount as p, parseClickClackTarget as r, isClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, discussionAccounts as u, discussionExternalRef as v, clearDiscussionBindingGeneration as w, resolveDiscussionLabel as x, fallbackDiscussionLabel 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 };