@openclaw/discord 2026.8.1-beta.2 → 2026.8.1-beta.3

package/dist/{voice-runtime-BEdqNcST.js → voice-runtime-CjNFaynA.js}

@@ -1,18 +1,20 @@
-import { C as ReadyListener, D as VoiceStateUpdateListener, N as isUnknownDiscordVoiceStateError, Wt as getGuildVoiceState, h as discord_exports, p as parseDiscordTarget, w as ResumedListener } from "./retry-CLpJcXXf.js";
+import { S as ResumedListener, T as VoiceStateUpdateListener, Ut as getGuildVoiceState, j as isUnknownDiscordVoiceStateError, p as discord_exports, x as ReadyListener } from "./retry-DNsVTeTo.js";
+import { k as parseDiscordTarget } from "./accounts-DNl-oCEw.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as normalizeDiscordSlug, h as resolveDiscordOwnerAccess, x as formatDiscordUserTag } from "./allow-list-DnxIlPP2.js";
-import { a as formatMention } from "./send.outbound-DS5tHwfR.js";
-import { g as buildDiscordGroupSystemPrompt, l as resolveDiscordVoiceAccess, m as resolveDiscordVoiceEnabled, u as authorizeDiscordVoiceIngress } from "./provider-DvSNb-2v.js";
-import { S as formatVoiceLogPreview, _ as decodeOpusStream, a as SPEAKING_READY_TIMEOUT_MS, b as formatVoiceIngressPrompt, c as isDiscordRealtimeVoiceMode, d as resolveDiscordVoiceMode, f as resolveVoiceTimeoutMs, g as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as isVoiceChannel, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_CONNECT_READY_TIMEOUT_MS, s as VOICE_RECONNECT_GRACE_MS, t as loadDiscordVoiceSdk, u as logVoiceVerbose, v as decodeOpusStreamChunks, x as maybeControlDiscordVoiceAgentRun, y as writeVoiceWavFile } from "./sdk-runtime-QpY8PvCh.js";
-import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { a as normalizeDiscordSlug, h as resolveDiscordOwnerAccess, x as formatDiscordUserTag } from "./allow-list-BDMimASD.js";
+import { a as formatMention } from "./send.outbound-HIkgji_7.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-Bg41VzAf.js";
+import { p as buildDiscordGroupSystemPrompt, y as resolveFetchedDiscordThreadLikeChannelContext } from "./provider-DlK_ynqt.js";
+import { S as formatVoiceLogPreview, _ as decodeOpusStream, a as SPEAKING_READY_TIMEOUT_MS, b as formatVoiceIngressPrompt, c as isDiscordRealtimeVoiceMode, d as resolveDiscordVoiceMode, f as resolveVoiceTimeoutMs, g as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as isVoiceChannel, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_CONNECT_READY_TIMEOUT_MS, s as VOICE_RECONNECT_GRACE_MS, t as loadDiscordVoiceSdk, u as logVoiceVerbose, v as decodeOpusStreamChunks, x as maybeControlDiscordVoiceAgentRun, y as writeVoiceWavFile } from "./sdk-runtime-37OU6_Yh.js";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
+import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { escapeRegExp, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { stripInlineDirectiveTagsForDisplay } from "openclaw/plugin-sdk/text-chunking";
-import path from "node:path";
+import { unlinkIfExists } from "openclaw/plugin-sdk/media-runtime";
 import { agentCommandFromIngress, resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { Readable } from "node:stream";
@@ -88,6 +90,7 @@ async function runDiscordVoiceAgentTurn(params) {
 		agentId: params.entry.route.agentId,
 		messageChannel: "discord",
 		messageProvider: DISCORD_VOICE_MESSAGE_PROVIDER,
+		accountId: params.accountId,
 		extraSystemPrompt: context.extraSystemPrompt,
 		senderIsOwner: context.senderIsOwner,
 		allowModelOverride: Boolean(voiceModel),
@@ -193,7 +196,7 @@ function countDiscordVoiceHumanParticipants(params) {
 		const userId = state.user_id?.trim();
 		if (!userId || userId === params.botUserId || knownUserIds.has(userId)) continue;
 		knownUserIds.add(userId);
-		if (state.member?.user?.bot !== true) count += 1;
+		if (state.member?.user && state.member.user.bot !== true) count += 1;
 	}
 	for (const rawUserId of params.additionalUserIds ?? []) {
 		const userId = rawUserId.trim();
@@ -654,7 +657,8 @@ function normalizeVoiceChannelResidencies(entries) {
 		const channelId = entry.channelId?.trim();
 		if (guildId && channelId) normalized.push({
 			guildId,
-			channelId
+			channelId,
+			...entry.whenOccupied === true ? { whenOccupied: true } : {}
 		});
 	}
 	return normalized;
@@ -1017,6 +1021,7 @@ var DiscordVoiceFollowing = class {
 	}
 	resolveVoiceResidencyTarget(guildId) {
 		const autoJoinTarget = this.params.autoJoinChannels.toReversed().find((entry) => entry.guildId === guildId);
+		if (autoJoinTarget?.whenOccupied) return null;
 		if (autoJoinTarget && this.params.isAllowedVoiceChannel(autoJoinTarget)) return autoJoinTarget;
 		if (this.params.allowedChannels === null) return null;
 		const guildAllowed = this.params.allowedChannels.filter((entry) => entry.guildId === guildId);
@@ -1142,6 +1147,7 @@ async function synthesizeVoiceReplyAudio(params) {
 		release: streamResult.release,
 		speakText
 	};
+	const streamFailure = streamResult && !streamResult.success ? streamResult.attempts?.findLast((attempt) => attempt.outcome === "failed") : void 0;
 	const result = await runtime.tts.textToSpeech({
 		text: speakText,
 		cfg: prepared.cfg,
@@ -1156,7 +1162,11 @@ async function synthesizeVoiceReplyAudio(params) {
 		status: "ok",
 		mode: "file",
 		audioPath: result.audioPath,
-		speakText
+		speakText,
+		...streamFailure ? { streamFailure: {
+			provider: streamFailure.provider,
+			reasonCode: streamFailure.reasonCode
+		} } : {}
 	};
 }
 //#endregion
@@ -1219,10 +1229,12 @@ async function processDiscordVoiceSegment(params) {
 		logger$4.info(`discord voice: active-run control handled mode=${control.result.mode} ok=${control.result.ok} active=${control.result.active} reason=${control.result.reason ?? "none"} session=${entry.route.sessionKey}`);
 		replyText = control.speakText ?? "";
 	} else {
+		const prompt = formatVoiceIngressPrompt(transcript, ingress.speakerLabel);
 		const turn = await runDiscordVoiceAgentTurn({
 			entry,
+			accountId: params.accountId,
 			userId,
-			message: formatVoiceIngressPrompt(transcript, ingress.speakerLabel),
+			message: prompt,
 			cfg: params.cfg,
 			discordConfig: params.discordConfig,
 			runtime: params.runtime,
@@ -1256,26 +1268,30 @@ async function processDiscordVoiceSegment(params) {
 		logger$4.warn(`discord voice: TTS failed: ${voiceReplyAudio.error ?? "unknown error"}`);
 		return;
 	}
+	const streamFailure = voiceReplyAudio.mode === "file" ? voiceReplyAudio.streamFailure : void 0;
+	if (streamFailure && !entry.ttsStreamFallbackWarned) {
+		entry.ttsStreamFallbackWarned = true;
+		logger$4.warn(`discord voice: streaming TTS failed provider=${streamFailure.provider} reasonCode=${streamFailure.reasonCode}; using file fallback`);
+	}
 	logVoiceVerbose(`tts ok (${voiceReplyAudio.speakText.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
+	const releaseAudio = voiceReplyAudio.mode === "stream" ? voiceReplyAudio.release : () => unlinkIfExists(voiceReplyAudio.audioPath);
+	if (entry.sessionLifecycle.status === "stopped") {
+		await releaseAudio?.();
+		return;
+	}
 	params.enqueuePlayback(entry, async () => {
 		const voiceSdk = loadDiscordVoiceSdk();
-		const releaseAudioStream = voiceReplyAudio.mode === "stream" ? voiceReplyAudio.release : void 0;
 		try {
-			if (voiceReplyAudio.mode === "stream") {
-				logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} stream`);
-				const nodeStream = Readable.fromWeb(voiceReplyAudio.audioStream);
-				const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(nodeStream), { inputType: voiceSdk.StreamType.Opus });
-				entry.player.play(resource);
-			} else {
-				logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} file ${path.basename(voiceReplyAudio.audioPath)}`);
-				const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(voiceReplyAudio.audioPath), { inputType: voiceSdk.StreamType.Opus });
-				entry.player.play(resource);
-			}
+			if (entry.sessionLifecycle.status === "stopped") return;
+			const input = voiceReplyAudio.mode === "stream" ? Readable.fromWeb(voiceReplyAudio.audioStream) : voiceReplyAudio.audioPath;
+			logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} ${voiceReplyAudio.mode}`);
+			const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(input), { inputType: voiceSdk.StreamType.Opus });
+			entry.player.play(resource);
 			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Playing, PLAYBACK_READY_TIMEOUT_MS).catch(() => void 0);
 			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Idle, SPEAKING_READY_TIMEOUT_MS).catch(() => void 0);
 			logVoiceVerbose(`playback done: guild ${entry.guildId} channel ${entry.channelId}`);
 		} finally {
-			await releaseAudioStream?.();
+			await releaseAudio?.();
 		}
 	});
 }
@@ -1415,6 +1431,7 @@ var DiscordVoiceReceive = class {
 	async processSegment(params) {
 		await processDiscordVoiceSegment({
 			...params,
+			accountId: this.params.accountId,
 			cfg: this.params.cfg,
 			discordConfig: this.params.discordConfig,
 			admissionAllowFrom: this.params.admissionAllowFrom,
@@ -1515,6 +1532,7 @@ var DiscordVoiceReceive = class {
 		logger$3.info(`discord voice: agent turn start guild=${entry.guildId} channel=${entry.channelId} voiceSession=${entry.voiceSessionKey} supervisorSession=${entry.route.sessionKey} agent=${entry.route.agentId} user=${userId} speaker=${context.speakerLabel} owner=${context.senderIsOwner} model=${this.params.discordConfig.voice?.model ?? "route-default"} message=${formatVoiceLogPreview(message)}`);
 		const turn = await runDiscordVoiceAgentTurn({
 			entry,
+			accountId: this.params.accountId,
 			userId,
 			message,
 			cfg: this.params.cfg,
@@ -1574,7 +1592,10 @@ var DiscordVoiceReceive = class {
 		const result = await this.params.join({
 			guildId: entry.guildId,
 			channelId: entry.channelId
-		}, { preserveFollowState });
+		}, {
+			preserveFollowState,
+			autoJoinWhenOccupied: entry.autoJoinWhenOccupied
+		});
 		if (!result.ok) logger$3.warn(`discord voice: rejoin after decrypt failures failed: ${result.message}`);
 	}
 };
@@ -1660,8 +1681,15 @@ var DiscordVoiceSessions = class {
 		const { guildId, channelId } = params;
 		const voiceConfig = this.params.discordConfig.voice;
 		const voiceMode = resolveDiscordVoiceMode(voiceConfig);
+		const cancelledJoinResult = () => ({
+			ok: false,
+			message: "Discord voice join was cancelled.",
+			guildId,
+			channelId
+		});
 		const existing = this.params.sessions.get(guildId);
 		if (existing && existing.channelId === channelId) {
+			existing.autoJoinWhenOccupied = options?.autoJoinWhenOccupied === true;
 			if (authority) existing.generation = authority.generation;
 			if (options?.transcripts) existing.transcripts = options.transcripts;
 			if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode) && existing.realtimeLifecycle.status !== "active" && existing.realtimeLifecycle.status !== "starting") {
@@ -1688,14 +1716,20 @@ var DiscordVoiceSessions = class {
 			logVoiceVerbose(`join: replacing existing session for guild ${guildId}`);
 			await this.leave({ guildId }, { preserveFollowState: options?.preserveFollowState });
 		}
-		const channelInfo = await this.params.client.fetchChannel(channelId).catch(() => null);
-		if (authority && !authority.isCurrent()) return {
-			ok: false,
-			message: "Discord voice join was cancelled.",
-			guildId,
-			channelId
-		};
-		if (!channelInfo || "type" in channelInfo && !isVoiceChannel(channelInfo.type)) return {
+		let channelInfo;
+		try {
+			channelInfo = await this.params.client.fetchChannel(channelId);
+		} catch (err) {
+			if (authority && !authority.isCurrent()) return cancelledJoinResult();
+			return {
+				ok: false,
+				message: `Failed to resolve Discord channel ${channelId}: ${formatErrorMessage(err)}`,
+				guildId,
+				channelId
+			};
+		}
+		if (authority && !authority.isCurrent()) return cancelledJoinResult();
+		if (!isVoiceChannel(channelInfo.type)) return {
 			ok: false,
 			message: `Channel ${channelId} is not a voice channel.`
 		};
@@ -1774,12 +1808,7 @@ var DiscordVoiceSessions = class {
 				voiceSdk,
 				reason: `cancelled join guild ${guildId} channel ${channelId}`
 			});
-			return {
-				ok: false,
-				message: "Discord voice join was cancelled.",
-				guildId,
-				channelId
-			};
+			return cancelledJoinResult();
 		}
 		if (this.params.destroyed()) {
 			destroyVoiceConnectionSafely({
@@ -1855,6 +1884,7 @@ var DiscordVoiceSessions = class {
 		};
 		const entry = {
 			generation: authority?.generation ?? 0,
+			autoJoinWhenOccupied: options?.autoJoinWhenOccupied === true,
 			sessionLifecycle: { status: "active" },
 			guildId,
 			guildName: channelInfo && "guild" in channelInfo && channelInfo.guild && typeof channelInfo.guild.name === "string" ? channelInfo.guild.name : void 0,
@@ -1867,6 +1897,7 @@ var DiscordVoiceSessions = class {
 			player,
 			playbackQueue: Promise.resolve(),
 			processingQueue: Promise.resolve(),
+			ttsStreamFallbackWarned: false,
 			capture: createVoiceCaptureState(),
 			transcripts: options?.transcripts,
 			receiveRecovery: createVoiceReceiveRecoveryState(),
@@ -2011,8 +2042,9 @@ var DiscordVoiceSessions = class {
 			ok: false,
 			message: "Discord realtime voice session stopped before startup completed."
 		};
-		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-C7wen-aF.js");
+		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-ysbMG8v7.js");
 		const realtime = new DiscordRealtimeVoiceSession({
+			accountId: this.params.accountId,
 			bootstrapContextInstructions,
 			cfg: this.params.cfg,
 			discordConfig: this.params.discordConfig,
@@ -2069,8 +2101,8 @@ var DiscordVoiceSessions = class {
 //#endregion
 //#region extensions/discord/src/voice/listeners.ts
 const logger$1 = createSubsystemLogger("discord/voice");
-function startAutoJoin(manager) {
-	manager.autoJoin().catch((err) => logger$1.warn(`discord voice: autoJoin failed: ${formatErrorMessage(err)}`));
+function startAutoJoin(operation, context = "") {
+	operation().catch((err) => logger$1.warn(`discord voice: autoJoin${context} failed: ${formatErrorMessage(err)}`));
 }
 var DiscordVoiceReadyListener = class extends ReadyListener {
 	constructor(manager) {
@@ -2078,7 +2110,7 @@ var DiscordVoiceReadyListener = class extends ReadyListener {
 		this.manager = manager;
 	}
 	async handle(_data, _client) {
-		startAutoJoin(this.manager);
+		startAutoJoin(() => this.manager.autoJoin());
 	}
 };
 var DiscordVoiceResumedListener = class extends ResumedListener {
@@ -2087,7 +2119,7 @@ var DiscordVoiceResumedListener = class extends ResumedListener {
 		this.manager = manager;
 	}
 	async handle(_data, _client) {
-		startAutoJoin(this.manager);
+		startAutoJoin(() => this.manager.autoJoin());
 	}
 };
 var DiscordVoiceGuildCreateListener = class {
@@ -2096,7 +2128,10 @@ var DiscordVoiceGuildCreateListener = class {
 		this.type = discord_exports.GatewayDispatchEvents.GuildCreate;
 	}
 	async handle(data, _client) {
-		if (!data.unavailable) this.manager.refreshGuildRoster(data.id);
+		if (!data.unavailable) {
+			this.manager.refreshGuildRoster(data.id);
+			startAutoJoin(() => this.manager.reconcileAutoJoinGuild(data.id), ` occupancy reconciliation guild=${data.id}`);
+		}
 	}
 };
 var DiscordVoiceStateUpdateListener = class extends VoiceStateUpdateListener {
@@ -2137,9 +2172,10 @@ var DiscordVoiceManager = class {
 		this.guildLifecycles = /* @__PURE__ */ new Map();
 		this.nextGuildGeneration = 0;
 		this.joinTasks = /* @__PURE__ */ new Map();
-		this.autoJoinTask = null;
+		this.autoJoinTasks = /* @__PURE__ */ new Map();
 		this.fatalAutoJoinFailures = /* @__PURE__ */ new Map();
 		this.destroyed = false;
+		this.client = params.client;
 		this.botUserId = params.botUserId;
 		this.voiceEnabled = resolveDiscordVoiceEnabled(params.discordConfig.voice);
 		const voiceAccess = resolveDiscordVoiceAccess(params);
@@ -2153,6 +2189,7 @@ var DiscordVoiceManager = class {
 		});
 		this.membership = new DiscordVoiceMembershipTracker(params.client, this.speakerContext, params.accountId);
 		this.receive = new DiscordVoiceReceive({
+			accountId: params.accountId,
 			admissionAllowFrom: this.admissionAllowFrom,
 			botUserId: () => this.botUserId,
 			cfg: params.cfg,
@@ -2218,51 +2255,24 @@ var DiscordVoiceManager = class {
 	}
 	async autoJoin() {
 		if (!this.voiceEnabled || this.destroyed) return;
-		if (this.autoJoinTask) return this.autoJoinTask;
-		this.autoJoinTask = (async () => {
-			const entries = this.autoJoinChannels;
-			const entriesByGuild = /* @__PURE__ */ new Map();
-			const duplicateGuilds = /* @__PURE__ */ new Set();
-			for (const entry of entries) {
-				const guildId = entry.guildId.trim();
-				const channelId = entry.channelId.trim();
-				if (!guildId || !channelId) continue;
-				if (entriesByGuild.has(guildId)) duplicateGuilds.add(guildId);
-				entriesByGuild.set(guildId, {
-					guildId,
-					channelId
-				});
-			}
-			logVoiceVerbose(`autoJoin: ${entries.length} entries, ${entriesByGuild.size} guilds`);
-			for (const guildId of duplicateGuilds) {
-				const selected = entriesByGuild.get(guildId);
-				if (selected) logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; using channel ${selected.channelId}`);
-			}
-			for (const entry of entriesByGuild.values()) {
-				const failureKey = formatAutoJoinFailureKey(entry);
-				const fatalFailure = this.fatalAutoJoinFailures.get(failureKey);
-				if (fatalFailure) {
-					if (!fatalFailure.skipLogged) {
-						logger.warn(`discord voice: autoJoin suppressed guild=${entry.guildId} channel=${entry.channelId} after fatal startup failure; retry with /vc join or reload config after fixing credentials: ${fatalFailure.message}`);
-						fatalFailure.skipLogged = true;
-					}
-					continue;
-				}
-				logVoiceVerbose(`autoJoin: joining guild ${entry.guildId} channel ${entry.channelId}`);
-				const result = await this.join(entry);
-				if (!result.ok) {
-					logger.warn(`discord voice: autoJoin skipped guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
-					if (isFatalAutoJoinFailure(result.message)) this.fatalAutoJoinFailures.set(failureKey, {
-						message: result.message,
-						skipLogged: false
-					});
-				}
-			}
-			await this.following.startReconciliation();
-		})().finally(() => {
-			this.autoJoinTask = null;
-		});
-		return this.autoJoinTask;
+		const entriesByGuild = /* @__PURE__ */ new Map();
+		const duplicateGuilds = /* @__PURE__ */ new Set();
+		for (const entry of this.autoJoinChannels) {
+			if (entriesByGuild.has(entry.guildId)) duplicateGuilds.add(entry.guildId);
+			entriesByGuild.set(entry.guildId, entry);
+		}
+		logVoiceVerbose(`autoJoin: ${this.autoJoinChannels.length} entries, ${entriesByGuild.size} guilds`);
+		for (const guildId of duplicateGuilds) {
+			const selected = entriesByGuild.get(guildId);
+			if (selected) logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; using channel ${selected.channelId}`);
+		}
+		for (const entry of entriesByGuild.values()) await this.enqueueAutoJoin(entry);
+		await this.following.startReconciliation();
+	}
+	async reconcileAutoJoinGuild(guildId) {
+		const entry = this.resolveAutoJoinTarget(guildId);
+		if (!entry?.whenOccupied || !this.voiceEnabled || this.destroyed) return;
+		await this.enqueueAutoJoin(entry);
 	}
 	status() {
 		return Array.from(this.guildLifecycles.values()).filter((lifecycle) => lifecycle.status === "active").map(({ instance: session }) => ({
@@ -2279,6 +2289,24 @@ var DiscordVoiceManager = class {
 			channelId: params.channelId.trim()
 		});
 	}
+	async resolveAccessTarget(params) {
+		const [guild, channel] = await Promise.all([this.client.fetchGuild(params.guildId).catch(() => null), this.client.fetchChannel(params.channelId).catch(() => null)]);
+		if (!guild || !channel) return;
+		const context = await resolveFetchedDiscordThreadLikeChannelContext({
+			client: this.client,
+			channel,
+			channelIdFallback: params.channelId
+		});
+		return {
+			guild,
+			...context.channelName ? { channelName: context.channelName } : {},
+			channelSlug: context.channelSlug,
+			...context.parentId ? { parentId: context.parentId } : {},
+			...context.threadParentName ? { parentName: context.threadParentName } : {},
+			...context.threadParentSlug ? { parentSlug: context.threadParentSlug } : {},
+			scope: context.isThreadChannel ? "thread" : "channel"
+		};
+	}
 	async join(params, options) {
 		if (this.destroyed) return {
 			ok: false,
@@ -2429,6 +2457,7 @@ var DiscordVoiceManager = class {
 				guildId,
 				channelId
 			});
+			await this.reconcileAutoJoinGuild(guildId);
 			return;
 		}
 		this.membership.track(this.sessions.get(guildId), data, previousVoiceState);
@@ -2437,6 +2466,8 @@ var DiscordVoiceManager = class {
 			channelId,
 			userId
 		});
+		const autoJoinTarget = this.resolveAutoJoinTarget(guildId);
+		if (autoJoinTarget?.whenOccupied) await this.enqueueAutoJoin(autoJoinTarget);
 	}
 	async destroy() {
 		this.destroyed = true;
@@ -2454,6 +2485,65 @@ var DiscordVoiceManager = class {
 		const lifecycle = this.guildLifecycles.get(entry.guildId);
 		return lifecycle?.status === "active" && lifecycle.generation === entry.generation && lifecycle.instance === entry && entry.sessionLifecycle.status === "active";
 	}
+	resolveAutoJoinTarget(guildId) {
+		return this.autoJoinChannels.toReversed().find((entry) => entry.guildId === guildId.trim());
+	}
+	enqueueAutoJoin(entry) {
+		const task = (this.autoJoinTasks.get(entry.guildId) ?? Promise.resolve()).catch(() => void 0).then(async () => await this.reconcileAutoJoinEntry(entry)).finally(() => {
+			if (this.autoJoinTasks.get(entry.guildId) === task) this.autoJoinTasks.delete(entry.guildId);
+		});
+		this.autoJoinTasks.set(entry.guildId, task);
+		return task;
+	}
+	async reconcileAutoJoinEntry(entry) {
+		if (this.destroyed) return;
+		const failureKey = formatAutoJoinFailureKey(entry);
+		const fatalFailure = this.fatalAutoJoinFailures.get(failureKey);
+		if (fatalFailure) {
+			if (!fatalFailure.skipLogged) {
+				logger.warn(`discord voice: autoJoin suppressed guild=${entry.guildId} channel=${entry.channelId} after fatal startup failure; retry with /vc join or reload config after fixing credentials: ${fatalFailure.message}`);
+				fatalFailure.skipLogged = true;
+			}
+			return;
+		}
+		if (entry.whenOccupied) {
+			const states = listDiscordVoiceParticipantStates({
+				client: this.client,
+				guildId: entry.guildId,
+				channelId: entry.channelId
+			});
+			if (states === null) {
+				logVoiceVerbose(`autoJoin waiting for guild voice snapshot guild=${entry.guildId} channel=${entry.channelId}`);
+				return;
+			}
+			const humanCount = countDiscordVoiceHumanParticipants({
+				states,
+				botUserId: this.botUserId
+			});
+			const existing = this.sessions.get(entry.guildId);
+			if (humanCount === 0) {
+				if (!existing?.autoJoinWhenOccupied || existing.channelId !== entry.channelId) return;
+				logger.info(`discord voice: occupied autoJoin leaving empty channel guild=${entry.guildId} channel=${entry.channelId}`);
+				const result = await this.leave({
+					guildId: entry.guildId,
+					channelId: entry.channelId
+				});
+				if (!result.ok) logger.warn(`discord voice: occupied autoJoin failed to leave guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
+				return;
+			}
+			const lifecycle = this.guildLifecycles.get(entry.guildId);
+			if (existing || lifecycle?.status === "starting" || lifecycle?.status === "active") return;
+			logger.info(`discord voice: occupied autoJoin joining guild=${entry.guildId} channel=${entry.channelId} humans=${humanCount}`);
+		} else logVoiceVerbose(`autoJoin: joining guild ${entry.guildId} channel ${entry.channelId}`);
+		const result = await this.join(entry, { autoJoinWhenOccupied: entry.whenOccupied === true });
+		if (!result.ok) {
+			logger.warn(`discord voice: autoJoin skipped guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
+			if (isFatalAutoJoinFailure(result.message)) this.fatalAutoJoinFailures.set(failureKey, {
+				message: result.message,
+				skipLogged: false
+			});
+		}
+	}
 };
 //#endregion
 export { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener };

package/openclaw.plugin.json

@@ -17,10 +17,6 @@
     "discord"
   ],
   "contracts": {
-    "tools": [
-      "show_widget",
-      "discord_widget"
-    ],
     "transcriptSourceProviders": [
       "discord-voice"
     ]
@@ -1181,6 +1177,9 @@
                     "channelId": {
                       "type": "string",
                       "minLength": 1
+                    },
+                    "whenOccupied": {
+                      "type": "boolean"
                     }
                   },
                   "required": [
@@ -2989,6 +2988,9 @@
                           "channelId": {
                             "type": "string",
                             "minLength": 1
+                          },
+                          "whenOccupied": {
+                            "type": "boolean"
                           }
                         },
                         "required": [
@@ -3902,7 +3904,11 @@
         },
         "voice.autoJoin": {
           "label": "Discord Voice Auto-Join",
-          "help": "Voice channels to auto-join on startup (list of guildId/channelId entries)."
+          "help": "Voice channels to auto-join (list of guildId/channelId entries). Set whenOccupied on an entry to connect only while humans are present."
+        },
+        "voice.autoJoin.*.whenOccupied": {
+          "label": "Discord Voice Auto-Join When Occupied",
+          "help": "Join and remain in this auto-managed voice channel only while at least one human is present. The OpenClaw bot and other bots do not count. Default: false."
         },
         "voice.allowedChannels": {
           "label": "Discord Voice Allowed Channels",
@@ -4035,7 +4041,7 @@
         },
         "activities": {
           "label": "Discord Activities",
-          "help": "Enable Discord Activity widgets for this account. Routes, the agent tool, and the launch handler remain disabled when this block is absent."
+          "help": "Enable the Discord Activity presenter for the core show_widget tool on this account. Activity routes and the launch handler remain disabled when this block is absent."
         },
         "activities.clientSecret": {
           "label": "Discord Activities Client Secret",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/discord",
-  "version": "2026.8.1-beta.2",
+  "version": "2026.8.1-beta.3",
   "description": "OpenClaw Discord channel plugin for channels, DMs, commands, and app events.",
   "repository": {
     "type": "git",
@@ -13,14 +13,13 @@
     "discord-api-types": "0.38.52",
     "libopus-wasm": "0.2.0",
     "mdast-util-from-markdown": "2.0.3",
-    "p-map": "7.0.6",
     "typebox": "1.3.6",
     "undici": "8.9.0",
     "ws": "8.21.1",
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.8.1-beta.2"
+    "openclaw": ">=2026.8.1-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -95,10 +94,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.8.1-beta.2"
+      "pluginApi": ">=2026.8.1-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.8.1-beta.2",
+      "openclawVersion": "2026.8.1-beta.3",
       "staticAssets": [
         {
           "source": "./assets/embedded-app-sdk.mjs",
@@ -130,7 +129,6 @@
     "discord-api-types",
     "libopus-wasm",
     "mdast-util-from-markdown",
-    "p-map",
     "typebox",
     "undici",
     "ws",