@openclaw/discord 2026.5.19 → 2026.5.20-beta.2

package/dist/{manager.runtime-CGcJ0yjq.js → manager.runtime-Dq0mc5K0.js}

@@ -1,10 +1,10 @@
-import { Ht as parseDiscordTarget, _ as VoiceStateUpdateListener, c as discord_exports, h as ResumedListener, m as ReadyListener } from "./send.receipt-Dhym-qOF.js";
-import { c as resolveDiscordAccountAllowFrom } from "./accounts-ltxKLzxN.js";
-import { a as normalizeDiscordSlug, b as formatDiscordUserTag, m as resolveDiscordOwnerAccess } from "./allow-list-CBI-M84K.js";
-import { i as formatMention } from "./send.outbound-C0OzZAv_.js";
-import { t as getDiscordRuntime } from "./runtime-Tqtvj5GX.js";
-import { o as authorizeDiscordVoiceIngress, u as resolveDiscordVoiceEnabled } from "./provider-BZtjA1y_.js";
-import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-CzEAvKgx.js";
+import { Ht as parseDiscordTarget, _ as VoiceStateUpdateListener, c as discord_exports, h as ResumedListener, jt as getGuildVoiceState, m as ReadyListener } from "./send.receipt-spSPAC77.js";
+import { c as resolveDiscordAccountAllowFrom } from "./accounts-C2TOAmpo.js";
+import { a as normalizeDiscordSlug, b as formatDiscordUserTag, m as resolveDiscordOwnerAccess } from "./allow-list-BnkWtVpA.js";
+import { i as formatMention } from "./send.outbound-1vG9pOh2.js";
+import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
+import { o as authorizeDiscordVoiceIngress, u as resolveDiscordVoiceEnabled } from "./provider-CzKMDsSE.js";
+import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-B5EsqsSr.js";
 import { createRequire } from "node:module";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
@@ -17,6 +17,7 @@ import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { agentCommandFromIngress, getTtsProvider, resolveAgentDir, resolveTtsConfig, resolveTtsPrefsPath } from "openclaw/plugin-sdk/agent-runtime";
 import { escapeRegExp } from "openclaw/plugin-sdk/text-utility-runtime";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceAgentConsultChatMessage, buildRealtimeVoiceAgentConsultPolicyInstructions, buildRealtimeVoiceAgentConsultWorkingResponse, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceBridgeSession, resamplePcm, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultToolPolicy, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow } from "openclaw/plugin-sdk/realtime-voice";
+import { resolveRealtimeBootstrapContextInstructions } from "openclaw/plugin-sdk/realtime-bootstrap-context";
 import { PassThrough, Readable } from "node:stream";
 import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 //#region extensions/discord/src/voice/audio.ts
@@ -148,7 +149,6 @@ function convertRealtimePcm24kMonoToDiscordPcm48kStereo(pcm) {
 }
 function estimateDurationSeconds(pcm) {
 	const bytesPerSample = BIT_DEPTH / 8 * CHANNELS;
-	if (bytesPerSample <= 0) return 0;
 	return pcm.length / (bytesPerSample * SAMPLE_RATE);
 }
 async function writeVoiceWavFile(pcm) {
@@ -312,7 +312,6 @@ async function runDiscordVoiceAgentTurn(params) {
 		messageChannel: "discord",
 		messageProvider: "discord-voice",
 		extraSystemPrompt: context.extraSystemPrompt,
-		senderIsOwner: context.senderIsOwner,
 		allowModelOverride: Boolean(voiceModel),
 		model: voiceModel,
 		toolsAllow: params.toolsAllow,
@@ -325,6 +324,22 @@ async function runDiscordVoiceAgentTurn(params) {
 		text
 	};
 }
+async function resolveDiscordVoiceRealtimeBootstrapContext(params) {
+	const files = (params.discordConfig.voice?.realtime)?.bootstrapContextFiles;
+	if (files?.length === 0) return;
+	try {
+		return await resolveRealtimeBootstrapContextInstructions({
+			config: params.cfg,
+			agentId: params.entry.route.agentId,
+			sessionKey: params.entry.route.sessionKey,
+			files,
+			warn: (message) => logger$3.warn(`discord voice: realtime bootstrap context: ${message}`)
+		});
+	} catch (error) {
+		logger$3.warn(`discord voice: realtime bootstrap context unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+}
 //#endregion
 //#region extensions/discord/src/voice/prompt.ts
 const DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT = [
@@ -599,6 +614,7 @@ var DiscordRealtimeVoiceSession = class {
 		const instructions = buildDiscordRealtimeInstructions({
 			mode: this.params.mode,
 			instructions: this.realtimeConfig?.instructions,
+			bootstrapContextInstructions: this.params.bootstrapContextInstructions,
 			toolPolicy,
 			consultPolicy
 		});
@@ -1197,6 +1213,7 @@ function buildDiscordRealtimeInstructions(params) {
 	const base = params.instructions ?? ["You are OpenClaw's Discord voice interface.", "Keep spoken replies concise, natural, and suitable for a live Discord voice channel."].join("\n");
 	if (isDiscordAgentProxyVoiceMode(params.mode)) return [
 		base,
+		params.bootstrapContextInstructions?.trim(),
 		"Mode: OpenClaw agent proxy.",
 		"You are the realtime voice surface for the same OpenClaw agent the user can message directly.",
 		"Do not mention a backend, supervisor, helper, or separate system. Present the result as your own work.",
@@ -1209,10 +1226,14 @@ function buildDiscordRealtimeInstructions(params) {
 			consultPolicy: params.consultPolicy
 		})
 	].join("\n\n");
-	return [base, buildRealtimeVoiceAgentConsultPolicyInstructions({
-		toolPolicy: params.toolPolicy,
-		consultPolicy: params.consultPolicy
-	})].filter(Boolean).join("\n\n");
+	return [
+		base,
+		params.bootstrapContextInstructions?.trim(),
+		buildRealtimeVoiceAgentConsultPolicyInstructions({
+			toolPolicy: params.toolPolicy,
+			consultPolicy: params.consultPolicy
+		})
+	].filter(Boolean).join("\n\n");
 }
 //#endregion
 //#region extensions/discord/src/voice/receive-recovery.ts
@@ -1582,6 +1603,9 @@ var DiscordVoiceSpeakerContextResolver = class {
 //#region extensions/discord/src/voice/manager.ts
 const logger = createSubsystemLogger("discord/voice");
 const VOICE_LOG_PREVIEW_CHARS = 500;
+const FOLLOW_USERS_RECONCILE_INTERVAL_MS = 1e4;
+const FOLLOW_USERS_RECONCILE_MAX_GUILDS_PER_RUN = 4;
+const FOLLOW_USERS_RECONCILE_MAX_REST_LOOKUPS_PER_RUN = 32;
 const DISCORD_VOICE_FATAL_AUTOJOIN_ERROR_PATTERNS = [
 	"api key missing",
 	"incorrect api key",
@@ -1627,6 +1651,22 @@ function normalizeVoiceChannelResidencies(entries) {
 	}
 	return normalized;
 }
+function normalizeDiscordUserId(value) {
+	const trimmed = value.trim();
+	const withoutDiscordPrefix = trimmed.startsWith("discord:") ? trimmed.slice(8) : trimmed;
+	return (withoutDiscordPrefix.startsWith("user:") ? withoutDiscordPrefix.slice(5) : withoutDiscordPrefix).trim() || void 0;
+}
+function normalizeDiscordUserIds(entries) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of entries ?? []) {
+		const id = normalizeDiscordUserId(entry);
+		if (id) ids.add(id);
+	}
+	return ids;
+}
+function resolveFollowUsersEnabled(voiceConfig) {
+	return voiceConfig?.followUsersEnabled !== false;
+}
 function isVoiceChannelAllowed(params) {
 	return params.allowedChannels === null || params.allowedChannels.some((entry) => entry.guildId === params.guildId && entry.channelId === params.channelId);
 }
@@ -1637,6 +1677,9 @@ function isFatalAutoJoinFailure(message) {
 	const normalized = message.toLowerCase();
 	return DISCORD_VOICE_FATAL_AUTOJOIN_ERROR_PATTERNS.some((pattern) => normalized.includes(pattern));
 }
+function isUnknownDiscordVoiceStateError(err) {
+	return (err && typeof err === "object" && "status" in err && typeof err.status === "number" ? err.status : void 0) === 404 || /unknown voice state/i.test(formatErrorMessage(err));
+}
 function startAutoJoin(manager) {
 	manager.autoJoin().catch((err) => logger.warn(`discord voice: autoJoin failed: ${formatErrorMessage(err)}`));
 }
@@ -1684,6 +1727,14 @@ var DiscordVoiceManager$1 = class {
 		this.sessions = /* @__PURE__ */ new Map();
 		this.autoJoinTask = null;
 		this.fatalAutoJoinFailures = /* @__PURE__ */ new Map();
+		this.followedUserChannels = /* @__PURE__ */ new Map();
+		this.followedVoiceGuilds = /* @__PURE__ */ new Set();
+		this.followUsersReconcileTimer = null;
+		this.followUsersReconcileTask = null;
+		this.followUsersReconcileGuildCursor = 0;
+		this.followUsersReconcileBotGuildCursor = 0;
+		this.followUsersReconcileUserCursors = /* @__PURE__ */ new Map();
+		this.destroyed = false;
 		this.botUserId = params.botUserId;
 		this.voiceEnabled = resolveDiscordVoiceEnabled(params.discordConfig.voice);
 		this.ownerAllowFrom = resolveDiscordAccountAllowFrom({
@@ -1691,6 +1742,7 @@ var DiscordVoiceManager$1 = class {
 			accountId: params.accountId
 		}) ?? params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom ?? [];
 		this.allowedChannels = params.discordConfig.voice?.allowedChannels === void 0 ? null : normalizeVoiceChannelResidencies(params.discordConfig.voice.allowedChannels);
+		this.followUserIds = resolveFollowUsersEnabled(params.discordConfig.voice) ? normalizeDiscordUserIds(params.discordConfig.voice?.followUsers) : /* @__PURE__ */ new Set();
 		this.speakerContext = new DiscordVoiceSpeakerContextResolver({
 			client: params.client,
 			ownerAllowFrom: this.ownerAllowFrom
@@ -1703,7 +1755,7 @@ var DiscordVoiceManager$1 = class {
 		return this.voiceEnabled;
 	}
 	async autoJoin() {
-		if (!this.voiceEnabled) return;
+		if (!this.voiceEnabled || this.destroyed) return;
 		if (this.autoJoinTask) return this.autoJoinTask;
 		this.autoJoinTask = (async () => {
 			const entries = this.params.discordConfig.voice?.autoJoin ?? [];
@@ -1747,6 +1799,8 @@ var DiscordVoiceManager$1 = class {
 					});
 				}
 			}
+			this.ensureFollowUsersReconcileTimer();
+			await this.reconcileFollowedUsers("startup");
 		})().finally(() => {
 			this.autoJoinTask = null;
 		});
@@ -1767,7 +1821,11 @@ var DiscordVoiceManager$1 = class {
 			channelId: params.channelId.trim()
 		});
 	}
-	async join(params) {
+	async join(params, options) {
+		if (this.destroyed) return {
+			ok: false,
+			message: "Discord voice manager is stopped."
+		};
 		if (!this.voiceEnabled) return {
 			ok: false,
 			message: "Discord voice is disabled (channels.discord.voice.enabled)."
@@ -1803,7 +1861,7 @@ var DiscordVoiceManager$1 = class {
 		}
 		if (existing) {
 			logVoiceVerbose(`join: replacing existing session for guild ${guildId}`);
-			await this.leave({ guildId });
+			await this.leave({ guildId }, { preserveFollowState: options?.preserveFollowState });
 		}
 		const channelInfo = await this.params.client.fetchChannel(channelId).catch(() => null);
 		if (!channelInfo || "type" in channelInfo && !isVoiceChannel(channelInfo.type)) return {
@@ -1942,6 +2000,11 @@ var DiscordVoiceManager$1 = class {
 		};
 		if (voiceMode !== "stt-tts") {
 			entry.realtime = new DiscordRealtimeVoiceSession({
+				bootstrapContextInstructions: await resolveDiscordVoiceRealtimeBootstrapContext({
+					entry,
+					cfg: this.params.cfg,
+					discordConfig: this.params.discordConfig
+				}),
 				cfg: this.params.cfg,
 				discordConfig: this.params.discordConfig,
 				entry,
@@ -2022,7 +2085,7 @@ var DiscordVoiceManager$1 = class {
 			channelId
 		};
 	}
-	async leave(params) {
+	async leave(params, options) {
 		const guildId = params.guildId.trim();
 		logVoiceVerbose(`leave requested: guild ${guildId} channel ${params.channelId ?? "current"}`);
 		const entry = this.sessions.get(guildId);
@@ -2036,6 +2099,10 @@ var DiscordVoiceManager$1 = class {
 		};
 		entry.stop();
 		this.sessions.delete(guildId);
+		if (!options?.preserveFollowState) {
+			this.followedVoiceGuilds.delete(guildId);
+			this.deleteFollowedUserChannelsForGuild(guildId);
+		}
 		logVoiceVerbose(`leave: disconnected from guild ${guildId} channel ${entry.channelId}`);
 		return {
 			ok: true,
@@ -2045,10 +2112,26 @@ var DiscordVoiceManager$1 = class {
 		};
 	}
 	async handleVoiceStateUpdate(data) {
-		if (!this.botUserId || data.user_id !== this.botUserId) return;
 		const guildId = data.guild_id?.trim();
+		const userId = data.user_id?.trim();
 		const channelId = data.channel_id?.trim();
-		if (!guildId || !channelId) return;
+		if (!guildId || !userId) return;
+		if (this.botUserId && userId === this.botUserId) {
+			await this.handleBotVoiceStateUpdate({
+				guildId,
+				channelId
+			});
+			return;
+		}
+		if (this.followUserIds.has(userId)) await this.handleFollowedUserVoiceStateUpdate({
+			guildId,
+			channelId,
+			userId
+		});
+	}
+	async handleBotVoiceStateUpdate(params) {
+		const { guildId, channelId } = params;
+		if (!channelId) return;
 		const existing = this.sessions.get(guildId);
 		if (this.isAllowedVoiceChannel({
 			guildId,
@@ -2059,7 +2142,7 @@ var DiscordVoiceManager$1 = class {
 				await this.join({
 					guildId,
 					channelId
-				});
+				}, { preserveFollowState: this.isFollowOwnedGuild(guildId) });
 			}
 			return;
 		}
@@ -2080,9 +2163,267 @@ var DiscordVoiceManager$1 = class {
 			await this.join(target);
 		}
 	}
+	async handleFollowedUserVoiceStateUpdate(params) {
+		if (!this.voiceEnabled || this.destroyed) return;
+		const { guildId, channelId, userId } = params;
+		const followKey = this.formatFollowedUserKey({
+			guildId,
+			userId
+		});
+		const existing = this.sessions.get(guildId);
+		const wasFollowedVoiceSession = this.followedUserChannels.has(followKey) || this.followedVoiceGuilds.has(guildId);
+		if (!channelId) {
+			this.followedUserChannels.delete(followKey);
+			if (existing && wasFollowedVoiceSession && !this.hasFollowedUserInChannel(existing)) await this.handoffToAnotherFollowedUserOrLeave({
+				guildId,
+				userId,
+				existing,
+				reason: "disconnected"
+			});
+			return;
+		}
+		if (!this.isAllowedVoiceChannel({
+			guildId,
+			channelId
+		})) {
+			this.followedUserChannels.delete(followKey);
+			logger.warn(`discord voice: followed user joined non-allowed channel guild=${guildId} user=${userId} channel=${channelId}; ignoring`);
+			if (existing && wasFollowedVoiceSession && !this.hasFollowedUserInChannel(existing)) await this.handoffToAnotherFollowedUserOrLeave({
+				guildId,
+				userId,
+				existing,
+				reason: "joined non-allowed channel"
+			});
+			return;
+		}
+		this.followedUserChannels.set(followKey, {
+			guildId,
+			channelId
+		});
+		if (existing?.channelId === channelId) {
+			this.followedVoiceGuilds.add(guildId);
+			return;
+		}
+		logger.info(`discord voice: following user guild=${guildId} user=${userId} channel=${channelId}`);
+		const result = await this.join({
+			guildId,
+			channelId
+		}, { preserveFollowState: true });
+		if (!result.ok) {
+			if (this.sessions.get(guildId)?.channelId === channelId) this.followedVoiceGuilds.add(guildId);
+			else this.followedUserChannels.delete(followKey);
+			logger.warn(`discord voice: failed to follow user guild=${guildId} user=${userId} channel=${channelId}: ${result.message}`);
+			return;
+		}
+		this.followedVoiceGuilds.add(guildId);
+	}
 	async destroy() {
+		this.destroyed = true;
+		if (this.followUsersReconcileTimer) {
+			clearInterval(this.followUsersReconcileTimer);
+			this.followUsersReconcileTimer = null;
+		}
 		for (const entry of this.sessions.values()) entry.stop();
 		this.sessions.clear();
+		this.followedUserChannels.clear();
+		this.followedVoiceGuilds.clear();
+	}
+	resolveFollowGuildIds() {
+		const guildIds = /* @__PURE__ */ new Set();
+		for (const guildId of Object.keys(this.params.discordConfig.guilds ?? {})) {
+			const normalized = guildId.trim();
+			if (normalized) guildIds.add(normalized);
+		}
+		for (const entry of normalizeVoiceChannelResidencies(this.params.discordConfig.voice?.autoJoin)) guildIds.add(entry.guildId);
+		for (const entry of this.allowedChannels ?? []) guildIds.add(entry.guildId);
+		for (const entry of this.sessions.values()) guildIds.add(entry.guildId);
+		return Array.from(guildIds);
+	}
+	ensureFollowUsersReconcileTimer() {
+		if (this.followUserIds.size === 0) return;
+		if (this.followUsersReconcileTimer) return;
+		this.followUsersReconcileTimer = setInterval(() => {
+			this.reconcileFollowedUsers("interval").catch((err) => {
+				logger.warn(`discord voice: follow user reconciliation failed: ${formatErrorMessage(err)}`);
+			});
+		}, FOLLOW_USERS_RECONCILE_INTERVAL_MS);
+		this.followUsersReconcileTimer.unref?.();
+	}
+	async reconcileFollowedUsers(reason) {
+		if (this.followUserIds.size === 0 || this.destroyed) return;
+		if (this.followUsersReconcileTask) return this.followUsersReconcileTask;
+		this.followUsersReconcileTask = this.runFollowedUsersReconcile(reason).finally(() => {
+			this.followUsersReconcileTask = null;
+		});
+		return this.followUsersReconcileTask;
+	}
+	async runFollowedUsersReconcile(reason) {
+		if (this.destroyed) return;
+		const guildIds = this.resolveFollowGuildIds();
+		if (guildIds.length === 0) {
+			logVoiceVerbose(`follow user reconcile skipped reason=${reason}: no Discord guild ids are configured`);
+			return;
+		}
+		logVoiceVerbose(`follow user reconcile reason=${reason}: ${this.followUserIds.size} users across ${guildIds.length} guilds`);
+		const plans = this.selectFollowUserReconcilePlans(guildIds, reason);
+		for (const plan of plans) {
+			for (const userId of plan.userIds) {
+				const voiceState = await getGuildVoiceState(this.params.client.rest, plan.guildId, userId).catch((err) => {
+					if (!isUnknownDiscordVoiceStateError(err)) {
+						logger.warn(`discord voice: follow user reconcile skipped transient voice state error guild=${plan.guildId} user=${userId} reason=${reason}: ${formatErrorMessage(err)}`);
+						return "transient-error";
+					}
+					logVoiceVerbose(`follow user reconcile reason=${reason}: no voice state guild ${plan.guildId} user ${userId}: ${formatErrorMessage(err)}`);
+				});
+				if (this.destroyed) return;
+				if (voiceState === "transient-error") continue;
+				const channelId = voiceState?.channel_id?.trim();
+				await this.handleFollowedUserVoiceStateUpdate({
+					guildId: plan.guildId,
+					channelId,
+					userId
+				});
+			}
+			if (plan.checkBotVoiceState) {
+				if (this.destroyed) return;
+				await this.disconnectStaleFollowedBotVoiceState({
+					guildId: plan.guildId,
+					reason
+				});
+			}
+		}
+	}
+	selectFollowUserReconcilePlans(guildIds, reason) {
+		const followedUserIds = Array.from(this.followUserIds);
+		if (followedUserIds.length === 0) return [];
+		let remainingLookups = FOLLOW_USERS_RECONCILE_MAX_REST_LOOKUPS_PER_RUN;
+		const guildLimit = Math.min(guildIds.length, FOLLOW_USERS_RECONCILE_MAX_GUILDS_PER_RUN);
+		const start = this.followUsersReconcileGuildCursor % guildIds.length;
+		const plans = [];
+		for (let offset = 0; offset < guildLimit && remainingLookups > 0; offset += 1) {
+			if (this.botUserId && remainingLookups === 1) break;
+			const guildId = guildIds[(start + offset) % guildIds.length];
+			const userLimit = this.resolveFollowUserReconcileUserLookupLimit(followedUserIds.length, remainingLookups);
+			if (userLimit <= 0) break;
+			const selection = this.selectFollowUserReconcileUserIds(guildId, followedUserIds, userLimit);
+			plans.push({
+				guildId,
+				userIds: selection.userIds,
+				checkedAllUsers: selection.completedCycle,
+				checkBotVoiceState: false
+			});
+			remainingLookups -= selection.userIds.length;
+		}
+		this.followUsersReconcileGuildCursor = (start + plans.length) % guildIds.length;
+		this.assignFollowUserReconcileBotChecks(guildIds, plans, remainingLookups);
+		if (plans.length < guildIds.length || plans.some((plan) => plan.userIds.length < followedUserIds.length)) logVoiceVerbose(`follow user reconcile reason=${reason}: sampling ${plans.length}/${guildIds.length} guilds and up to ${FOLLOW_USERS_RECONCILE_MAX_REST_LOOKUPS_PER_RUN} REST lookups`);
+		return plans;
+	}
+	assignFollowUserReconcileBotChecks(guildIds, plans, remainingLookups) {
+		if (!this.botUserId || remainingLookups <= 0 || plans.length === 0) return;
+		const plansByGuild = new Map(plans.map((plan) => [plan.guildId, plan]));
+		const start = this.followUsersReconcileBotGuildCursor % guildIds.length;
+		let scanned = 0;
+		let assigned = 0;
+		for (; scanned < guildIds.length && assigned < remainingLookups; scanned += 1) {
+			const guildId = guildIds[(start + scanned) % guildIds.length];
+			const plan = plansByGuild.get(guildId);
+			if (!plan?.checkedAllUsers) continue;
+			plan.checkBotVoiceState = true;
+			assigned += 1;
+		}
+		this.followUsersReconcileBotGuildCursor = (start + scanned) % guildIds.length;
+	}
+	resolveFollowUserReconcileUserLookupLimit(followedUserCount, remainingLookups) {
+		const userLimit = Math.min(followedUserCount, remainingLookups);
+		if (this.botUserId && followedUserCount > userLimit && remainingLookups > 1) return remainingLookups - 1;
+		return userLimit;
+	}
+	selectFollowUserReconcileUserIds(guildId, followedUserIds, limit) {
+		if (followedUserIds.length <= limit) {
+			this.followUsersReconcileUserCursors.set(guildId, 0);
+			return {
+				userIds: followedUserIds,
+				completedCycle: true
+			};
+		}
+		const start = this.followUsersReconcileUserCursors.get(guildId) ?? 0;
+		const selected = Array.from({ length: limit }, (_, offset) => followedUserIds[(start + offset) % followedUserIds.length]);
+		const completedCycle = start + selected.length >= followedUserIds.length;
+		this.followUsersReconcileUserCursors.set(guildId, (start + selected.length) % followedUserIds.length);
+		return {
+			userIds: selected,
+			completedCycle
+		};
+	}
+	formatFollowedUserKey(params) {
+		return `${params.guildId}:${params.userId}`;
+	}
+	hasFollowedUserInChannel(entry) {
+		return Array.from(this.followedUserChannels.values()).some((candidate) => candidate.guildId === entry.guildId && candidate.channelId === entry.channelId);
+	}
+	resolveFollowedUserHandoffTarget(guildId, currentChannelId) {
+		for (const entry of this.followedUserChannels.values()) if (entry.guildId === guildId && entry.channelId !== currentChannelId && this.isAllowedVoiceChannel(entry)) return entry;
+		return null;
+	}
+	async handoffToAnotherFollowedUserOrLeave(params) {
+		const target = this.resolveFollowedUserHandoffTarget(params.guildId, params.existing.channelId);
+		if (target) {
+			logger.info(`discord voice: followed user ${params.reason} guild=${params.guildId} user=${params.userId}; moving to remaining followed user channel=${target.channelId}`);
+			const result = await this.join(target, { preserveFollowState: true });
+			if (result.ok) this.followedVoiceGuilds.add(params.guildId);
+			else {
+				logger.warn(`discord voice: failed to hand off followed user session guild=${params.guildId} channel=${target.channelId}: ${result.message}`);
+				this.followedVoiceGuilds.delete(params.guildId);
+				this.deleteFollowedUserChannelsForGuild(params.guildId);
+				await this.leave({ guildId: params.guildId });
+			}
+			return;
+		}
+		logger.info(`discord voice: followed user ${params.reason} guild=${params.guildId} user=${params.userId}; leaving channel=${params.existing.channelId}`);
+		await this.leave({ guildId: params.guildId });
+	}
+	isFollowOwnedGuild(guildId) {
+		return this.followedVoiceGuilds.has(guildId) || Array.from(this.followedUserChannels.values()).some((entry) => entry.guildId === guildId);
+	}
+	deleteFollowedUserChannelsForGuild(guildId) {
+		for (const [key, entry] of this.followedUserChannels.entries()) if (entry.guildId === guildId) this.followedUserChannels.delete(key);
+	}
+	async disconnectStaleFollowedBotVoiceState(params) {
+		if (this.destroyed) return;
+		const { guildId, reason } = params;
+		if (Array.from(this.followedUserChannels.values()).some((entry) => entry.guildId === guildId)) return;
+		const existing = this.sessions.get(guildId);
+		if (existing) {
+			if (this.followedVoiceGuilds.has(guildId)) {
+				logger.info(`discord voice: follow reconcile leaving local session guild=${guildId} channel=${existing.channelId} reason=${reason}`);
+				await this.leave({ guildId });
+			}
+			return;
+		}
+		if (!this.botUserId) return;
+		const botVoiceState = await getGuildVoiceState(this.params.client.rest, guildId, this.botUserId).catch((err) => {
+			if (!isUnknownDiscordVoiceStateError(err)) {
+				logger.warn(`discord voice: follow reconcile skipped transient bot voice state error guild=${guildId} reason=${reason}: ${formatErrorMessage(err)}`);
+				return "transient-error";
+			}
+			logVoiceVerbose(`follow user reconcile reason=${reason}: no bot voice state guild ${guildId}: ${formatErrorMessage(err)}`);
+		});
+		if (this.destroyed || botVoiceState === "transient-error") return;
+		const botChannelId = botVoiceState?.channel_id?.trim();
+		if (!botChannelId) return;
+		const gateway = this.params.client.getPlugin("voice")?.getGateway(guildId);
+		if (!gateway) {
+			logger.warn(`discord voice: follow reconcile cannot disconnect stale bot voice state guild=${guildId} channel=${botChannelId}; gateway unavailable`);
+			return;
+		}
+		logger.info(`discord voice: follow reconcile disconnecting stale bot voice state guild=${guildId} channel=${botChannelId} reason=${reason}`);
+		gateway.updateVoiceState({
+			guild_id: guildId,
+			channel_id: null,
+			self_mute: false,
+			self_deaf: false
+		});
 	}
 	resolveVoiceResidencyTarget(guildId) {
 		const autoJoinTarget = normalizeVoiceChannelResidencies(this.params.discordConfig.voice?.autoJoin).toReversed().find((entry) => entry.guildId === guildId);
@@ -2306,8 +2647,9 @@ var DiscordVoiceManager$1 = class {
 	async recoverFromDecryptFailures(entry) {
 		const active = this.sessions.get(entry.guildId);
 		if (!active || active.connection !== entry.connection) return;
+		const preserveFollowState = this.isFollowOwnedGuild(entry.guildId);
 		logger.warn(`discord voice: repeated decrypt failures; attempting rejoin for guild ${entry.guildId} channel ${entry.channelId}`);
-		const leaveResult = await this.leave({ guildId: entry.guildId });
+		const leaveResult = await this.leave({ guildId: entry.guildId }, { preserveFollowState });
 		if (!leaveResult.ok) {
 			logger.warn(`discord voice: decrypt recovery leave failed: ${leaveResult.message}`);
 			return;
@@ -2315,7 +2657,7 @@ var DiscordVoiceManager$1 = class {
 		const result = await this.join({
 			guildId: entry.guildId,
 			channelId: entry.channelId
-		});
+		}, { preserveFollowState });
 		if (!result.ok) logger.warn(`discord voice: rejoin after decrypt failures failed: ${result.message}`);
 	}
 };

package/dist/{message-handler-1NV0WiHC.js → message-handler-wQJd4Peh.js}

@@ -1,8 +1,8 @@
-import { N as createDiscordRestClient } from "./send.shared-C6JLgsbp.js";
-import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-BzelVdsY.js";
-import { a as mergeAbortSignals } from "./timeouts-CEwuGaWT.js";
-import { c as hasDiscordMessageStickers, d as resolveDiscordMessageChannelId, r as resolveDiscordMessageText } from "./message-utils-BKrlzFtM.js";
-import { t as sendTyping } from "./typing-DtdZgo-g.js";
+import { N as createDiscordRestClient } from "./send.shared-D4clao4K.js";
+import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-Ddalj9wo.js";
+import { a as mergeAbortSignals } from "./timeouts-l_PsHQvX.js";
+import { c as hasDiscordMessageStickers, d as resolveDiscordMessageChannelId, r as resolveDiscordMessageText } from "./message-utils-Bw-wDr8G.js";
+import { t as sendTyping } from "./typing-DUUjLsPr.js";
 import { danger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
@@ -121,7 +121,7 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 //#region extensions/discord/src/monitor/message-run-queue.ts
 let messageProcessRuntimePromise;
 async function loadMessageProcessRuntime() {
-	messageProcessRuntimePromise ??= import("./message-handler.process-PpgZ0qC4.js");
+	messageProcessRuntimePromise ??= import("./message-handler.process-DG4qm0sQ.js");
 	return await messageProcessRuntimePromise;
 }
 async function processDiscordQueuedMessage(params) {
@@ -173,7 +173,7 @@ function createDiscordMessageRunQueue(params) {
 //#region extensions/discord/src/monitor/message-handler.ts
 let messagePreflightRuntimePromise;
 async function loadMessagePreflightRuntime() {
-	messagePreflightRuntimePromise ??= import("./message-handler.preflight-DQ-oPY7m.js");
+	messagePreflightRuntimePromise ??= import("./message-handler.preflight-ANdoLbtA.js");
 	return await messagePreflightRuntimePromise;
 }
 function isNonEmptyString(value) {

package/dist/{message-handler.preflight-DQ-oPY7m.js → message-handler.preflight-ANdoLbtA.js}

@@ -1,13 +1,13 @@
-import { A as Message, c as discord_exports, mt as getChannelMessage } from "./send.receipt-Dhym-qOF.js";
-import { o as resolveDefaultDiscordAccountId } from "./accounts-ltxKLzxN.js";
-import { S as resolveTimestampMs, _ as resolveGroupDmAllow, a as normalizeDiscordSlug, b as formatDiscordUserTag, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, g as resolveDiscordShouldRequireMention, i as normalizeDiscordDisplaySlug, n as isDiscordGroupAllowedByPolicy, x as resolveDiscordSystemLocation } from "./allow-list-CBI-M84K.js";
-import { t as resolveDiscordConversationIdentity } from "./conversation-identity-BY7sjUQh.js";
-import { l as isRecentlyUnboundThreadWebhookMessage } from "./thread-bindings.state-CSphZOiL.js";
-import { d as resolveDiscordChannelNameSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-BzelVdsY.js";
-import "./thread-bindings-BcXgbZ3-.js";
-import { C as resolveDiscordDmCommandAccess, f as buildDiscordRoutePeer, g as handleDiscordDmCommandDecision, h as shouldIgnoreStaleDiscordRouteBinding, m as resolveDiscordEffectiveRoute, p as resolveDiscordConversationRoute, w as resolveDiscordTextCommandAccess } from "./provider-BZtjA1y_.js";
-import { d as resolveDiscordMessageChannelId, l as resolveDiscordMessageStickers, o as resolveMediaList, r as resolveDiscordMessageText, u as resolveDiscordChannelInfo } from "./message-utils-BKrlzFtM.js";
-import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-DC0FdEcU.js";
+import { A as Message, c as discord_exports, mt as getChannelMessage } from "./send.receipt-spSPAC77.js";
+import { o as resolveDefaultDiscordAccountId } from "./accounts-C2TOAmpo.js";
+import { S as resolveTimestampMs, _ as resolveGroupDmAllow, a as normalizeDiscordSlug, b as formatDiscordUserTag, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, g as resolveDiscordShouldRequireMention, i as normalizeDiscordDisplaySlug, n as isDiscordGroupAllowedByPolicy, x as resolveDiscordSystemLocation } from "./allow-list-BnkWtVpA.js";
+import { t as resolveDiscordConversationIdentity } from "./conversation-identity-CAyt5wzy.js";
+import { l as isRecentlyUnboundThreadWebhookMessage } from "./thread-bindings.state-BsOnj5NX.js";
+import { d as resolveDiscordChannelNameSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-Ddalj9wo.js";
+import "./thread-bindings-BQz8z6MR.js";
+import { C as resolveDiscordDmCommandAccess, f as buildDiscordRoutePeer, g as handleDiscordDmCommandDecision, h as shouldIgnoreStaleDiscordRouteBinding, m as resolveDiscordEffectiveRoute, p as resolveDiscordConversationRoute, w as resolveDiscordTextCommandAccess } from "./provider-CzKMDsSE.js";
+import { d as resolveDiscordMessageChannelId, l as resolveDiscordMessageStickers, o as resolveMediaList, r as resolveDiscordMessageText, u as resolveDiscordChannelInfo } from "./message-utils-Bw-wDr8G.js";
+import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-BFp5w0F8.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getChildLogger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
@@ -29,7 +29,7 @@ async function loadConversationRuntime$1() {
 	return await conversationRuntimePromise$1;
 }
 async function loadDiscordSendRuntime() {
-	discordSendRuntimePromise ??= import("./send-BsBy21Te.js").then((n) => n.t);
+	discordSendRuntimePromise ??= import("./send-CEAtV0qd.js").then((n) => n.t);
 	return await discordSendRuntimePromise;
 }
 async function resolveDiscordDmPreflightAccess(params) {
@@ -427,19 +427,19 @@ let preflightAudioRuntimePromise;
 let systemEventsRuntimePromise;
 let discordThreadingRuntimePromise;
 async function loadPluralKitRuntime() {
-	pluralkitRuntimePromise ??= import("./pluralkit-BnCH6cHK.js").then((n) => n.n);
+	pluralkitRuntimePromise ??= import("./pluralkit-sQLfeyIZ.js").then((n) => n.n);
 	return await pluralkitRuntimePromise;
 }
 async function loadPreflightAudioRuntime() {
-	preflightAudioRuntimePromise ??= import("./preflight-audio-B0keJeQe.js");
+	preflightAudioRuntimePromise ??= import("./preflight-audio-ClWbnQto.js");
 	return await preflightAudioRuntimePromise;
 }
 async function loadSystemEventsRuntime() {
-	systemEventsRuntimePromise ??= import("./system-events-DEuiLTl9.js");
+	systemEventsRuntimePromise ??= import("./system-events-HgHeiMHg.js");
 	return await systemEventsRuntimePromise;
 }
 async function loadDiscordThreadingRuntime() {
-	discordThreadingRuntimePromise ??= import("./provider-BZtjA1y_.js").then((n) => n.v);
+	discordThreadingRuntimePromise ??= import("./provider-CzKMDsSE.js").then((n) => n.v);
 	return await discordThreadingRuntimePromise;
 }
 function isPreflightAborted(abortSignal) {
@@ -1026,9 +1026,7 @@ async function preflightDiscordMessage(params) {
 		logDebug(`[discord-preflight] drop: system event`);
 		enqueueSystemEvent(systemText, {
 			sessionKey: effectiveRoute.sessionKey,
-			contextKey: `discord:system:${messageChannelId}:${message.id}`,
-			forceSenderIsOwnerFalse: true,
-			trusted: false
+			contextKey: `discord:system:${messageChannelId}:${message.id}`
 		});
 		return null;
 	}