@openclaw/buzz 2026.8.1-beta.2 → 2026.9.1-beta.1

package/dist/{channel-CCmyE6Yq.js → channel-BulZqShF.js}

@@ -1,7 +1,7 @@
-import { a as resolveDefaultBuzzAccountId, c as isConfiguredBuzzChannel, d as parseBuzzTarget, i as resolveBuzzPublicKey, l as looksLikeBuzzTarget, n as listBuzzAccountIds, r as resolveBuzzAccount, s as buildBuzzTarget, t as decodeBuzzPrivateKey, u as normalizeBuzzTarget } from "./types-CPFsIZ5Z.js";
-import { a as BuzzConfigSchema, i as startBuzzRoomMembershipNotifications, n as buzzSetupContract, r as discoverBuzzRooms, t as buzzSetupWizard } from "./setup-surface-DCxlD2oY.js";
-import { n as listBuzzDirectoryPeersFromConfig, t as listBuzzDirectoryGroupsFromConfig } from "./directory-config-BXa3Vqzu.js";
-import { a as parseBuzzRoomMembershipEvent, c as parseBuzzAuthTag, i as parseBuzzRoomMembershipChangeEvent, l as openBuzzRelaySubscription, n as BUZZ_ROOM_SYSTEM_KIND, o as connectAuthenticatedBuzzRelay, r as isNewerBuzzRoomMembership, s as connectAuthenticatedBuzzRelaySession, t as BUZZ_ROOM_MEMBERSHIP_KIND } from "./room-membership-CNBlHjTj.js";
+import { a as resolveBuzzPublicKey, c as buildBuzzTarget, d as normalizeBuzzTarget, f as parseBuzzTarget, i as resolveBuzzAccount, l as isConfiguredBuzzChannel, n as decodeBuzzPrivateKey, o as resolveDefaultBuzzAccountId, r as listBuzzAccountIds, t as assertBuzzAccountAvailable, u as looksLikeBuzzTarget } from "./types-BN_HOsnq.js";
+import { a as BuzzConfigSchema, i as startBuzzRoomMembershipNotifications, n as buzzSetupContract, r as discoverBuzzRooms, t as buzzSetupWizard } from "./setup-surface-BvQgEJ7O.js";
+import { n as listBuzzDirectoryPeersFromConfig, t as listBuzzDirectoryGroupsFromConfig } from "./directory-config-BesCse0q.js";
+import { a as parseBuzzRoomMembershipEvent, c as parseBuzzAuthTag, i as parseBuzzRoomMembershipChangeEvent, l as openBuzzRelaySubscription, n as BUZZ_ROOM_SYSTEM_KIND, o as connectAuthenticatedBuzzRelay, r as isNewerBuzzRoomMembership, s as connectAuthenticatedBuzzRelaySession, t as BUZZ_ROOM_MEMBERSHIP_KIND, u as queryBuzzRelaySnapshot } from "./room-membership-DSAkyE0a.js";
 import { a as formatBuzzMessageForAgent, c as inspectBuzzMentionSyntax, i as buildBuzzMessageTags, l as resolveBuzzMessageMentions, n as BUZZ_INBOUND_MESSAGE_KINDS, o as isBuzzInboundMessageKind, r as BUZZ_TYPING_INDICATOR_KIND, s as parseBuzzMessageEvent, t as BUZZ_DIFF_MESSAGE_KIND } from "./message-event-CFw7gGLi.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-D19RiJv_.js";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
@@ -11,6 +11,7 @@ import { createChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-run
 import { parseThreadSessionSuffix } from "openclaw/plugin-sdk/routing";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
 import { finalizeEvent } from "nostr-tools";
+import { chunkItems } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { attachChannelToResult } from "openclaw/plugin-sdk/channel-send-result";
 import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
@@ -20,6 +21,7 @@ import { buildChannelInboundEventContext, resolveChannelInboundRouteEnvelope } f
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/logging-core";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import { createHash } from "node:crypto";
 const BUZZ_ROOM_METADATA_KIND = 39e3;
 const DEFAULT_BUZZ_DIRECTORY_PROFILE_LIMIT = 2e3;
 const HEX_PUBLIC_KEY_PATTERN = /^[0-9a-f]{64}$/u;
@@ -250,58 +252,27 @@ const PROFILE_SUBSCRIPTION_REPLACED_REASON = "directory profile subscription rep
 const PROFILE_SUBSCRIPTION_FAILED_REASON = "directory profile subscription generation failed";
 const DIRECTORY_SHUTDOWN_REASON = "directory shutdown";
 const DIRECTORY_QUERY_COMPLETE_REASON = "directory query complete";
-const DIRECTORY_QUERY_TIMEOUT_MS = 1e4;
 const PROFILE_SUBSCRIPTION_READY_TIMEOUT_MS = 1e4;
-function chunkValues(values, size) {
-	const chunks = [];
-	for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
-	return chunks;
-}
 async function queryBuzzDirectoryBatch(params) {
 	params.signal?.throwIfAborted();
-	await new Promise((resolve, reject) => {
-		let settled = false;
-		let receivedEose = false;
-		const timeout = setTimeout(() => {
-			const error = /* @__PURE__ */ new Error("Timed out loading Buzz directory snapshot");
-			finish(error);
-			if (params.onTimeout) params.onTimeout(error);
-			else params.relay.close();
-		}, DIRECTORY_QUERY_TIMEOUT_MS);
-		const subscriptionRef = {};
-		const finish = (error) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			params.signal?.removeEventListener("abort", onAbort);
-			if (receivedEose) subscriptionRef.current?.close(DIRECTORY_QUERY_COMPLETE_REASON);
-			if (error === void 0) resolve();
-			else reject(error instanceof Error ? error : new Error("Buzz directory query failed", { cause: error }));
-		};
-		const onAbort = () => finish(params.signal?.reason ?? /* @__PURE__ */ new Error("Buzz directory query aborted"));
-		params.signal?.addEventListener("abort", onAbort, { once: true });
-		try {
-			subscriptionRef.current = openBuzzRelaySubscription(params.relay, [params.filter], {
-				onevent: params.onEvent,
-				oneose: () => {
-					receivedEose = true;
-					if (settled) subscriptionRef.current?.close(DIRECTORY_QUERY_COMPLETE_REASON);
-					else finish();
-				},
-				onclose: (reason) => {
-					if (reason !== DIRECTORY_QUERY_COMPLETE_REASON) finish(/* @__PURE__ */ new Error(`Buzz directory query closed: ${reason}`));
-				}
-			});
-		} catch (error) {
-			finish(error);
-			return;
-		}
-		if (settled && receivedEose) subscriptionRef.current.close(DIRECTORY_QUERY_COMPLETE_REASON);
-		if (params.signal?.aborted) onAbort();
+	await queryBuzzRelaySnapshot({
+		relay: params.relay,
+		filters: [params.filter],
+		signal: params.signal,
+		timeoutMessage: "Timed out loading Buzz directory snapshot",
+		abortMessage: "Buzz directory query aborted",
+		failureMessage: "Buzz directory query failed",
+		closeReason: DIRECTORY_QUERY_COMPLETE_REASON,
+		closeMessage: (reason) => `Buzz directory query closed: ${reason}`,
+		onEvent: params.onEvent,
+		result: () => {},
+		onTimeout: params.onTimeout,
+		closeRelayOnTimeout: !params.onTimeout,
+		checkAbortAfterSubscribe: true
 	});
 }
 async function queryBuzzDirectoryProfiles(params) {
-	for (const authors of chunkValues(params.publicKeys, 200)) await queryBuzzDirectoryBatch({
+	for (const authors of chunkItems(params.publicKeys, 200)) await queryBuzzDirectoryBatch({
 		relay: params.relay,
 		filter: {
 			kinds: [0],
@@ -316,7 +287,7 @@ async function queryBuzzDirectoryProfiles(params) {
 	});
 }
 async function queryBuzzDirectoryRooms(params) {
-	for (const roomIds of chunkValues(params.channelIds, BUZZ_ROOM_QUERY_CHUNK_SIZE)) await queryBuzzDirectoryBatch({
+	for (const roomIds of chunkItems(params.channelIds, BUZZ_ROOM_QUERY_CHUNK_SIZE)) await queryBuzzDirectoryBatch({
 		relay: params.relay,
 		filter: {
 			kinds: [BUZZ_ROOM_METADATA_KIND],
@@ -360,7 +331,7 @@ function startBuzzDirectoryRelay(params) {
 		const publicKeys = queuedProfilePublicKeys;
 		queuedProfilePublicKeys = void 0;
 		closeProfileGeneration(PROFILE_SUBSCRIPTION_REPLACED_REASON);
-		const authorChunks = chunkValues(publicKeys, 200);
+		const authorChunks = chunkItems(publicKeys, 200);
 		if (authorChunks.length === 0) return;
 		const generation = {
 			subscriptions: [],
@@ -473,7 +444,6 @@ const CHANNEL_ADD_POLICIES = /* @__PURE__ */ new Set([
 	"owner_only",
 	"nobody"
 ]);
-const PROFILE_QUERY_TIMEOUT_MS = 1e4;
 function parseProfileContent(event) {
 	if (!event) return {};
 	try {
@@ -499,33 +469,10 @@ function readNonEmptyString(content, key) {
 }
 async function queryCurrentProfiles(params) {
 	params.signal?.throwIfAborted();
-	return await new Promise((resolve, reject) => {
-		const latestByKind = /* @__PURE__ */ new Map();
-		const state = {
-			settled: false,
-			receivedEose: false
-		};
-		const timeout = setTimeout(() => {
-			const error = /* @__PURE__ */ new Error("Timed out loading current Buzz profile");
-			finish(error);
-			params.onTimeout?.(error);
-			params.relay.close();
-		}, PROFILE_QUERY_TIMEOUT_MS);
-		const finish = (error) => {
-			if (state.settled) return;
-			state.settled = true;
-			clearTimeout(timeout);
-			params.signal?.removeEventListener("abort", onAbort);
-			if (state.receivedEose) state.subscription?.close("profile query complete");
-			if (error !== void 0) {
-				reject(error instanceof Error ? error : new Error("Buzz profile query failed", { cause: error }));
-				return;
-			}
-			resolve(latestByKind);
-		};
-		const onAbort = () => finish(params.signal?.reason ?? /* @__PURE__ */ new Error("Buzz profile query aborted"));
-		params.signal?.addEventListener("abort", onAbort, { once: true });
-		state.subscription = openBuzzRelaySubscription(params.relay, [{
+	const latestByKind = /* @__PURE__ */ new Map();
+	return await queryBuzzRelaySnapshot({
+		relay: params.relay,
+		filters: [{
 			kinds: [PROFILE_KIND],
 			authors: [params.publicKey],
 			limit: 1
@@ -533,21 +480,19 @@ async function queryCurrentProfiles(params) {
 			kinds: [AGENT_PROFILE_KIND],
 			authors: [params.publicKey],
 			limit: 1
-		}], {
-			onevent: (event) => {
-				const current = latestByKind.get(event.kind);
-				if (!current || event.created_at > current.created_at) latestByKind.set(event.kind, event);
-			},
-			oneose: () => {
-				state.receivedEose = true;
-				if (state.settled) state.subscription?.close("profile query complete");
-				else finish();
-			},
-			onclose: (reason) => {
-				if (reason !== "profile query complete") finish(/* @__PURE__ */ new Error(`Buzz profile query closed: ${reason}`));
-			}
-		});
-		if (state.settled && state.receivedEose) state.subscription.close("profile query complete");
+		}],
+		signal: params.signal,
+		timeoutMessage: "Timed out loading current Buzz profile",
+		abortMessage: "Buzz profile query aborted",
+		failureMessage: "Buzz profile query failed",
+		closeReason: "profile query complete",
+		closeMessage: (reason) => `Buzz profile query closed: ${reason}`,
+		onEvent: (event) => {
+			const current = latestByKind.get(event.kind);
+			if (!current || event.created_at > current.created_at) latestByKind.set(event.kind, event);
+		},
+		result: () => latestByKind,
+		onTimeout: params.onTimeout
 	});
 }
 function buildProfileEvent(params) {
@@ -733,56 +678,29 @@ function resolveBuzzRoomHistoryLimit(roomCount) {
 //#region extensions/buzz/src/room-membership-query.ts
 const RELAY_QUERY_EVENT_LIMIT = 1e3;
 const MEMBERSHIP_QUERY_COMPLETE_REASON = "membership snapshot loaded";
-const MEMBERSHIP_QUERY_TIMEOUT_MS = 1e4;
 async function queryBuzzRoomMembershipBatch(params) {
 	const configuredRooms = new Set(params.channelIds);
 	const memberships = /* @__PURE__ */ new Map();
-	return await new Promise((resolve, reject) => {
-		let settled = false;
-		let receivedEose = false;
-		const timeout = setTimeout(() => {
-			finish(/* @__PURE__ */ new Error("Timed out loading Buzz room membership snapshot"));
-			params.relay.close();
-		}, MEMBERSHIP_QUERY_TIMEOUT_MS);
-		const subscriptionRef = {};
-		const finish = (error) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			params.signal?.removeEventListener("abort", onAbort);
-			if (receivedEose) subscriptionRef.current?.close(MEMBERSHIP_QUERY_COMPLETE_REASON);
-			if (error === void 0) resolve(memberships);
-			else reject(error instanceof Error ? error : new Error("Buzz room membership query failed", { cause: error }));
-		};
-		const onAbort = () => finish(params.signal?.reason ?? /* @__PURE__ */ new Error("Buzz room membership query aborted"));
-		params.signal?.addEventListener("abort", onAbort, { once: true });
-		try {
-			subscriptionRef.current = openBuzzRelaySubscription(params.relay, [{
-				kinds: [BUZZ_ROOM_MEMBERSHIP_KIND],
-				authors: [params.relayPublicKey],
-				"#d": params.channelIds,
-				limit: params.channelIds.length
-			}], {
-				onevent: (event) => {
-					const membership = parseBuzzRoomMembershipEvent(event, params.relayPublicKey);
-					if (!membership || !configuredRooms.has(membership.roomId) || !isNewerBuzzRoomMembership(membership, memberships.get(membership.roomId))) return;
-					memberships.set(membership.roomId, membership);
-				},
-				oneose: () => {
-					receivedEose = true;
-					if (settled) subscriptionRef.current?.close(MEMBERSHIP_QUERY_COMPLETE_REASON);
-					else finish();
-				},
-				onclose: (reason) => {
-					if (reason !== MEMBERSHIP_QUERY_COMPLETE_REASON) finish(/* @__PURE__ */ new Error(`Buzz room membership query closed: ${reason}`));
-				}
-			});
-		} catch (error) {
-			finish(error);
-			return;
-		}
-		if (settled && receivedEose) subscriptionRef.current.close(MEMBERSHIP_QUERY_COMPLETE_REASON);
-		if (params.signal?.aborted) onAbort();
+	return await queryBuzzRelaySnapshot({
+		relay: params.relay,
+		filters: [{
+			kinds: [BUZZ_ROOM_MEMBERSHIP_KIND],
+			authors: [params.relayPublicKey],
+			"#d": params.channelIds,
+			limit: params.channelIds.length
+		}],
+		signal: params.signal,
+		timeoutMessage: "Timed out loading Buzz room membership snapshot",
+		abortMessage: "Buzz room membership query aborted",
+		failureMessage: "Buzz room membership query failed",
+		closeReason: MEMBERSHIP_QUERY_COMPLETE_REASON,
+		closeMessage: (reason) => `Buzz room membership query closed: ${reason}`,
+		onEvent: (event) => {
+			const membership = parseBuzzRoomMembershipEvent(event, params.relayPublicKey);
+			if (membership && configuredRooms.has(membership.roomId) && isNewerBuzzRoomMembership(membership, memberships.get(membership.roomId))) memberships.set(membership.roomId, membership);
+		},
+		result: () => memberships,
+		checkAbortAfterSubscribe: true
 	});
 }
 async function queryBuzzRoomMemberships(params) {
@@ -798,62 +716,35 @@ async function queryBuzzRoomMemberships(params) {
 }
 //#endregion
 //#region extensions/buzz/src/history-catchup.ts
-const HISTORY_PAGE_TIMEOUT_MS = 1e4;
 const HISTORY_PAGE_COMPLETE_REASON = "buzz room history page loaded";
 async function queryBuzzRoomHistoryPage(params) {
 	const events = [];
 	let overLimit = false;
-	return await new Promise((resolve, reject) => {
-		let settled = false;
-		let receivedEose = false;
-		const timeout = setTimeout(() => {
-			const error = /* @__PURE__ */ new Error(`Timed out loading Buzz room history for ${params.channelId}`);
-			finish(error);
-			params.relay.close();
-		}, HISTORY_PAGE_TIMEOUT_MS);
-		const subscriptionRef = {};
-		const finish = (error) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			params.signal?.removeEventListener("abort", onAbort);
-			if (receivedEose) subscriptionRef.current?.close(HISTORY_PAGE_COMPLETE_REASON);
-			if (error === void 0) resolve({
-				events,
-				overLimit
-			});
-			else reject(error instanceof Error ? error : new Error("Buzz room history query failed", { cause: error }));
-		};
-		const onAbort = () => finish(params.signal?.reason ?? /* @__PURE__ */ new Error("Buzz room history query aborted"));
-		params.signal?.addEventListener("abort", onAbort, { once: true });
-		try {
-			subscriptionRef.current = openBuzzRelaySubscription(params.relay, [{
-				kinds: [...BUZZ_INBOUND_MESSAGE_KINDS],
-				"#h": [params.channelId],
-				since: params.since,
-				until: params.until,
-				...params.requestLimit === void 0 ? {} : { limit: params.requestLimit }
-			}], {
-				onevent: (event) => {
-					if (params.skipEventIds?.has(event.id)) return;
-					if (events.length < params.maxEvents) events.push(event);
-					else overLimit = true;
-				},
-				oneose: () => {
-					receivedEose = true;
-					if (settled) subscriptionRef.current?.close(HISTORY_PAGE_COMPLETE_REASON);
-					else finish();
-				},
-				onclose: (reason) => {
-					if (reason !== HISTORY_PAGE_COMPLETE_REASON) finish(/* @__PURE__ */ new Error(`Buzz room history query closed for ${params.channelId}: ${reason}`));
-				}
-			});
-		} catch (error) {
-			finish(error);
-			return;
-		}
-		if (settled && receivedEose) subscriptionRef.current.close(HISTORY_PAGE_COMPLETE_REASON);
-		if (params.signal?.aborted) onAbort();
+	return await queryBuzzRelaySnapshot({
+		relay: params.relay,
+		filters: [{
+			kinds: [...BUZZ_INBOUND_MESSAGE_KINDS],
+			"#h": [params.channelId],
+			since: params.since,
+			until: params.until,
+			...params.requestLimit === void 0 ? {} : { limit: params.requestLimit }
+		}],
+		signal: params.signal,
+		timeoutMessage: `Timed out loading Buzz room history for ${params.channelId}`,
+		abortMessage: "Buzz room history query aborted",
+		failureMessage: "Buzz room history query failed",
+		closeReason: HISTORY_PAGE_COMPLETE_REASON,
+		closeMessage: (reason) => `Buzz room history query closed for ${params.channelId}: ${reason}`,
+		onEvent: (event) => {
+			if (params.skipEventIds?.has(event.id)) return;
+			if (events.length < params.maxEvents) events.push(event);
+			else overLimit = true;
+		},
+		result: () => ({
+			events,
+			overLimit
+		}),
+		checkAbortAfterSubscribe: true
 	});
 }
 async function drainBuzzRoomHistoryRange(params) {
@@ -1027,6 +918,14 @@ async function createBuzzRoomMembershipTracker(params) {
 		params.onFatalError?.(error instanceof Error ? error : new Error(String(error)));
 		params.relay.close();
 	};
+	const replaceMembership = (membership) => {
+		if (membership.roles.get(params.botPublicKey) !== "bot" || !membership.members.has(params.botPublicKey)) {
+			blockedRooms.add(membership.roomId);
+			throw new Error(`Buzz bot no longer has the Bot role in room ${membership.roomId}`);
+		}
+		memberships.set(membership.roomId, membership);
+		params.onMembershipsChanged?.(effectiveMemberships());
+	};
 	const queryMembership = (channelId) => {
 		const query = membershipQueryTail.then(async () => (await queryBuzzRoomMemberships({
 			relay: params.relay,
@@ -1038,8 +937,6 @@ async function createBuzzRoomMembershipTracker(params) {
 		return query;
 	};
 	const refreshMembership = async (channelId, state) => {
-		const baseline = memberships.get(channelId);
-		if (!baseline) throw new Error(`Missing Buzz room membership for ${channelId}`);
 		for (const delayMs of MEMBERSHIP_REFRESH_DELAYS_MS) {
 			const generation = state.generation;
 			state.lastAttemptedGeneration = generation;
@@ -1053,19 +950,14 @@ async function createBuzzRoomMembershipTracker(params) {
 				continue;
 			}
 			if (state.generation !== generation || !refreshed) continue;
+			const current = memberships.get(channelId);
+			if (current && isNewerBuzzRoomMembership(current, refreshed)) refreshed = current;
 			const pending = pendingMemberships.get(channelId);
-			const pendingMatches = !pending || [...pending].every(([publicKey, expected]) => refreshed.members.has(publicKey) === (expected === "present"));
-			const botMembershipChanged = pending?.has(params.botPublicKey) === true;
-			if (!pendingMatches || botMembershipChanged && !isNewerBuzzRoomMembership(refreshed, baseline)) continue;
-			if (refreshed.roles.get(params.botPublicKey) !== "bot" || !refreshed.members.has(params.botPublicKey)) {
-				blockedRooms.add(channelId);
-				throw new Error(`Buzz bot no longer has the Bot role in room ${channelId}`);
-			}
-			memberships.set(channelId, refreshed);
+			if (!(!pending || [...pending].every(([publicKey, expected]) => refreshed.members.has(publicKey) === (expected === "present")))) continue;
 			pendingMemberships.delete(channelId);
 			deniedMembers.delete(channelId);
 			blockedRooms.delete(channelId);
-			params.onMembershipsChanged?.(effectiveMemberships());
+			replaceMembership(refreshed);
 			return;
 		}
 		if (state.generation !== state.lastAttemptedGeneration) return;
@@ -1116,6 +1008,15 @@ async function createBuzzRoomMembershipTracker(params) {
 		return refreshMembershipOnce(channelId);
 	};
 	const handleRoomEvent = (event, reservation) => {
+		if (event.kind === 39002) {
+			const membership = parseBuzzRoomMembershipEvent(event, params.relayPublicKey);
+			if (membership && memberships.has(membership.roomId) && isNewerBuzzRoomMembership(membership, memberships.get(membership.roomId))) try {
+				replaceMembership(membership);
+			} catch (error) {
+				reportSystemEventError(error);
+			}
+			return;
+		}
 		if (isBuzzInboundMessageKind(event.kind)) {
 			params.onMessageEvent(event, isMember, reservation);
 			return;
@@ -1135,38 +1036,50 @@ async function createBuzzRoomMembershipTracker(params) {
 	}, MEMBERSHIP_READY_TIMEOUT_MS);
 	const subscriptions = [];
 	try {
-		for (const channelId of params.channelIds) subscriptions.push(openBuzzRelaySubscription(params.relay, [{
-			kinds: [BUZZ_ROOM_SYSTEM_KIND, BUZZ_ROOM_METADATA_EDIT_KIND],
-			"#h": [channelId],
-			since: params.since
-		}, {
-			kinds: [...BUZZ_INBOUND_MESSAGE_KINDS],
-			"#h": [channelId],
-			since: params.messageSince,
-			limit: params.messageLimit
-		}], {
-			onevent: (event) => {
-				if (!historicalRooms.has(channelId) && isBuzzInboundMessageKind(event.kind)) {
-					const page = historyPages.get(channelId);
-					if (page) {
-						page.count += 1;
-						page.oldest = Math.min(page.oldest, event.created_at);
-					} else historyPages.set(channelId, {
-						count: 1,
-						oldest: event.created_at
-					});
+		for (const channelId of params.channelIds) {
+			const filters = [
+				{
+					kinds: [BUZZ_ROOM_SYSTEM_KIND, BUZZ_ROOM_METADATA_EDIT_KIND],
+					"#h": [channelId],
+					since: params.since
+				},
+				{
+					kinds: [BUZZ_ROOM_MEMBERSHIP_KIND],
+					authors: [params.relayPublicKey],
+					"#d": [channelId],
+					limit: 1
+				},
+				{
+					kinds: [...BUZZ_INBOUND_MESSAGE_KINDS],
+					"#h": [channelId],
+					since: params.messageSince(channelId),
+					limit: params.messageLimit
 				}
-				handleRoomEvent(event);
-			},
-			oneose: () => {
-				historicalRooms.add(channelId);
-				if (historicalRooms.size === params.channelIds.length) resolveHistorical?.();
-			},
-			onclose: (reason) => {
-				if (!historicalRooms.has(channelId)) rejectHistorical?.(/* @__PURE__ */ new Error(`Buzz membership subscription closed for ${channelId}: ${reason}`));
-				else if (reason !== "shutdown" && reason !== "relay connection closed by us" && reason !== MEMBERSHIP_TRACKER_SETUP_CLOSE_REASON && !params.signal?.aborted) params.onFatalError?.(/* @__PURE__ */ new Error(`Buzz membership subscription closed for ${channelId}: ${reason}`));
-			}
-		}));
+			];
+			subscriptions.push(openBuzzRelaySubscription(params.relay, filters, {
+				onevent: (event) => {
+					if (!historicalRooms.has(channelId) && isBuzzInboundMessageKind(event.kind)) {
+						const page = historyPages.get(channelId);
+						if (page) {
+							page.count += 1;
+							page.oldest = Math.min(page.oldest, event.created_at);
+						} else historyPages.set(channelId, {
+							count: 1,
+							oldest: event.created_at
+						});
+					}
+					handleRoomEvent(event);
+				},
+				oneose: () => {
+					historicalRooms.add(channelId);
+					if (historicalRooms.size === params.channelIds.length) resolveHistorical?.();
+				},
+				onclose: (reason) => {
+					if (!historicalRooms.has(channelId)) rejectHistorical?.(/* @__PURE__ */ new Error(`Buzz membership subscription closed for ${channelId}: ${reason}`));
+					else if (reason !== "shutdown" && reason !== "relay connection closed by us" && reason !== MEMBERSHIP_TRACKER_SETUP_CLOSE_REASON && !params.signal?.aborted) params.onFatalError?.(/* @__PURE__ */ new Error(`Buzz membership subscription closed for ${channelId}: ${reason}`));
+				}
+			}, filters.map((filter) => Object.assign({}, filter, { "#h": [channelId] }))));
+		}
 		await historicalReady;
 	} catch (error) {
 		if (params.relay.connected) {
@@ -1187,7 +1100,7 @@ async function createBuzzRoomMembershipTracker(params) {
 					if (await catchUpBuzzRoomHistory({
 						relay: params.relay,
 						channelId,
-						since: params.messageSince,
+						since: params.messageSince(channelId),
 						until: page.oldest,
 						limit: params.messageLimit,
 						reserveCapacity: params.reserveDispatchCapacity,
@@ -1208,10 +1121,11 @@ async function createBuzzRoomMembershipTracker(params) {
 const BUZZ_RELAY_MAX_SUBSCRIPTIONS = 1024;
 const BUZZ_RELAY_NON_ROOM_PROFILE_SUBSCRIPTION_RESERVE = 4;
 const BUZZ_DIRECTORY_MAX_PROFILE_SUBSCRIPTIONS = 10;
+const BUZZ_MAX_CONFIGURED_ROOMS = BUZZ_RELAY_MAX_SUBSCRIPTIONS - BUZZ_RELAY_NON_ROOM_PROFILE_SUBSCRIPTION_RESERVE;
 function resolveBuzzSubscriptionBudget(roomCount) {
 	if (!Number.isSafeInteger(roomCount) || roomCount < 0) throw new Error("Buzz configured room count must be a non-negative integer");
 	const availableProfileSubscriptions = BUZZ_RELAY_MAX_SUBSCRIPTIONS - BUZZ_RELAY_NON_ROOM_PROFILE_SUBSCRIPTION_RESERVE - roomCount;
-	if (availableProfileSubscriptions < 0) throw new Error(`Buzz supports at most ${BUZZ_RELAY_MAX_SUBSCRIPTIONS - BUZZ_RELAY_NON_ROOM_PROFILE_SUBSCRIPTION_RESERVE} configured rooms per account`);
+	if (availableProfileSubscriptions < 0) throw new Error(`Buzz supports at most ${BUZZ_MAX_CONFIGURED_ROOMS} configured rooms per account`);
 	return { profileLimit: Math.min(BUZZ_DIRECTORY_MAX_PROFILE_SUBSCRIPTIONS, availableProfileSubscriptions) * 200 };
 }
 //#endregion
@@ -1257,9 +1171,11 @@ function startBuzzPresenceHeartbeat(params) {
 			await params.relay.publish(buildBuzzPresenceEvent(params.secretKey));
 			errorReported = false;
 		} catch (error) {
-			if (!stopped && !errorReported) {
+			const failure = error instanceof Error ? error : new Error("Buzz presence heartbeat failed", { cause: error });
+			if (!stopped && failure.message === "publish timed out") params.onFatalError(failure);
+			else if (!stopped && !errorReported) {
 				errorReported = true;
-				params.onError?.(error instanceof Error ? error : new Error("Buzz presence heartbeat failed", { cause: error }));
+				params.onError?.(failure);
 			}
 		} finally {
 			publishInFlight = false;
@@ -1345,10 +1261,9 @@ async function startBuzzBus(options) {
 	const sessionStartedAt = Math.floor(Date.now() / 1e3);
 	const lifecycleAbort = new AbortController();
 	const signal = options.signal ? AbortSignal.any([options.signal, lifecycleAbort.signal]) : lifecycleAbort.signal;
-	let fatalErrorReported = false;
 	const reportFatalError = (error) => {
-		if (signal.aborted || fatalErrorReported) return;
-		fatalErrorReported = true;
+		if (signal.aborted) return;
+		lifecycleAbort.abort(error);
 		options.onFatalError?.(error);
 	};
 	const replayGuard = createChannelReplayGuard({
@@ -1458,7 +1373,7 @@ async function startBuzzBus(options) {
 			channelIds: activeChannelIds,
 			botPublicKey: publicKey,
 			since: sessionStartedAt,
-			messageSince: options.since ?? sessionStartedAt,
+			messageSince: (channelId) => options.since?.(channelId) ?? sessionStartedAt,
 			messageLimit: resolveBuzzRoomHistoryLimit(activeChannelIds.length),
 			reserveDispatchCapacity: (slots) => dispatchQueue.reserveCapacity(slots),
 			onHistoryError: options.onHistoryError,
@@ -1468,7 +1383,12 @@ async function startBuzzBus(options) {
 				if (!message || !isMember(message.channelId, event.pubkey)) return;
 				if ((reservation ?? dispatchQueue).enqueue(async () => {
 					await replayGuard.processGuarded(event, async () => {
-						await options.onMessage(message, bus, signal);
+						const assertCurrent = () => {
+							signal.throwIfAborted();
+							if (!isMember(message.channelId, event.pubkey)) throw new Error("Buzz sender is no longer a room member");
+						};
+						assertCurrent();
+						await options.onMessage(message, bus, signal, assertCurrent);
 					});
 				}) !== "overflow") return;
 				if (reservation) {
@@ -1495,7 +1415,8 @@ async function startBuzzBus(options) {
 		stopPresenceHeartbeat = startBuzzPresenceHeartbeat({
 			relay,
 			secretKey,
-			onError: options.onPresenceError
+			onError: options.onPresenceError,
+			onFatalError: reportFatalError
 		});
 		if (options.profileName?.trim()) syncBuzzProfile({
 			relay,
@@ -1573,8 +1494,8 @@ async function handleBuzzInbound(params) {
 			canDetectMention: true,
 			wasMentioned
 		},
-		groupPolicy: account.config.groupPolicy,
-		groupAllowFrom: account.config.groupAllowFrom,
+		groupPolicy: groupConfig?.groupPolicy ?? account.config.groupPolicy,
+		groupAllowFrom: groupConfig?.groupAllowFrom ?? account.config.groupAllowFrom,
 		policy: { activation: {
 			requireMention: groupConfig?.requireMention ?? true,
 			allowTextCommands: true
@@ -1584,6 +1505,7 @@ async function handleBuzzInbound(params) {
 			hasControlCommand
 		} : void 0
 	});
+	params.assertCurrent();
 	if (access.ingress.admission !== "dispatch") return;
 	const senderName = bus.directory.resolveSenderName(message.senderPubkey);
 	const roomName = bus.directory.resolveRoomName(channelId);
@@ -1643,6 +1565,11 @@ async function handleBuzzInbound(params) {
 			BuzzEventKind: message.kind
 		}
 	});
+	const replyTarget = {
+		channelId,
+		threadId: message.threadId,
+		replyToId: message.threadId ?? message.id
+	};
 	await runtime.channel.inbound.dispatch({
 		cfg,
 		channel: "buzz",
@@ -1658,10 +1585,8 @@ async function handleBuzzInbound(params) {
 				const text = payload && typeof payload === "object" && "text" in payload ? payload.text ?? "" : "";
 				if (!text.trim()) return;
 				await bus.sendText({
-					channelId,
-					text,
-					threadId: message.threadId,
-					replyToId: message.id
+					...replyTarget,
+					text
 				});
 			},
 			onError: (error) => {
@@ -1671,11 +1596,7 @@ async function handleBuzzInbound(params) {
 		replyOptions: { abortSignal: signal },
 		replyPipeline: { typing: {
 			start: async () => {
-				await bus.sendTyping({
-					channelId,
-					threadId: message.threadId,
-					replyToId: message.id
-				});
+				await bus.sendTyping(replyTarget);
 			},
 			keepaliveIntervalMs: 3e3,
 			onStartError: (error) => {
@@ -1688,6 +1609,38 @@ async function handleBuzzInbound(params) {
 	});
 }
 //#endregion
+//#region extensions/buzz/src/recovery-watermark.ts
+function roomCursorKey(channelId) {
+	return `room:${channelId}`;
+}
+function openBuzzRecoveryWatermarkStore(params) {
+	const accountScope = createHash("sha256").update(params.accountId).digest("hex").slice(0, 16);
+	return getBuzzRuntime().state.openKeyedStore({
+		namespace: `buzz.recovery-watermark-${accountScope}`,
+		maxEntries: BUZZ_MAX_CONFIGURED_ROOMS,
+		overflowPolicy: "reject-new"
+	});
+}
+async function resolveBuzzRecoverySince(params) {
+	const { store, channelIds, nowSeconds, lookbackSeconds } = params;
+	const configuredKeys = new Set(channelIds.map(roomCursorKey));
+	for (const { key } of await store.entries()) if (key.startsWith("room:") && !configuredKeys.has(key)) await store.delete(key);
+	const sinceByRoom = /* @__PURE__ */ new Map();
+	const retentionFloor = nowSeconds - lookbackSeconds;
+	for (const channelId of channelIds) {
+		const key = roomCursorKey(channelId);
+		const activation = await store.lookup(key);
+		if (activation === void 0) {
+			await store.register(key, { seconds: nowSeconds });
+			sinceByRoom.set(channelId, nowSeconds);
+			continue;
+		}
+		if (typeof activation.seconds !== "number" || !Number.isFinite(activation.seconds)) throw new Error(`Invalid Buzz recovery watermark for room ${channelId}`);
+		sinceByRoom.set(channelId, Math.min(Math.max(activation.seconds, retentionFloor), nowSeconds));
+	}
+	return sinceByRoom;
+}
+//#endregion
 //#region extensions/buzz/src/gateway.ts
 const activeBuses = /* @__PURE__ */ new Map();
 const RECONNECT_BACKOFF = {
@@ -1720,10 +1673,8 @@ function resolveBuzzProfileName(params) {
 }
 async function startBuzzGatewayAccount(ctx) {
 	const buildContext = ctx.channelRuntime?.inbound.buildContext;
-	const account = resolveBuzzAccount({
-		cfg: ctx.cfg,
-		accountId: ctx.account.accountId
-	});
+	const account = ctx.account;
+	assertBuzzAccountAvailable(account);
 	if (!account.configured) throw new Error(`Buzz is not configured for account "${account.accountId}"`);
 	const channelIds = Object.entries(account.config.groups ?? {}).filter(([, config]) => config.enabled !== false).map(([channelId]) => parseBuzzTarget(channelId));
 	if (channelIds.length === 0) throw new Error("Buzz requires at least one channels.buzz.groups entry");
@@ -1733,7 +1684,7 @@ async function startBuzzGatewayAccount(ctx) {
 		account,
 		channelIds
 	});
-	let hasAttemptedSession = false;
+	const watermarkStore = openBuzzRecoveryWatermarkStore({ accountId: account.accountId });
 	let reconnectAttempt = 0;
 	while (!ctx.abortSignal.aborted) {
 		let bus;
@@ -1744,8 +1695,13 @@ async function startBuzzGatewayAccount(ctx) {
 			reportBusFailure = resolve;
 		});
 		try {
-			const sessionSince = Math.floor(Date.now() / 1e3) - (hasAttemptedSession ? RECONNECT_LOOKBACK_SECONDS : 0);
-			hasAttemptedSession = true;
+			const nowSeconds = Math.floor(Date.now() / 1e3);
+			const sinceByRoom = await resolveBuzzRecoverySince({
+				store: watermarkStore,
+				channelIds,
+				nowSeconds,
+				lookbackSeconds: RECONNECT_LOOKBACK_SECONDS
+			});
 			bus = await startBuzzBus({
 				accountId: account.accountId,
 				relayUrl: account.relayUrl,
@@ -1753,9 +1709,9 @@ async function startBuzzGatewayAccount(ctx) {
 				authTag: account.authTag,
 				profileName,
 				channelIds,
-				since: sessionSince,
+				since: (channelId) => sinceByRoom.get(channelId) ?? nowSeconds,
 				signal: ctx.abortSignal,
-				onMessage: async (message, sessionBus, signal) => {
+				onMessage: async (message, sessionBus, signal, assertCurrent) => {
 					if (!isConfiguredBuzzChannel(configuredChannelIds, message.channelId)) return;
 					await handleBuzzInbound({
 						account,
@@ -1763,6 +1719,7 @@ async function startBuzzGatewayAccount(ctx) {
 						bus: sessionBus,
 						message,
 						signal,
+						assertCurrent,
 						buildContext
 					});
 				},
@@ -1810,8 +1767,8 @@ async function startBuzzGatewayAccount(ctx) {
 			if (ctx.abortSignal.aborted) return;
 			cycleError = error instanceof Error ? error : new Error(String(error));
 		} finally {
-			await bus?.close();
 			if (activeBuses.get(account.accountId) === bus) activeBuses.delete(account.accountId);
+			await bus?.close();
 			ctx.setStatus({
 				accountId: account.accountId,
 				running: false,
@@ -1847,6 +1804,7 @@ const buzzOutboundAdapter = {
 			cfg,
 			accountId: resolvedAccountId
 		});
+		assertBuzzAccountAvailable(account);
 		if (!account.enabled) throw new Error(`Buzz is disabled for account ${resolvedAccountId}`);
 		if (!account.configured) throw new Error(`Buzz is not configured for account ${resolvedAccountId}`);
 		const bus = activeBuses.get(resolvedAccountId);
@@ -1893,6 +1851,7 @@ function createConfiguredDirectoryState(params) {
 		cfg: params.cfg,
 		accountId: params.accountId
 	});
+	assertBuzzAccountAvailable(account);
 	if (!account.publicKey) return null;
 	const channelIds = resolveConfiguredRoomIds(account);
 	return {
@@ -2010,7 +1969,8 @@ const buzzPlugin = createChatChannelPlugin({
 				configured: account.configured,
 				extra: {
 					baseUrl: account.relayUrl,
-					publicKey: account.publicKey
+					publicKey: account.publicKey,
+					tokenStatus: account.tokenStatus
 				}
 			}),
 			resolveAllowFrom: ({ cfg, accountId }) => resolveBuzzAccount({
@@ -2081,11 +2041,15 @@ const buzzPlugin = createChatChannelPlugin({
 					name: account.name,
 					enabled: account.enabled,
 					configured: account.configured,
-					baseUrl: account.relayUrl,
-					publicKey: account.publicKey
+					extra: {
+						baseUrl: account.relayUrl,
+						publicKey: account.publicKey,
+						tokenStatus: account.tokenStatus
+					}
 				})
 			}),
 			probeAccount: async ({ account, timeoutMs }) => {
+				assertBuzzAccountAvailable(account);
 				const rooms = await discoverBuzzRooms({
 					relayUrl: account.relayUrl,
 					privateKey: account.privateKey,