@openclaw/discord 2026.5.20 → 2026.5.24-beta.1

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

@@ -1,9 +1,9 @@
-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 { Ht as parseDiscordTarget, _ as VoiceStateUpdateListener, c as discord_exports, h as ResumedListener, jt as getGuildVoiceState, m as ReadyListener } from "./send.receipt--EtaMe11.js";
+import { c as resolveDiscordAccountAllowFrom } from "./accounts-dXTfmnSZ.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 { i as formatMention } from "./send.outbound-CWhhKank.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { o as authorizeDiscordVoiceIngress, u as resolveDiscordVoiceEnabled } from "./provider-CzKMDsSE.js";
+import { o as authorizeDiscordVoiceIngress, u as resolveDiscordVoiceEnabled } from "./provider-CPLDWYC9.js";
 import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-B5EsqsSr.js";
 import { createRequire } from "node:module";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -16,7 +16,7 @@ import { resolvePreferredOpenClawTmpDir, tempWorkspace } from "openclaw/plugin-s
 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 { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONTROL_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceAgentConsultChatMessage, buildRealtimeVoiceAgentConsultPolicyInstructions, controlRealtimeVoiceAgentRun, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceBridgeSession, parseRealtimeVoiceAgentControlToolArgs, resamplePcm, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultToolPolicy, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow, shouldAutoControlRealtimeVoiceAgentText } 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";
@@ -341,6 +341,24 @@ async function resolveDiscordVoiceRealtimeBootstrapContext(params) {
 	}
 }
 //#endregion
+//#region extensions/discord/src/voice/agent-control.ts
+async function maybeControlDiscordVoiceAgentRun(params) {
+	if (!shouldAutoControlRealtimeVoiceAgentText(params.text)) return { handled: false };
+	const result = await controlRealtimeVoiceAgentRun({
+		sessionKey: params.entry.route.sessionKey,
+		text: params.text
+	});
+	if (!result.active) return {
+		handled: false,
+		result
+	};
+	return {
+		handled: true,
+		result,
+		...result.speak && !result.suppress ? { speakText: result.message } : {}
+	};
+}
+//#endregion
 //#region extensions/discord/src/voice/prompt.ts
 const DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT = [
 	"You are OpenClaw's Discord voice interface in a live voice channel.",
@@ -385,6 +403,11 @@ function isVoiceChannel(type) {
 //#endregion
 //#region extensions/discord/src/voice/realtime.ts
 const logger$2 = createSubsystemLogger("discord/voice");
+function resolveDiscordRealtimeVoiceAgentConsultTools(policy) {
+	const tools = resolveRealtimeVoiceAgentConsultTools(policy);
+	if (policy !== "none" && !tools.some((tool) => tool.name === REALTIME_VOICE_AGENT_CONTROL_TOOL.name)) return [...tools, REALTIME_VOICE_AGENT_CONTROL_TOOL];
+	return tools;
+}
 const DISCORD_REALTIME_TALKBACK_DEBOUNCE_MS = 350;
 const DISCORD_REALTIME_FALLBACK_TEXT = "I hit an error while checking that. Please try again.";
 const DISCORD_REALTIME_PENDING_SPEAKER_CONTEXT_LIMIT = 32;
@@ -394,6 +417,8 @@ const DISCORD_REALTIME_LOG_PREVIEW_CHARS = 500;
 const DISCORD_REALTIME_DEFAULT_MIN_BARGE_IN_AUDIO_END_MS = 250;
 const DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
 const DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS = 6e4;
+const DISCORD_REALTIME_CONTROL_SPEECH_DEDUPE_MS = 5e3;
+const DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS = 1500;
 const REALTIME_PCM16_BYTES_PER_SAMPLE = 2;
 const DISCORD_RAW_PCM_FRAME_BYTES = 3840;
 const DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES = 25;
@@ -422,6 +447,7 @@ const DISCORD_REALTIME_FORCED_CONSULT_TRAILING_FRAGMENT_WORDS = new Set([
 	"to",
 	"with"
 ]);
+const DISCORD_REALTIME_FORCED_CONSULT_REASON = "provider_final_transcript_without_openclaw_agent_consult";
 const DISCORD_REALTIME_VERBOSE_OMITTED_EVENTS = new Set([
 	"conversation.output_audio.delta",
 	"input_audio_buffer.append",
@@ -540,6 +566,39 @@ function extractDiscordExactSpeechConsultText(args) {
 function normalizeRealtimeConsultMatchText(text) {
 	return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
+function normalizeControlSpeechText(text) {
+	return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function normalizeWakeName(value) {
+	return value.toLowerCase().replace(/\s+/g, " ").trim() || void 0;
+}
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function includesWakeName(text, wakeName) {
+	const normalizedText = normalizeRealtimeConsultMatchText(text);
+	const normalizedName = normalizeWakeName(wakeName);
+	if (!normalizedName) return false;
+	return new RegExp(`(^|[^a-z0-9])${escapeRegExp$1(normalizedName)}([^a-z0-9]|$)`).test(normalizedText);
+}
+function stripLeadingWakeName(text, wakeName) {
+	const normalizedName = normalizeWakeName(wakeName);
+	if (!normalizedName) return text.trim();
+	const wakePattern = normalizedName.split(" ").map(escapeRegExp$1).join("\\s+");
+	return text.replace(new RegExp(`^\\s*(?:(?:hey|ok|okay)(?:\\s*[-,:;]+\\s*|\\s+))?${wakePattern}(?:\\s*[-,:;]+\\s*|\\s+)`, "i"), "").trim();
+}
+function resolveDiscordRealtimeWakeNames(params) {
+	const configured = params.config?.wakeNames?.map((name) => normalizeWakeName(name)).filter((name) => Boolean(name));
+	if (configured && configured.length > 0) return sortWakeNames(Array.from(new Set(configured)));
+	const agent = params.cfg.agents?.list?.find((candidate) => candidate.id === params.agentId);
+	const configuredAgentNames = [agent?.name, agent?.identity?.name].map((name) => typeof name === "string" ? normalizeWakeName(name) : void 0).filter((name) => Boolean(name));
+	const productWakeNames = [normalizeWakeName("OpenClaw")].filter((name) => Boolean(name));
+	const defaults = configuredAgentNames.length > 0 ? [...configuredAgentNames, ...productWakeNames] : [normalizeWakeName(params.agentId), ...productWakeNames].filter((name) => Boolean(name));
+	return sortWakeNames(Array.from(new Set(defaults)));
+}
+function sortWakeNames(wakeNames) {
+	return wakeNames.toSorted((left, right) => right.length - left.length || left.localeCompare(right));
+}
 function matchesPendingAgentProxyQuestion(consultMessage, question) {
 	const normalizedConsult = normalizeRealtimeConsultMatchText(consultMessage);
 	const normalizedQuestion = normalizeRealtimeConsultMatchText(question);
@@ -554,6 +613,8 @@ var DiscordRealtimeVoiceSession = class {
 		this.stopped = false;
 		this.consultToolPolicy = "safe-read-only";
 		this.consultPolicy = "auto";
+		this.requireWakeName = false;
+		this.wakeNames = [];
 		this.pendingAgentProxyConsultContexts = [];
 		this.recentAgentProxyConsultContexts = [];
 		this.pendingSpeakerTurns = [];
@@ -605,9 +666,16 @@ var DiscordRealtimeVoiceSession = class {
 		this.consultToolsAllow = resolveRealtimeVoiceAgentConsultToolsAllow(toolPolicy);
 		const consultPolicy = this.realtimeConfig?.consultPolicy ?? (isAgentProxy ? "always" : "auto");
 		this.consultPolicy = consultPolicy;
+		const supportsWakeNameGate = resolved.provider.id === "openai";
+		this.requireWakeName = this.realtimeConfig?.requireWakeName === true && isAgentProxy && supportsWakeNameGate;
+		this.wakeNames = this.requireWakeName ? resolveDiscordRealtimeWakeNames({
+			config: this.realtimeConfig,
+			cfg: this.params.cfg,
+			agentId: this.params.entry.route.agentId
+		}) : [];
 		const usesRealtimeAgentHandoff = this.params.mode === "bidi" || toolPolicy !== "none";
-		const autoRespondToAudio = !isAgentProxy || consultPolicy !== "always";
-		const interruptResponseOnInputAudio = resolveDiscordRealtimeInterruptResponseOnInputAudio({
+		const autoRespondToAudio = !this.requireWakeName && (!isAgentProxy || consultPolicy !== "always");
+		const interruptResponseOnInputAudio = !this.requireWakeName && resolveDiscordRealtimeInterruptResponseOnInputAudio({
 			realtimeConfig: this.realtimeConfig,
 			providerId: resolved.provider.id
 		});
@@ -626,7 +694,7 @@ var DiscordRealtimeVoiceSession = class {
 			autoRespondToAudio,
 			interruptResponseOnInputAudio,
 			markStrategy: "ack-immediately",
-			tools: usesRealtimeAgentHandoff ? resolveRealtimeVoiceAgentConsultTools(toolPolicy) : [],
+			tools: usesRealtimeAgentHandoff ? resolveDiscordRealtimeVoiceAgentConsultTools(toolPolicy) : [],
 			audioSink: {
 				isOpen: () => !this.stopped,
 				sendAudio: (audio) => this.sendOutputAudio(audio),
@@ -634,12 +702,9 @@ var DiscordRealtimeVoiceSession = class {
 			},
 			onTranscript: (role, text, isFinal) => {
 				if (isFinal && text.trim()) logger$2.info(`discord voice: realtime ${role} transcript (${text.length} chars): ${formatRealtimeLogPreview(text)}`);
-				if (!isFinal || role !== "user" || !isDiscordAgentProxyVoiceMode(this.params.mode)) return;
-				if (usesRealtimeAgentHandoff) {
-					this.scheduleForcedAgentProxyConsult(text);
-					return;
-				}
-				this.talkback.enqueue(text, this.consumePendingSpeakerContext());
+				if (isFinal && role === "assistant") this.suppressDuplicateControlSpeech(text);
+				if (!isFinal || role !== "user") return;
+				this.handleFinalUserTranscript(text, { usesRealtimeAgentHandoff });
 			},
 			onToolCall: (event, session) => this.handleToolCall(event, session),
 			onEvent: (event) => {
@@ -660,7 +725,7 @@ var DiscordRealtimeVoiceSession = class {
 		});
 		const resolvedModel = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
 		const resolvedVoice = readProviderConfigString(resolved.providerConfig, "voice");
-		logger$2.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${autoRespondToAudio} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${resolveDiscordRealtimeBargeIn({
+		logger$2.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${autoRespondToAudio} requireWakeName=${this.requireWakeName} wakeNames=${this.wakeNames.join(",") || "none"} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${resolveDiscordRealtimeBargeIn({
 			realtimeConfig: this.realtimeConfig,
 			providerId: resolved.provider.id
 		})} minBargeInAudioEndMs=${resolveDiscordRealtimeMinBargeInAudioEndMs(this.realtimeConfig)}`);
@@ -766,6 +831,7 @@ var DiscordRealtimeVoiceSession = class {
 		this.bridge?.handleBargeIn({ audioPlaybackActive: true });
 	}
 	isBargeInEnabled() {
+		if (this.requireWakeName) return false;
 		const providerId = this.realtimeProviderId ?? this.realtimeConfig?.provider ?? "openai";
 		return resolveDiscordRealtimeBargeIn({
 			realtimeConfig: this.realtimeConfig,
@@ -839,6 +905,7 @@ var DiscordRealtimeVoiceSession = class {
 	}
 	resetOutputStream(reason = "reset") {
 		const stream = this.outputStream;
+		this.clearOutputPlaybackWatchdog();
 		this.logOutputAudioStopped(reason);
 		this.outputStream = null;
 		this.outputPacedBuffer = Buffer.alloc(0);
@@ -852,8 +919,10 @@ var DiscordRealtimeVoiceSession = class {
 		if (!stream || stream.destroyed || this.outputStreamEnding) return;
 		this.outputStreamEnding = true;
 		logger$2.info(`discord voice: realtime audio playback finishing reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} audioMs=${Math.floor(this.outputAudioTimestampMs)} chunks=${this.outputAudioChunks}`);
-		if (playBuffered) this.startOutputPlayback(stream);
-		else {
+		if (playBuffered) {
+			this.startOutputPlayback(stream);
+			this.scheduleOutputPlaybackWatchdog(reason, stream);
+		} else {
 			this.resetOutputStream(reason);
 			this.params.entry.player.stop(true);
 			this.completeExactSpeechResponse(reason);
@@ -861,6 +930,28 @@ var DiscordRealtimeVoiceSession = class {
 		}
 		stream.end();
 	}
+	scheduleOutputPlaybackWatchdog(reason, stream) {
+		this.clearOutputPlaybackWatchdog();
+		if (!this.outputAudioStartedAt || this.outputAudioTimestampMs <= 0) return;
+		const elapsedMs = Date.now() - this.outputAudioStartedAt;
+		const timeoutMs = Math.max(1e3, this.outputAudioTimestampMs - elapsedMs + DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS);
+		this.outputPlaybackWatchdog = setTimeout(() => {
+			this.outputPlaybackWatchdog = void 0;
+			if (this.outputStream && this.outputStream !== stream) return;
+			if (!this.outputStream && !this.isOutputAudioActive()) {
+				this.completeExactSpeechResponse("playback-watchdog");
+				return;
+			}
+			logger$2.warn(`discord voice: realtime audio playback watchdog fired reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} audioMs=${Math.floor(this.outputAudioTimestampMs)} elapsedMs=${this.outputAudioStartedAt ? Date.now() - this.outputAudioStartedAt : 0}`);
+			this.clearOutputAudio("playback-watchdog");
+			this.completeExactSpeechResponse("playback-watchdog");
+		}, timeoutMs);
+	}
+	clearOutputPlaybackWatchdog() {
+		if (!this.outputPlaybackWatchdog) return;
+		clearTimeout(this.outputPlaybackWatchdog);
+		this.outputPlaybackWatchdog = void 0;
+	}
 	enqueueExactSpeechMessage(text) {
 		if (this.stopped || !text.trim()) return;
 		if (this.exactSpeechResponseActive || this.hasInterruptibleOutputAudio()) {
@@ -876,6 +967,40 @@ var DiscordRealtimeVoiceSession = class {
 		this.exactSpeechAudioStarted = false;
 		this.bridge?.sendUserMessage(buildDiscordSpeakExactUserMessage(text));
 	}
+	speakControlResult(text) {
+		const trimmed = text.trim();
+		if (this.stopped || !trimmed) return;
+		this.queuedExactSpeechMessages = [];
+		this.completeExactSpeechResponse("active-run-control", { drain: false });
+		this.bridge?.handleBargeIn?.({
+			audioPlaybackActive: true,
+			force: true
+		});
+		this.clearOutputAudio("active-run-control");
+		this.lastControlSpeech = {
+			normalizedText: normalizeControlSpeechText(trimmed),
+			sentAt: Date.now(),
+			assistantTranscriptCount: 0
+		};
+		this.sendExactSpeechMessage(trimmed);
+	}
+	suppressDuplicateControlSpeech(text) {
+		const recent = this.lastControlSpeech;
+		if (!recent) return;
+		if (Date.now() - recent.sentAt > DISCORD_REALTIME_CONTROL_SPEECH_DEDUPE_MS) {
+			this.lastControlSpeech = void 0;
+			return;
+		}
+		if (normalizeControlSpeechText(text) !== recent.normalizedText) return;
+		recent.assistantTranscriptCount += 1;
+		if (recent.assistantTranscriptCount <= 1) return;
+		logger$2.info(`discord voice: realtime duplicate active-run control speech suppressed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`);
+		this.bridge?.handleBargeIn?.({
+			audioPlaybackActive: true,
+			force: true
+		});
+		this.clearOutputAudio("duplicate-active-run-control");
+	}
 	completeExactSpeechResponse(reason, options) {
 		if (!this.exactSpeechResponseActive && this.queuedExactSpeechMessages.length === 0) return;
 		this.exactSpeechResponseActive = false;
@@ -932,6 +1057,10 @@ var DiscordRealtimeVoiceSession = class {
 	}
 	handleToolCall(event, session) {
 		const callId = event.callId || event.itemId || "unknown";
+		if (event.name === REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME) {
+			this.handleAgentControlToolCall(event, session, callId);
+			return;
+		}
 		if (event.name !== REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
 			session.submitToolResult(callId, { error: `Tool "${event.name}" not available` });
 			return;
@@ -948,7 +1077,6 @@ var DiscordRealtimeVoiceSession = class {
 		}
 		const consultMessage = buildRealtimeVoiceAgentConsultChatMessage(event.args);
 		logger$2.info(`discord voice: realtime consult requested call=${callId || "unknown"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatRealtimeLogPreview(consultMessage)}`);
-		if (session.bridge.supportsToolResultContinuation) session.submitToolResult(callId, buildRealtimeVoiceAgentConsultWorkingResponse("speaker"), { willContinue: true });
 		const pendingConsultContext = this.consumeAgentProxyConsultContext(consultMessage);
 		if (pendingConsultContext) this.addRecentAgentProxyConsultQuestion(pendingConsultContext.recent, consultMessage);
 		let context = pendingConsultContext?.context;
@@ -986,6 +1114,20 @@ var DiscordRealtimeVoiceSession = class {
 			session.submitToolResult(callId, { error: formatErrorMessage(error) });
 		});
 	}
+	async handleAgentControlToolCall(event, session, callId) {
+		try {
+			const parsed = parseRealtimeVoiceAgentControlToolArgs(event.args);
+			const result = await controlRealtimeVoiceAgentRun({
+				sessionKey: this.params.entry.route.sessionKey,
+				text: parsed.text,
+				mode: parsed.mode
+			});
+			this.logAgentControlResult(result);
+			session.submitToolResult(callId, result);
+		} catch (error) {
+			session.submitToolResult(callId, { error: formatErrorMessage(error) });
+		}
+	}
 	async runAgentTurn(params) {
 		const context = params.context;
 		if (!context) return "";
@@ -996,8 +1138,86 @@ var DiscordRealtimeVoiceSession = class {
 			userId: context.userId
 		});
 	}
-	scheduleForcedAgentProxyConsult(transcript) {
-		if (this.consultPolicy !== "always") return;
+	async handleFinalUserTranscript(text, params) {
+		const trimmed = text.trim();
+		if (!trimmed) return;
+		const meetingNotesTurn = this.peekPendingSpeakerTurn();
+		this.recordMeetingNotesUtterance(trimmed, meetingNotesTurn);
+		const wakeNameResult = this.resolveWakeNameTranscript(trimmed);
+		if (!wakeNameResult.allowed) {
+			logger$2.info(`discord voice: realtime wake-name gate ignored transcript chars=${trimmed.length} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId} wakeNames=${this.wakeNames.join(",") || "none"}`);
+			this.consumePendingSpeakerContext();
+			return;
+		}
+		const acceptedText = wakeNameResult.text || trimmed;
+		const usesAgentProxy = isDiscordAgentProxyVoiceMode(this.params.mode);
+		const pendingForcedConsult = usesAgentProxy && params.usesRealtimeAgentHandoff ? this.prepareForcedAgentProxyConsult(acceptedText) : void 0;
+		const control = await maybeControlDiscordVoiceAgentRun({
+			entry: this.params.entry,
+			text: acceptedText
+		}).catch((error) => {
+			logger$2.warn(`discord voice: realtime active-run control failed; falling back to normal transcript handling: ${formatErrorMessage(error)}`);
+		});
+		if (control?.handled) {
+			if (pendingForcedConsult) {
+				this.removePendingAgentProxyConsultContext(pendingForcedConsult);
+				this.forgetRecentAgentProxyConsultContext(pendingForcedConsult.recent);
+			}
+			this.logAgentControlResult(control.result);
+			if (control.speakText) this.speakControlResult(control.speakText);
+			return;
+		}
+		if (!usesAgentProxy) return;
+		if (params.usesRealtimeAgentHandoff) {
+			if (pendingForcedConsult) this.schedulePreparedForcedAgentProxyConsult(pendingForcedConsult);
+			return;
+		}
+		this.talkback.enqueue(acceptedText, this.consumePendingSpeakerContext());
+	}
+	resolveWakeNameTranscript(text) {
+		if (!this.requireWakeName) return {
+			allowed: true,
+			text
+		};
+		const wakeName = this.wakeNames.find((name) => includesWakeName(text, name));
+		if (wakeName) return {
+			allowed: true,
+			text: stripLeadingWakeName(text, wakeName)
+		};
+		return {
+			allowed: false,
+			text
+		};
+	}
+	recordMeetingNotesUtterance(text, turn) {
+		const meetingNotes = this.params.entry.meetingNotes;
+		if (!meetingNotes || !turn) return;
+		const context = turn.context;
+		const utterance = {
+			sessionId: meetingNotes.sessionId,
+			startedAt: new Date(turn.startedAt).toISOString(),
+			final: true,
+			speaker: {
+				id: context.userId,
+				label: context.speakerLabel
+			},
+			text,
+			metadata: {
+				channel: "discord",
+				guildId: this.params.entry.guildId,
+				channelId: this.params.entry.channelId,
+				voiceSessionKey: this.params.entry.voiceSessionKey
+			}
+		};
+		Promise.resolve().then(() => meetingNotes.onUtterance(utterance)).catch((error) => {
+			logger$2.warn(`discord voice: realtime meeting notes utterance failed: ${formatErrorMessage(error)}`);
+		});
+	}
+	logAgentControlResult(result) {
+		logger$2.info(`discord voice: realtime active-run control handled mode=${result.mode} ok=${result.ok} active=${result.active} reason=${result.reason ?? "none"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId}`);
+	}
+	prepareForcedAgentProxyConsult(transcript) {
+		if (this.consultPolicy !== "always" && !this.requireWakeName) return;
 		const question = transcript.trim();
 		if (!question) return;
 		const context = this.consumePendingSpeakerContext();
@@ -1021,6 +1241,10 @@ var DiscordRealtimeVoiceSession = class {
 			recent: this.rememberRecentAgentProxyConsultContext(question, context)
 		};
 		this.pendingAgentProxyConsultContexts.push(pending);
+		return pending;
+	}
+	schedulePreparedForcedAgentProxyConsult(pending) {
+		if (!this.pendingAgentProxyConsultContexts.includes(pending) || pending.timer) return;
 		pending.timer = setTimeout(() => {
 			pending.timer = void 0;
 			this.runForcedAgentProxyConsult(pending);
@@ -1052,18 +1276,23 @@ var DiscordRealtimeVoiceSession = class {
 		const index = this.pendingAgentProxyConsultContexts.indexOf(pending);
 		if (index >= 0) this.pendingAgentProxyConsultContexts.splice(index, 1);
 	}
+	forgetRecentAgentProxyConsultContext(recent) {
+		const index = this.recentAgentProxyConsultContexts.indexOf(recent);
+		if (index >= 0) this.recentAgentProxyConsultContexts.splice(index, 1);
+	}
 	async runForcedAgentProxyConsult(pending) {
 		this.removePendingAgentProxyConsultContext(pending);
 		const { context, question } = pending;
 		if (this.stopped) return;
 		const startedAt = Date.now();
 		logger$2.info(`discord voice: realtime forced agent consult starting chars=${question.length} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel} owner=${context.senderIsOwner}`);
+		logger$2.debug(`discord voice: realtime forced agent consult reason=${DISCORD_REALTIME_FORCED_CONSULT_REASON} consultPolicy=${this.consultPolicy} requireWakeName=${this.requireWakeName} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel}`);
 		if (this.hasInterruptibleOutputAudio()) logger$2.info(`discord voice: realtime forced agent consult preserving active playback guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} outputAudioMs=${Math.floor(this.outputAudioTimestampMs)} outputActive=${this.isOutputAudioActive()} playbackChunks=${this.outputAudioChunks}`);
 		pending.recent.handledByForcedPlayback = true;
 		try {
 			const promise = this.runAgentTurn({
 				context,
-				message: [question, "Context: The realtime model produced a final user transcript without calling openclaw_agent_consult. OpenClaw is forcing the consult because consultPolicy is always."].join("\n\n")
+				message: question
 			});
 			this.setRecentAgentProxyConsultPromise(pending.recent, promise);
 			const text = await promise;
@@ -1083,6 +1312,11 @@ var DiscordRealtimeVoiceSession = class {
 		this.prunePendingSpeakerTurns();
 		return turn?.context;
 	}
+	peekPendingSpeakerTurn() {
+		this.prunePendingSpeakerTurns();
+		this.expireClosedSpeakerTurnsBeforeLaterAudio();
+		return this.pendingSpeakerTurns.find((turn) => turn.hasAudio);
+	}
 	hasPendingSpeakerAudioContext() {
 		this.prunePendingSpeakerTurns();
 		this.expireClosedSpeakerTurnsBeforeLaterAudio();
@@ -1449,23 +1683,54 @@ async function processDiscordVoiceSegment(params) {
 	}
 	logVoiceVerbose(`transcription ok (${transcript.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
 	logVoiceVerbose(`transcript from ${ingress.speakerLabel} (${userId}) in guild ${entry.guildId} channel ${entry.channelId}: ${formatVoiceTranscriptLogPreview(transcript)}`);
-	const turn = await runDiscordVoiceAgentTurn({
+	if (params.meetingNotes) {
+		await params.meetingNotes.onUtterance({
+			sessionId: params.meetingNotes.sessionId,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			final: true,
+			speaker: {
+				id: userId,
+				label: ingress.speakerLabel
+			},
+			text: transcript,
+			metadata: {
+				channel: "discord",
+				guildId: entry.guildId,
+				channelId: entry.channelId,
+				voiceSessionKey: entry.voiceSessionKey
+			}
+		});
+		return;
+	}
+	let replyText;
+	const control = await maybeControlDiscordVoiceAgentRun({
 		entry,
-		userId,
-		message: formatVoiceIngressPrompt(transcript, ingress.speakerLabel),
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		runtime: params.runtime,
-		context: ingress,
-		ownerAllowFrom: params.ownerAllowFrom,
-		fetchGuildName: params.fetchGuildName,
-		speakerContext: params.speakerContext
+		text: transcript
+	}).catch((error) => {
+		logger$1.warn(`discord voice: active-run control failed; falling back to normal segment handling: ${formatErrorMessage(error)}`);
 	});
-	if (!turn) {
-		logVoiceVerbose(`segment unauthorized before agent turn: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
-		return;
+	if (control?.handled) {
+		logger$1.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 turn = await runDiscordVoiceAgentTurn({
+			entry,
+			userId,
+			message: formatVoiceIngressPrompt(transcript, ingress.speakerLabel),
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			runtime: params.runtime,
+			context: ingress,
+			ownerAllowFrom: params.ownerAllowFrom,
+			fetchGuildName: params.fetchGuildName,
+			speakerContext: params.speakerContext
+		});
+		if (!turn) {
+			logVoiceVerbose(`segment unauthorized before agent turn: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return;
+		}
+		replyText = turn.text;
 	}
-	const replyText = turn.text;
 	if (!replyText) {
 		logVoiceVerbose(`reply empty: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 		return;
@@ -1639,6 +1904,9 @@ function destroyVoiceConnectionSafely(params) {
 		logger.warn(`discord voice: destroy failed: ${params.reason}: ${message}`);
 	}
 }
+function isRetryableVoiceJoinReadyError(error) {
+	return formatErrorMessage(error).toLowerCase().includes("operation was aborted");
+}
 function normalizeVoiceChannelResidencies(entries) {
 	const normalized = [];
 	for (const entry of entries ?? []) {
@@ -1725,6 +1993,7 @@ var DiscordVoiceManager$1 = class {
 	constructor(params) {
 		this.params = params;
 		this.sessions = /* @__PURE__ */ new Map();
+		this.joinTasks = /* @__PURE__ */ new Map();
 		this.autoJoinTask = null;
 		this.fatalAutoJoinFailures = /* @__PURE__ */ new Map();
 		this.followedUserChannels = /* @__PURE__ */ new Map();
@@ -1849,8 +2118,45 @@ var DiscordVoiceManager$1 = class {
 			};
 		}
 		logVoiceVerbose(`join requested: guild ${guildId} channel ${channelId}`);
+		while (true) {
+			const activeJoinTask = this.joinTasks.get(guildId);
+			if (!activeJoinTask) break;
+			logVoiceVerbose(`join: waiting for active guild join guild ${guildId} channel ${channelId}`);
+			await activeJoinTask.catch(() => void 0);
+			if (this.destroyed) return {
+				ok: false,
+				message: "Discord voice manager is stopped.",
+				guildId,
+				channelId
+			};
+		}
+		const joinTask = this.joinUnlocked({
+			guildId,
+			channelId
+		}, options);
+		this.joinTasks.set(guildId, joinTask);
+		try {
+			return await joinTask;
+		} finally {
+			if (this.joinTasks.get(guildId) === joinTask) this.joinTasks.delete(guildId);
+		}
+	}
+	async joinUnlocked(params, options) {
+		const { guildId, channelId } = params;
+		const voiceConfig = this.params.discordConfig.voice;
+		const voiceMode = resolveDiscordVoiceMode(voiceConfig);
 		const existing = this.sessions.get(guildId);
 		if (existing && existing.channelId === channelId) {
+			if (options?.meetingNotes) existing.meetingNotes = options.meetingNotes;
+			if (!options?.meetingNotes && isDiscordRealtimeVoiceMode(voiceMode) && !existing.realtime) {
+				const realtimeResult = await this.attachRealtimeSession(existing, voiceMode, { requireLiveEntry: true });
+				if (!realtimeResult.ok) return {
+					ok: false,
+					message: realtimeResult.message,
+					guildId,
+					channelId
+				};
+			}
 			logVoiceVerbose(`join: already connected to guild ${guildId} channel ${channelId}`);
 			return {
 				ok: true,
@@ -1878,8 +2184,6 @@ var DiscordVoiceManager$1 = class {
 			ok: false,
 			message: "Discord voice plugin is not available."
 		};
-		const voiceConfig = this.params.discordConfig.voice;
-		const voiceMode = resolveDiscordVoiceMode(voiceConfig);
 		const adapterCreator = voicePlugin.getGatewayAdapterCreator(guildId);
 		const daveEncryption = voiceConfig?.daveEncryption;
 		const decryptionFailureTolerance = voiceConfig?.decryptionFailureTolerance;
@@ -1898,28 +2202,56 @@ var DiscordVoiceManager$1 = class {
 			voiceSdk,
 			reason: `stale connection before join guild ${guildId}`
 		});
-		const connection = voiceSdk.joinVoiceChannel({
-			channelId,
-			guildId,
-			adapterCreator,
-			selfDeaf: false,
-			selfMute: false,
-			daveEncryption,
-			decryptionFailureTolerance
-		});
-		try {
-			await voiceSdk.entersState(connection, voiceSdk.VoiceConnectionStatus.Ready, connectReadyTimeoutMs);
-			logVoiceVerbose(`join: connected to guild ${guildId} channel ${channelId}`);
-		} catch (err) {
-			logger.warn(`discord voice: join failed before ready: guild ${guildId} channel ${channelId} timeout=${connectReadyTimeoutMs}ms error=${formatErrorMessage(err)}`);
+		let connection;
+		const connectReadyDeadlineMs = Date.now() + connectReadyTimeoutMs;
+		for (let attempt = 1; attempt <= 2; attempt += 1) {
+			const joinedConnection = voiceSdk.joinVoiceChannel({
+				channelId,
+				guildId,
+				adapterCreator,
+				selfDeaf: false,
+				selfMute: false,
+				daveEncryption,
+				decryptionFailureTolerance
+			});
+			const remainingConnectReadyTimeoutMs = Math.max(1, connectReadyDeadlineMs - Date.now());
+			try {
+				await voiceSdk.entersState(joinedConnection, voiceSdk.VoiceConnectionStatus.Ready, remainingConnectReadyTimeoutMs);
+				connection = joinedConnection;
+				logVoiceVerbose(`join: connected to guild ${guildId} channel ${channelId}`);
+				break;
+			} catch (err) {
+				destroyVoiceConnectionSafely({
+					connection: joinedConnection,
+					voiceSdk,
+					reason: `failed join cleanup guild ${guildId} channel ${channelId}`
+				});
+				if (attempt === 1 && isRetryableVoiceJoinReadyError(err) && !this.destroyed && connectReadyDeadlineMs > Date.now()) {
+					logVoiceVerbose(`join: retrying aborted ready wait guild ${guildId} channel ${channelId}`);
+					continue;
+				}
+				logger.warn(`discord voice: join failed before ready: guild ${guildId} channel ${channelId} timeout=${connectReadyTimeoutMs}ms error=${formatErrorMessage(err)}`);
+				return {
+					ok: false,
+					message: `Failed to join voice channel: ${formatErrorMessage(err)}`
+				};
+			}
+		}
+		if (!connection) return {
+			ok: false,
+			message: "Failed to join voice channel."
+		};
+		if (this.destroyed) {
 			destroyVoiceConnectionSafely({
 				connection,
 				voiceSdk,
-				reason: `failed join cleanup guild ${guildId} channel ${channelId}`
+				reason: `manager stopped during join guild ${guildId} channel ${channelId}`
 			});
 			return {
 				ok: false,
-				message: `Failed to join voice channel: ${formatErrorMessage(err)}`
+				message: "Discord voice manager is stopped.",
+				guildId,
+				channelId
 			};
 		}
 		const sessionChannelId = channelInfo?.id ?? channelId;
@@ -1968,6 +2300,8 @@ var DiscordVoiceManager$1 = class {
 			if (disconnectedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
 			if (destroyedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
 			if (playerErrorHandler) player.off("error", playerErrorHandler);
+			entry.pendingRealtime?.close();
+			entry.pendingRealtime = void 0;
 			entry.realtime?.close();
 			entry.realtime = void 0;
 			player.stop();
@@ -1990,7 +2324,9 @@ var DiscordVoiceManager$1 = class {
 			playbackQueue: Promise.resolve(),
 			processingQueue: Promise.resolve(),
 			capture: createVoiceCaptureState(),
+			meetingNotes: options?.meetingNotes,
 			receiveRecovery: createVoiceReceiveRecoveryState(),
+			isStopped: () => stopped,
 			stop: () => {
 				stopEntry(entry, {
 					destroyConnection: true,
@@ -1998,29 +2334,9 @@ 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,
-				mode: voiceMode,
-				runAgentTurn: ({ context, message, toolsAllow, userId }) => this.runDiscordRealtimeAgentTurn({
-					context,
-					entry,
-					message,
-					toolsAllow,
-					userId
-				})
-			});
-			try {
-				await entry.realtime.connect();
-			} catch (err) {
-				entry.realtime.close();
+		if (!options?.meetingNotes && isDiscordRealtimeVoiceMode(voiceMode)) {
+			const realtimeResult = await this.attachRealtimeSession(entry, voiceMode);
+			if (!realtimeResult.ok) {
 				destroyVoiceConnectionSafely({
 					connection,
 					voiceSdk,
@@ -2028,12 +2344,24 @@ var DiscordVoiceManager$1 = class {
 				});
 				return {
 					ok: false,
-					message: `Failed to start Discord realtime voice: ${formatErrorMessage(err)}`,
+					message: realtimeResult.message,
 					guildId,
 					channelId
 				};
 			}
 		}
+		if (this.destroyed) {
+			stopEntry(entry, {
+				destroyConnection: true,
+				reason: `manager stopped during setup guild ${guildId} channel ${channelId}`
+			});
+			return {
+				ok: false,
+				message: "Discord voice manager is stopped.",
+				guildId,
+				channelId
+			};
+		}
 		speakingHandler = (userId) => {
 			this.handleSpeakingStart(entry, userId).catch((err) => {
 				logger.warn(`discord voice: capture failed: ${formatErrorMessage(err)}`);
@@ -2085,6 +2413,52 @@ var DiscordVoiceManager$1 = class {
 			channelId
 		};
 	}
+	async attachRealtimeSession(entry, voiceMode, options) {
+		const bootstrapContextInstructions = await resolveDiscordVoiceRealtimeBootstrapContext({
+			entry,
+			cfg: this.params.cfg,
+			discordConfig: this.params.discordConfig
+		});
+		if (entry.isStopped() || options?.requireLiveEntry === true && this.sessions.get(entry.guildId) !== entry) return {
+			ok: false,
+			message: "Discord realtime voice session stopped before startup completed."
+		};
+		const realtime = new DiscordRealtimeVoiceSession({
+			bootstrapContextInstructions,
+			cfg: this.params.cfg,
+			discordConfig: this.params.discordConfig,
+			entry,
+			mode: voiceMode,
+			runAgentTurn: ({ context, message, toolsAllow, userId }) => this.runDiscordRealtimeAgentTurn({
+				context,
+				entry,
+				message,
+				toolsAllow,
+				userId
+			})
+		});
+		entry.pendingRealtime = realtime;
+		try {
+			await realtime.connect();
+			if (entry.pendingRealtime !== realtime || entry.isStopped() || options?.requireLiveEntry === true && this.sessions.get(entry.guildId) !== entry) {
+				realtime.close();
+				return {
+					ok: false,
+					message: "Discord realtime voice session stopped before startup completed."
+				};
+			}
+			entry.pendingRealtime = void 0;
+			entry.realtime = realtime;
+			return { ok: true };
+		} catch (err) {
+			if (entry.pendingRealtime === realtime) entry.pendingRealtime = void 0;
+			realtime.close();
+			return {
+				ok: false,
+				message: `Failed to start Discord realtime voice: ${formatErrorMessage(err)}`
+			};
+		}
+	}
 	async leave(params, options) {
 		const guildId = params.guildId.trim();
 		logVoiceVerbose(`leave requested: guild ${guildId} channel ${params.channelId ?? "current"}`);
@@ -2097,6 +2471,23 @@ var DiscordVoiceManager$1 = class {
 			ok: false,
 			message: "Not connected to that voice channel."
 		};
+		if (options?.meetingNotesSessionId) {
+			if (!entry.meetingNotes || entry.meetingNotes.sessionId !== options.meetingNotesSessionId) return {
+				ok: false,
+				message: "Meeting notes session is not active in this voice channel.",
+				guildId,
+				channelId: entry.channelId
+			};
+			if (entry.realtime || entry.pendingRealtime) {
+				entry.meetingNotes = void 0;
+				return {
+					ok: true,
+					message: `Stopped meeting notes for ${formatMention({ channelId: entry.channelId })}.`,
+					guildId,
+					channelId: entry.channelId
+				};
+			}
+		}
 		entry.stop();
 		this.sessions.delete(guildId);
 		if (!options?.preserveFollowState) {
@@ -2595,6 +2986,7 @@ var DiscordVoiceManager$1 = class {
 			ownerAllowFrom: this.ownerAllowFrom,
 			runtime: this.params.runtime,
 			speakerContext: this.speakerContext,
+			meetingNotes: params.entry.meetingNotes,
 			fetchGuildName: async (guildId) => {
 				const guild = await this.params.client.fetchGuild(guildId).catch(() => null);
 				return guild && typeof guild.name === "string" && guild.name.trim() ? guild.name : void 0;