@openclaw/voice-call 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{realtime-handler-Do7Sz7Gh.mjs → realtime-handler-BdAuKAC2.mjs}

@@ -1,9 +1,9 @@
-import { d as REALTIME_VOICE_END_CALL_TOOL_NAME, s as resolveVoiceCallPublicPathPrefix } from "./config-CX9J-053.mjs";
-import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-CbSKxSKk.mjs";
+import { d as REALTIME_VOICE_END_CALL_TOOL_NAME, g as CallBriefSchema, s as resolveVoiceCallPublicPathPrefix } from "./config-CsrGuamE.mjs";
+import { n as appendRecentTalkEventMetadata, s as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-STjFmi_B.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { asNullableRecord, asOptionalObjectRecord, asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
-import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ, buildRealtimeVoiceAgentConsultWorkingResponse, buildRealtimeVoiceAgentErrorProviderResult, calculateMulawRms, createRealtimeVoiceSessionHarness, createSpeechThresholdGate, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
+import { createSubsystemLogger, sleep } from "openclaw/plugin-sdk/runtime-env";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ, buildRealtimeVoiceAgentConsultWorkingResponse, buildRealtimeVoiceAgentErrorProviderResult, buildRealtimeVoiceSpeakExactMessage, calculateMulawRms, createRealtimeVoiceSessionHarness, createSpeechThresholdGate, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
 import { normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { randomUUID } from "node:crypto";
@@ -114,8 +114,6 @@ var RealtimeAudioPacer = class {
 	clearAudio() {
 		if (this.closed) return 0;
 		const clearedAudioBytes = this.queuedAudioBytes;
-		this.clearTimer();
-		this.resetQueue();
 		this.resetPlaybackState();
 		this.params.send(this.params.serializer.serializeClear());
 		return clearedAudioBytes;
@@ -126,8 +124,6 @@ var RealtimeAudioPacer = class {
 	}
 	close() {
 		this.closed = true;
-		this.clearTimer();
-		this.resetQueue();
 		this.resetPlaybackState();
 	}
 	extendPlaybackSegment(itemId, durationMs) {
@@ -145,6 +141,8 @@ var RealtimeAudioPacer = class {
 		return segment;
 	}
 	resetPlaybackState() {
+		this.clearTimer();
+		this.resetQueue();
 		this.playbackSegments = [];
 		this.queuedAudioBytes = 0;
 		this.sentAudioMs = 0;
@@ -168,15 +166,8 @@ var RealtimeAudioPacer = class {
 		this.close();
 		this.params.onBackpressure?.();
 	}
-	get pendingQueueSize() {
-		return Math.max(0, this.queue.length - this.queueHead);
-	}
 	/** Take one queued item without shifting the remaining paced-audio backlog. */
 	takeNextItem() {
-		if (this.queueHead >= this.queue.length) {
-			this.resetQueue();
-			return;
-		}
 		const item = this.queue[this.queueHead];
 		this.queueHead += 1;
 		if (this.queueHead >= this.queue.length) this.resetQueue();
@@ -196,17 +187,17 @@ var RealtimeAudioPacer = class {
 		if (this.closed) return;
 		const now = performance.now();
 		this.streamClockMs ??= now;
-		while (this.pendingQueueSize > 0 && this.streamClockMs < now + LEAD_MS) {
+		while (this.queueHead < this.queue.length && this.streamClockMs < now + LEAD_MS) {
 			const item = this.takeNextItem();
 			if (!item) break;
-			if (!(item.type === "audio" ? this.sendAudioItem(item) : this.sendMarkItem(item))) {
+			if (!(item.type === "audio" ? this.sendAudioItem(item) : this.sendMarkItem(item.name))) {
 				this.resetQueue();
 				this.queuedAudioBytes = 0;
 				this.streamClockMs = null;
 				return;
 			}
 		}
-		if (this.pendingQueueSize === 0) {
+		if (this.queueHead === this.queue.length) {
 			this.streamClockMs = null;
 			return;
 		}
@@ -217,6 +208,7 @@ var RealtimeAudioPacer = class {
 		this.queuedAudioBytes = Math.max(0, this.queuedAudioBytes - item.chunk.length);
 		const sent = this.params.send(this.params.serializer.serializeMedia(item.chunk.toString("base64")));
 		if (sent) {
+			this.params.onAudioSent?.(item.chunk);
 			item.segment.sentMs += item.durationMs;
 			this.sentAudioMs += item.durationMs;
 			item.segment.lastSentEndMs = this.sentAudioMs;
@@ -225,17 +217,14 @@ var RealtimeAudioPacer = class {
 		if (!sent || item.segment.itemId === void 0 || this.sentAudioMs - this.lastPlaybackMarkMs < LEAD_MS) return sent;
 		this.lastPlaybackMarkMs = this.sentAudioMs;
 		this.playbackMarkSequence += 1;
-		return this.sendMarkItem({
-			type: "mark",
-			name: `${this.playbackMarkPrefix}-${this.playbackMarkSequence}`
-		});
+		return this.sendMarkItem(`${this.playbackMarkPrefix}-${this.playbackMarkSequence}`);
 	}
 	/** Send a queued mark frame and bind it to the playback prefix before it. */
-	sendMarkItem(item) {
-		const sent = this.params.send(this.params.serializer.serializeMark(item.name));
+	sendMarkItem(name) {
+		const sent = this.params.send(this.params.serializer.serializeMark(name));
 		if (sent) {
 			this.markBoundaries.push({
-				name: item.name,
+				name,
 				sentMs: this.sentAudioMs
 			});
 			if (this.markBoundaries.length > MAX_PENDING_MARK_BOUNDARIES) this.markBoundaries.shift();
@@ -244,6 +233,442 @@ var RealtimeAudioPacer = class {
 	}
 };
 //#endregion
+//#region extensions/voice-call/src/webhook/realtime-call-session-control.ts
+const OUTBOUND_GREETING_FALLBACK_MS = 3e3;
+const REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS = 3e4;
+const REALTIME_DISCONNECT_HANGUP_GRACE_MS = 2e3;
+const ASSISTANT_SPEECH_RMS_THRESHOLD = .035;
+function speakOnRealtimeBridge(bridges, callId, instructions) {
+	const bridge = bridges.get(callId);
+	if (!bridge) return {
+		success: false,
+		error: "No active realtime bridge for call"
+	};
+	try {
+		bridge.triggerGreeting(instructions);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: formatErrorMessage(error)
+		};
+	}
+}
+function buildForcedConsultSpeechPrompt(result) {
+	return [
+		"Internal OpenClaw consult result is ready.",
+		"Do not call tools for this internal result.",
+		"Speak the following answer to the caller now, briefly and naturally:",
+		result
+	].join("\n");
+}
+function buildGreetingInstructions(baseInstructions, greeting) {
+	const trimmedGreeting = greeting?.trim();
+	if (!trimmedGreeting) return;
+	const intro = "Start the call by greeting the caller naturally. Include this greeting in your first spoken reply:";
+	return baseInstructions ? `${baseInstructions}\n\n${intro} "${trimmedGreeting}"` : `${intro} "${trimmedGreeting}"`;
+}
+function buildVerbatimGreetingInstructions(baseInstructions, greeting) {
+	const trimmedGreeting = greeting?.trim();
+	if (!trimmedGreeting) return;
+	const exactGreeting = [
+		"For your first spoken reply, the first words must be the exact Answer below, verbatim and in its original language, with nothing before or after it.",
+		"Then stop and listen.",
+		buildRealtimeVoiceSpeakExactMessage({
+			text: trimmedGreeting,
+			surfaceLabel: "the callee"
+		})
+	].join("\n");
+	return baseInstructions ? `${baseInstructions}\n\n${exactGreeting}` : exactGreeting;
+}
+function createOutboundGreetingController(params) {
+	const waitForAnsweringMachine = params.call?.direction === "outbound" && params.call.metadata?.voicemailManagedByHost && params.call.metadata?.mode !== "notify" ? () => params.call?.metadata?.answeredBy : void 0;
+	let speechMs = 0;
+	let silenceMs = 0;
+	let acknowledged = false;
+	let claimed = !params.enabled;
+	let closed = false;
+	let waitingForAmd = Boolean(waitForAnsweringMachine);
+	let machineDetected = false;
+	let readySession;
+	let timer;
+	const clearTimer = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	};
+	const triggerOpening = () => {
+		if (!closed && readySession && params.instructions && claim()) readySession.triggerGreeting(params.instructions);
+	};
+	const isBlocked = () => {
+		const answeredBy = waitForAnsweringMachine?.();
+		if (typeof answeredBy === "string" && (answeredBy.startsWith("machine_") || answeredBy === "fax")) {
+			machineDetected = true;
+			clearTimer();
+		}
+		if (machineDetected) return true;
+		if (waitingForAmd && (answeredBy === "human" || answeredBy === "unknown")) {
+			waitingForAmd = false;
+			clearTimer();
+			triggerOpening();
+		}
+		return waitingForAmd;
+	};
+	const claim = () => {
+		if (closed || isBlocked() || claimed) return false;
+		claimed = true;
+		clearTimer();
+		return true;
+	};
+	return {
+		claim,
+		isBlocked,
+		noteInputAudio(audio) {
+			if (closed || !readySession || !isBlocked() || machineDetected || acknowledged) return;
+			if (calculateMulawRms(audio) >= ASSISTANT_SPEECH_RMS_THRESHOLD) {
+				speechMs += audio.length / 8;
+				silenceMs = 0;
+			} else {
+				silenceMs += audio.length / 8;
+				if (silenceMs >= 240) speechMs = 0;
+			}
+			if (speechMs <= 3e3) return;
+			acknowledged = true;
+			const brief = CallBriefSchema.safeParse(params.call?.metadata?.brief);
+			const language = brief.success ? brief.data.language : void 0;
+			params.acknowledge?.([`Say only a short acknowledgement${language ? ` in ${JSON.stringify(language)}` : ""}, then stop and wait. Do not call tools.`, /^(es(?:[-_]|$)|spanish|español)/i.test(language ?? "") ? "Sí, un momento" : "Yes, one moment."].join("\n"));
+		},
+		close() {
+			closed = true;
+			clearTimer();
+		},
+		onReady(session) {
+			readySession = session;
+			if (closed || machineDetected) return;
+			if (isBlocked()) {
+				if (!timer && !machineDetected) {
+					timer = setTimeout(() => {
+						if (isBlocked() && !machineDetected && !closed) {
+							waitingForAmd = false;
+							triggerOpening();
+						}
+					}, params.holdOpeningMaxMs ?? 3e4);
+					timer.unref?.();
+				}
+				return;
+			}
+			if (!params.enabled || !params.instructions || claimed) return;
+			clearTimer();
+			timer = setTimeout(() => {
+				if (claim()) session.triggerGreeting(params.instructions);
+			}, params.fallbackMs ?? OUTBOUND_GREETING_FALLBACK_MS);
+			timer.unref?.();
+		}
+	};
+}
+function createRealtimeCallActivityController(params) {
+	let closed = false;
+	let started = false;
+	let consultsInFlight = 0;
+	let idleTimer;
+	let mediaTimer;
+	const clearIdle = () => {
+		if (idleTimer) {
+			clearTimeout(idleTimer);
+			idleTimer = void 0;
+		}
+	};
+	const clearMedia = () => {
+		if (mediaTimer) {
+			clearTimeout(mediaTimer);
+			mediaTimer = void 0;
+		}
+	};
+	const resetIdle = () => {
+		clearIdle();
+		if (closed || !started || !params.idleHangupMs || consultsInFlight > 0 || params.isPaused?.() === true) return;
+		idleTimer = setTimeout(params.onIdle, params.idleHangupMs);
+		idleTimer.unref?.();
+	};
+	return {
+		beginConsult() {
+			consultsInFlight += 1;
+			clearIdle();
+		},
+		close() {
+			closed = true;
+			clearIdle();
+			clearMedia();
+		},
+		endConsult() {
+			consultsInFlight = Math.max(0, consultsInFlight - 1);
+			if (consultsInFlight === 0) resetIdle();
+		},
+		isPaused: () => consultsInFlight > 0,
+		noteMedia() {
+			if (closed) return;
+			clearMedia();
+			mediaTimer = setTimeout(() => {
+				params.onMediaWarning();
+				mediaTimer = setTimeout(params.onMediaTimeout, params.mediaGraceMs ?? 2e3);
+				mediaTimer.unref?.();
+			}, params.mediaInactivityMs ?? 3e4);
+			mediaTimer.unref?.();
+		},
+		noteSpeech: resetIdle,
+		start() {
+			started = true;
+			resetIdle();
+		}
+	};
+}
+function createRealtimeCallAudioController(params) {
+	const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
+		const outputAudioActive = params.harness.talk.outputAudioActive;
+		const pendingTelephonyAudio = params.audioPacer.hasPendingAudio();
+		if (source === "provider" && !outputAudioActive && !pendingTelephonyAudio && clearedAudioBytes === 0) return;
+		const interruptedTurnId = params.harness.talk.activeTurnId;
+		if (outputAudioActive || pendingTelephonyAudio) interruptProvider?.(true);
+		const clearedBytes = clearedAudioBytes + (source === "local" || pendingTelephonyAudio ? params.audioPacer.clearAudio() : 0);
+		console.log(`[voice-call] realtime outbound audio cleared by ${source} barge-in callId=${params.callId} providerCallId=${params.providerCallId} queuedBytes=${clearedBytes}`);
+		if (!outputAudioActive || !interruptedTurnId) return;
+		const reason = `${source}-barge-in`;
+		params.harness.finishOutputAudio(reason);
+		params.harness.talk.cancelTurn({
+			turnId: interruptedTurnId,
+			payload: {
+				callId: params.callId,
+				providerCallId: params.providerCallId,
+				reason
+			}
+		});
+	};
+	return {
+		audioSink: {
+			isOpen: params.isOpen,
+			sendAudio: (muLaw, metadata) => {
+				if (params.isBlocked?.()) return;
+				if (muLaw.length > 0 && calculateMulawRms(muLaw) >= ASSISTANT_SPEECH_RMS_THRESHOLD) params.onAudibleOutput?.();
+				params.harness.recordOutputAudio(muLaw);
+				params.audioPacer.sendAudio(muLaw, metadata);
+			},
+			getPlaybackState: () => params.audioPacer.getPlaybackState(),
+			clearAudio: (reason) => {
+				params.harness.flushOutput(() => {
+					const clearedBytes = params.audioPacer.clearAudio();
+					if (reason === "barge-in") {
+						cancelOutputAudioForBargeIn("provider", void 0, clearedBytes);
+						return;
+					}
+					console.log(`[voice-call] realtime outbound audio clear requested callId=${params.callId} providerCallId=${params.providerCallId} queuedBytes=${clearedBytes}`);
+					params.harness.finishOutputAudio(reason ?? "clear");
+				});
+			},
+			sendMark: (markName, acknowledge) => {
+				params.audioPacer.sendMark(markName);
+				if (markName && acknowledge) params.pendingMarkAcks.set(markName, acknowledge);
+			}
+		},
+		cancelOutputAudioForBargeIn
+	};
+}
+//#endregion
+//#region extensions/voice-call/src/webhook/realtime-host-speech.ts
+/** One host-requested utterance, completed by audible output rather than model receipts. */
+function createRealtimeHostSpeechController(params) {
+	let closed = false;
+	let pending;
+	let quietTimer;
+	let deadline;
+	const finish = (error) => {
+		const current = pending;
+		pending = void 0;
+		clearTimeout(quietTimer);
+		clearTimeout(deadline);
+		if (error) current?.reject(error);
+		else current?.resolve();
+	};
+	return {
+		isActive: () => Boolean(pending),
+		speak(instructions) {
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("Realtime bridge is closed"));
+			finish(/* @__PURE__ */ new Error("Host speech replaced"));
+			return new Promise((resolve, reject) => {
+				try {
+					params.interrupt();
+					if (closed) throw new Error("Realtime bridge is closed");
+					pending = {
+						resolve,
+						reject
+					};
+					deadline = setTimeout(() => finish(/* @__PURE__ */ new Error("Realtime speech did not finish within 45 seconds")), 45e3);
+					deadline.unref?.();
+					params.trigger(instructions);
+				} catch (error) {
+					const rejection = error instanceof Error ? error : new Error(String(error));
+					finish(rejection);
+					reject(rejection);
+				}
+			});
+		},
+		noteAudibleOutput() {
+			if (!pending) return;
+			clearTimeout(quietTimer);
+			quietTimer = setTimeout(() => finish(), 1500);
+			quietTimer.unref?.();
+		},
+		close() {
+			closed = true;
+			finish(/* @__PURE__ */ new Error("Realtime bridge closed during host speech"));
+		}
+	};
+}
+//#endregion
+//#region extensions/voice-call/src/webhook/realtime-call-playback.ts
+const MAX_REALTIME_WS_BUFFERED_BYTES$1 = 1048576;
+function createRealtimeCallPlayback(params) {
+	const { ws, callRecord, callSid, adapter, harness, initialGreetingInstructions } = params;
+	const callId = callRecord.callId;
+	const checkBackpressure = (phase) => {
+		if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES$1) {
+			console.warn(`[voice-call] realtime outbound websocket backpressure ${phase} send callId=${callId} providerCallId=${callSid} bufferedBytes=${ws.bufferedAmount}`);
+			ws.close(1013, "Backpressure: send buffer exceeded");
+			return false;
+		}
+		return true;
+	};
+	const sendString = (message) => {
+		if (ws.readyState !== WebSocket.OPEN || !checkBackpressure("before")) return false;
+		ws.send(message);
+		return checkBackpressure("after");
+	};
+	const pendingMarkAcks = /* @__PURE__ */ new Map();
+	const audioPacer = new RealtimeAudioPacer({
+		onPlaybackReset: () => pendingMarkAcks.clear(),
+		onAudioSent: (audio) => {
+			if (calculateMulawRms(audio) >= .035) {
+				hostSpeech.noteAudibleOutput();
+				activity.noteSpeech();
+			}
+		},
+		send: sendString,
+		serializer: adapter,
+		onBackpressure: () => {
+			console.warn(`[voice-call] realtime paced audio backpressure callId=${callId} providerCallId=${callSid}`);
+			if (ws.readyState === WebSocket.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
+		}
+	});
+	const outboundGreeting = createOutboundGreetingController({
+		enabled: params.hostOwnsOpening,
+		instructions: initialGreetingInstructions,
+		call: callRecord,
+		holdOpeningMaxMs: params.holdOpeningMaxMs,
+		acknowledge: (instructions) => {
+			hostSpeech.speak(instructions).catch((error) => {
+				console.warn("[voice-call] AMD acknowledgement failed:", formatErrorMessage(error));
+			});
+		}
+	});
+	const interruptModelOutput = () => {
+		params.getSession()?.handleBargeIn({
+			audioPlaybackActive: true,
+			force: true
+		});
+		audioController.cancelOutputAudioForBargeIn("local");
+	};
+	const hostSpeech = createRealtimeHostSpeechController({
+		interrupt: () => {
+			interruptModelOutput();
+		},
+		trigger: (instructions) => {
+			const session = params.getSession();
+			if (!session) throw new Error("No active realtime bridge for call");
+			session.triggerGreeting(instructions);
+		}
+	});
+	const audioController = createRealtimeCallAudioController({
+		audioPacer,
+		callId,
+		harness,
+		isOpen: () => !params.isClosed() && ws.readyState === WebSocket.OPEN,
+		isBlocked: () => outboundGreeting.isBlocked() && !hostSpeech.isActive(),
+		onAudibleOutput: () => {
+			outboundGreeting.claim();
+		},
+		pendingMarkAcks,
+		providerCallId: callSid
+	});
+	const activity = createRealtimeCallActivityController({
+		idleHangupMs: params.idleHangupMs,
+		isPaused: () => outboundGreeting.isBlocked() || hostSpeech.isActive(),
+		onIdle: () => {
+			console.warn(`[voice-call] Realtime speech idle timeout callId=${callId} providerCallId=${callSid} timeoutMs=${params.idleHangupMs}`);
+			params.closeForInactivity();
+			if (ws.readyState === WebSocket.OPEN) ws.close(1e3, "Speech inactivity");
+		},
+		onMediaWarning: () => {
+			console.warn(`[voice-call] Realtime media inactive callId=${callId} providerCallId=${callSid} timeoutMs=${REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS} graceMs=${REALTIME_DISCONNECT_HANGUP_GRACE_MS}`);
+		},
+		onMediaTimeout: () => {
+			params.closeForInactivity();
+			if (ws.readyState === WebSocket.OPEN) ws.close(1e3, "Media inactivity");
+		}
+	});
+	return {
+		audioPacer,
+		pendingMarkAcks,
+		outboundGreeting,
+		audioController,
+		activity,
+		hostSpeech
+	};
+}
+//#endregion
+//#region extensions/voice-call/src/webhook/realtime-transcript-text.ts
+const MAX_PARTIAL_USER_TRANSCRIPT_CHARS = 1200;
+function limitPartialUserTranscript(text) {
+	if (text.length <= MAX_PARTIAL_USER_TRANSCRIPT_CHARS) return text;
+	const tail = sliceUtf16Safe(text, -1200);
+	return tail.replace(/^\S+\s+/, "").trimStart() || tail.trimStart();
+}
+function normalizeTranscriptText(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+function findTextOverlap(base, next) {
+	const max = Math.min(base.length, next.length);
+	for (let size = max; size > 0; size -= 1) if (base.slice(-size) === next.slice(0, size)) return size;
+	return 0;
+}
+function appendTranscriptText(base, fragment) {
+	const next = normalizeTranscriptText(fragment);
+	if (!next) return base ?? "";
+	const current = normalizeTranscriptText(base ?? "");
+	if (!current) return next;
+	const currentLower = current.toLowerCase();
+	const nextLower = next.toLowerCase();
+	if (currentLower === nextLower || currentLower.endsWith(nextLower)) return current;
+	if (nextLower.startsWith(currentLower)) return next;
+	const overlap = findTextOverlap(currentLower, nextLower);
+	if (overlap >= 6 || overlap >= 3 && next.length <= 12) return `${current}${next.slice(overlap)}`.trim();
+	return `${current}${/[([{"']$/.test(current) || /^[,.;:!?)]/.test(next) ? "" : " "}${next}`.trim();
+}
+function resolveFinalTranscriptText(params) {
+	const final = normalizeTranscriptText(params.final);
+	const rawPartial = params.rawPartial ?? "";
+	const partial = normalizeTranscriptText(params.partial ?? rawPartial);
+	if (!partial) return final;
+	if (!final) return partial;
+	const compact = (value) => value.toLowerCase().replaceAll(/\s/g, "");
+	const compactFinal = compact(final);
+	const compactRaw = compact(rawPartial);
+	const compactPartial = compact(partial);
+	if (compactFinal.startsWith(compactPartial) || compactFinal.endsWith(compactPartial)) return final;
+	if (compactPartial.endsWith(compactFinal)) return partial;
+	if (compactRaw !== compactPartial) return appendTranscriptText(partial, params.final);
+	return normalizeTranscriptText(`${rawPartial}${params.final}`);
+}
+//#endregion
 //#region extensions/voice-call/src/webhook/stream-frame-adapter.ts
 /** Parse numeric timestamps sent as numbers or integer strings. */
 function parseTimestampMs(value) {
@@ -332,65 +757,16 @@ const STREAM_TOKEN_TTL_MS = 3e4;
 const DEFAULT_HOST = "localhost:8443";
 const MAX_REALTIME_MESSAGE_BYTES = 262144;
 const MAX_REALTIME_WS_BUFFERED_BYTES = 1048576;
-const REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS = 3e4;
-const REALTIME_DISCONNECT_HANGUP_GRACE_MS = 2e3;
 const FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
 const FORCED_CONSULT_NATIVE_DEDUPE_MS = 2e3;
 const FORCED_CONSULT_RESULT_MAX_CHARS = 1800;
 const FORCED_CONSULT_REASON = "provider_final_transcript_without_openclaw_agent_consult";
 const CONSULT_TRANSCRIPT_SETTLE_MS = 350;
 const CONSULT_TRANSCRIPT_SETTLE_MAX_MS = 1e3;
-const MAX_PARTIAL_USER_TRANSCRIPT_CHARS = 1200;
 const RECENT_FINAL_USER_TRANSCRIPT_TTL_MS = 2e3;
 const BARGE_IN_REQUIRED_LOUD_CHUNKS = 2;
+const CALLER_SPEECH_RMS_THRESHOLD = .035;
 const logger = createSubsystemLogger("voice-call/realtime");
-function buildGreetingInstructions(baseInstructions, greeting) {
-	const trimmedGreeting = greeting?.trim();
-	if (!trimmedGreeting) return;
-	const intro = "Start the call by greeting the caller naturally. Include this greeting in your first spoken reply:";
-	return baseInstructions ? `${baseInstructions}\n\n${intro} "${trimmedGreeting}"` : `${intro} "${trimmedGreeting}"`;
-}
-function normalizeTranscriptText(text) {
-	return text.replace(/\s+/g, " ").trim();
-}
-function findTextOverlap(base, next) {
-	const max = Math.min(base.length, next.length);
-	for (let size = max; size > 0; size -= 1) if (base.slice(-size) === next.slice(0, size)) return size;
-	return 0;
-}
-function appendTranscriptText(base, fragment) {
-	const next = normalizeTranscriptText(fragment);
-	if (!next) return base ?? "";
-	const current = normalizeTranscriptText(base ?? "");
-	if (!current) return next;
-	const currentLower = current.toLowerCase();
-	const nextLower = next.toLowerCase();
-	if (currentLower === nextLower || currentLower.endsWith(nextLower)) return current;
-	if (nextLower.startsWith(currentLower)) return next;
-	const overlap = findTextOverlap(currentLower, nextLower);
-	if (overlap >= 6 || overlap >= 3 && next.length <= 12) return `${current}${next.slice(overlap)}`.trim();
-	return `${current}${/[([{"']$/.test(current) || /^[,.;:!?)]/.test(next) ? "" : " "}${next}`.trim();
-}
-function resolveFinalTranscriptText(params) {
-	const final = normalizeTranscriptText(params.final);
-	const rawPartial = params.rawPartial ?? "";
-	const partial = normalizeTranscriptText(params.partial ?? rawPartial);
-	if (!partial) return final;
-	if (!final) return partial;
-	const compact = (value) => value.toLowerCase().replaceAll(/\s/g, "");
-	const compactFinal = compact(final);
-	const compactRaw = compact(rawPartial);
-	const compactPartial = compact(partial);
-	if (compactFinal.startsWith(compactPartial) || compactFinal.endsWith(compactPartial)) return final;
-	if (compactPartial.endsWith(compactFinal)) return partial;
-	if (compactRaw !== compactPartial) return appendTranscriptText(partial, params.final);
-	return normalizeTranscriptText(`${rawPartial}${params.final}`);
-}
-function limitPartialUserTranscript(text) {
-	if (text.length <= MAX_PARTIAL_USER_TRANSCRIPT_CHARS) return text;
-	const tail = sliceUtf16Safe(text, -1200);
-	return tail.replace(/^\S+\s+/, "").trimStart() || tail.trimStart();
-}
 function withFallbackConsultQuestion(args, fallback) {
 	const providerQuestion = readRealtimeVoiceConsultQuestion(args);
 	const question = fallback?.trim();
@@ -413,13 +789,47 @@ function withFallbackConsultQuestion(args, fallback) {
 		question
 	};
 }
-function buildForcedConsultSpeechPrompt(result) {
-	return [
-		"Internal OpenClaw consult result is ready.",
-		"Do not call tools for this internal result.",
-		"Speak the following answer to the caller now, briefly and naturally:",
-		result
-	].join("\n");
+function captureNativeConsultTranscript(state, invocationId) {
+	const previous = state.nativeConsultInvocation;
+	if (invocationId.trim() && previous?.id === invocationId) return previous.read;
+	previous?.freeze();
+	const read = () => {
+		const buffer = state.partial ?? state.recentFinal;
+		return {
+			buffer,
+			text: buffer?.text
+		};
+	};
+	const initial = read();
+	let frozen;
+	const invocation = {
+		id: invocationId,
+		read: () => frozen ?? read(),
+		freeze: () => {
+			frozen = initial.buffer?.final ? {
+				buffer: initial.buffer,
+				text: initial.buffer.text
+			} : initial;
+		}
+	};
+	state.nativeConsultInvocation = invocation;
+	return invocation.read;
+}
+function clearRecentFinalUserTranscript(state) {
+	clearTimeout(state.recentFinalTimer);
+	state.recentFinalTimer = void 0;
+	state.recentFinal = void 0;
+}
+function consumeUserTranscript(state, consumed) {
+	const buffer = consumed?.buffer;
+	const text = consumed?.text?.trim();
+	if (!state || !buffer || !text || buffer !== state.partial && buffer !== state.recentFinal || !buffer.text.toLowerCase().startsWith(text.toLowerCase())) return;
+	const remaining = buffer.text.slice(text.length).trimStart();
+	if (remaining) {
+		buffer.text = remaining;
+		buffer.raw = remaining;
+	} else if (buffer === state.partial) state.partial = void 0;
+	else clearRecentFinalUserTranscript(state);
 }
 async function waitForNativeConsult(state) {
 	return await Promise.race([state.promise.then((result) => ({
@@ -427,36 +837,15 @@ async function waitForNativeConsult(state) {
 		result
 	})), state.cancellation.then(() => ({ kind: "cancelled" }))]);
 }
-function appendRecentTalkEventMetadata(metadata, event) {
-	const previous = metadata ?? {};
-	const recent = Array.isArray(previous.recentTalkEvents) ? previous.recentTalkEvents : [];
-	return {
-		...previous,
-		lastTalkEventAt: event.timestamp,
-		lastTalkEventType: event.type,
-		recentTalkEvents: [...recent, {
-			id: event.id,
-			brain: event.brain,
-			mode: event.mode,
-			provider: event.provider,
-			seq: event.seq,
-			sessionId: event.sessionId,
-			timestamp: event.timestamp,
-			transport: event.transport,
-			type: event.type,
-			...event.turnId ? { turnId: event.turnId } : {},
-			...event.final !== void 0 ? { final: event.final } : {}
-		}].slice(-12)
-	};
-}
 var RealtimeCallHandler = class {
-	constructor(config, manager, resolveCallRegistration, servePath, streamDisconnectLifecycle, coreConfig) {
+	constructor(config, manager, resolveCallRegistration, servePath, streamDisconnectLifecycle, coreConfig, holdOpeningMaxMs) {
 		this.config = config;
 		this.manager = manager;
 		this.resolveCallRegistration = resolveCallRegistration;
 		this.servePath = servePath;
 		this.streamDisconnectLifecycle = streamDisconnectLifecycle;
 		this.coreConfig = coreConfig;
+		this.holdOpeningMaxMs = holdOpeningMaxMs;
 		this.toolHandlers = /* @__PURE__ */ new Map();
 		this.pendingStreamTokens = /* @__PURE__ */ new Map();
 		this.activeSockets = /* @__PURE__ */ new Set();
@@ -669,20 +1058,16 @@ var RealtimeCallHandler = class {
 		this.toolHandlers.set(name, fn);
 	}
 	speak(callId, instructions) {
-		const bridge = this.activeBridgesByCallId.get(callId);
-		if (!bridge) return {
-			success: false,
-			error: "No active realtime bridge for call"
-		};
-		try {
-			bridge.triggerGreeting(instructions);
-			return { success: true };
-		} catch (error) {
-			return {
-				success: false,
-				error: formatErrorMessage(error)
-			};
-		}
+		return speakOnRealtimeBridge(this.activeBridgesByCallId, callId, instructions);
+	}
+	playVoicemail(callId, instructions) {
+		return this.activeTelephonyBindingsByCallId.get(callId)?.playVoicemail(instructions);
+	}
+	async drainCall(callId) {
+		await this.activeBridgesByCallId.get(callId)?.close();
+	}
+	async prepareCarrierPlayback(callId) {
+		await this.activeTelephonyBindingsByCallId.get(callId)?.close();
 	}
 	issueStreamSession(request = {}) {
 		const meta = {
@@ -747,8 +1132,14 @@ var RealtimeCallHandler = class {
 			this.trackShutdownWork(attempt, this.terminationAttempts);
 			return attempt;
 		};
-		const admissionAbandoned = () => this.closing || ws.readyState !== WebSocket.OPEN;
+		const carrierOwnsPlayback = () => Boolean(callRecord.metadata?.voicemailStatus || callRecord.metadata?.notifyStatus);
+		const admissionAbandoned = () => this.closing || ws.readyState !== WebSocket.OPEN || carrierOwnsPlayback();
 		const abandonAdmission = async () => {
+			if (carrierOwnsPlayback()) {
+				this.streamDisconnectLifecycle.retire(callSid, streamSid);
+				ws.close(1e3, "Carrier playback owns the call");
+				return;
+			}
 			if (!this.activeBridgesByCallId.has(callId)) {
 				if (this.closing || this.serverClosingSockets.has(ws)) await emitCallEnd("shutdown");
 				else {
@@ -807,9 +1198,13 @@ var RealtimeCallHandler = class {
 		const previousTelephonyBinding = this.activeTelephonyBindingsByCallId.get(callId);
 		const { agentId, instructions, provider: realtimeProvider, providerConfig, capabilities } = registration;
 		const { handlesAgentConsult, toolPolicy } = sessionPolicy;
-		if (handlesAgentConsult) console.warn("[voice-call] This realtime model uses native agent delegation; the end-call and custom realtime function tools are unavailable.");
-		const initialGreetingInstructions = buildGreetingInstructions(instructions, initialGreeting);
+		if (handlesAgentConsult) console.warn("[voice-call] This realtime model uses native agent delegation; hang-up is available through the call-scoped OpenClaw agent, while other custom realtime function tools remain unavailable.");
+		const initialGreetingInstructions = handlesAgentConsult ? buildVerbatimGreetingInstructions(instructions, initialGreeting) : buildGreetingInstructions(instructions, initialGreeting);
+		const isDelayedOutboundGreeting = handlesAgentConsult && callRecord.direction === "outbound" && Boolean(initialGreetingInstructions);
+		const hostOwnsOpening = callRecord.direction === "outbound" && Boolean(initialGreetingInstructions) && (handlesAgentConsult || Boolean(callRecord.metadata?.voicemailManagedByHost) && callRecord.metadata?.mode !== "notify");
+		const sessionInstructions = isDelayedOutboundGreeting ? initialGreetingInstructions : instructions;
 		const harness = createRealtimeVoiceSessionHarness({
+			forcedConsults: { questionsMatch: (left, right) => Boolean(left && right && left.trim() === right.trim()) },
 			talk: {
 				sessionId: `voice-call:${callId}:realtime`,
 				mode: "realtime",
@@ -840,32 +1235,12 @@ var RealtimeCallHandler = class {
 				})
 			},
 			onTalkEvent: (event) => {
-				this.manager.updateCallMetadata(callRecord, (metadata) => appendRecentTalkEventMetadata(metadata, event)).catch((error) => {
+				this.manager.updateCallMetadata(callRecord, (metadata) => appendRecentTalkEventMetadata(metadata, event, "realtime")).catch((error) => {
 					console.warn("[voice-call] Failed to update realtime call metadata:", error);
 				});
 			}
 		});
 		const providerHandlesInputAudioBargeIn = (capabilities ?? realtimeProvider.capabilities)?.handlesInputAudioBargeIn === true;
-		const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
-			const outputAudioActive = harness.talk.outputAudioActive;
-			const pendingTelephonyAudio = audioPacer.hasPendingAudio();
-			if (source === "provider" && !outputAudioActive && !pendingTelephonyAudio && clearedAudioBytes === 0) return;
-			const interruptedTurnId = harness.talk.activeTurnId;
-			interruptProvider?.(outputAudioActive || pendingTelephonyAudio);
-			const clearedBytes = clearedAudioBytes + (source === "local" || pendingTelephonyAudio ? audioPacer.clearAudio() : 0);
-			console.log(`[voice-call] realtime outbound audio cleared by ${source} barge-in callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
-			if (!outputAudioActive || !interruptedTurnId) return;
-			const reason = `${source}-barge-in`;
-			harness.finishOutputAudio(reason);
-			harness.talk.cancelTurn({
-				turnId: interruptedTurnId,
-				payload: {
-					callId,
-					providerCallId: callSid,
-					reason
-				}
-			});
-		};
 		harness.emit({
 			type: "session.started",
 			payload: {
@@ -875,42 +1250,34 @@ var RealtimeCallHandler = class {
 			}
 		});
 		console.log(`[voice-call] Realtime bridge starting for call ${callId} (providerCallId=${callSid}, initialGreeting=${initialGreetingInstructions ? "queued" : "absent"})`);
-		const sendString = (message) => {
-			if (ws.readyState !== WebSocket.OPEN) return false;
-			if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES) {
-				console.warn(`[voice-call] realtime outbound websocket backpressure before send callId=${callId} providerCallId=${callSid} bufferedBytes=${ws.bufferedAmount}`);
-				ws.close(1013, "Backpressure: send buffer exceeded");
-				return false;
-			}
-			ws.send(message);
-			if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES) {
-				console.warn(`[voice-call] realtime outbound websocket backpressure after send callId=${callId} providerCallId=${callSid} bufferedBytes=${ws.bufferedAmount}`);
-				ws.close(1013, "Backpressure: send buffer exceeded");
-				return false;
-			}
-			return true;
-		};
-		const pendingMarkAcks = /* @__PURE__ */ new Map();
-		const audioPacer = new RealtimeAudioPacer({
-			onPlaybackReset: () => pendingMarkAcks.clear(),
-			send: sendString,
-			serializer: adapter,
-			onBackpressure: () => {
-				console.warn(`[voice-call] realtime paced audio backpressure callId=${callId} providerCallId=${callSid}`);
-				if (ws.readyState === WebSocket.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
-			}
-		});
 		const speechDetector = createSpeechThresholdGate({
-			rmsThreshold: .035,
+			rmsThreshold: CALLER_SPEECH_RMS_THRESHOLD,
 			speechFrames: BARGE_IN_REQUIRED_LOUD_CHUNKS,
 			silenceFrames: 12
 		});
 		const interruptResponseOnInputAudio = typeof providerConfig.interruptResponseOnInputAudio === "boolean" ? providerConfig.interruptResponseOnInputAudio : void 0;
-		const nativeConsultOwner = {};
+		let nativeConsultOwner = void 0;
+		const { audioPacer, pendingMarkAcks, outboundGreeting, audioController, activity, hostSpeech } = createRealtimeCallPlayback({
+			ws,
+			callRecord,
+			callSid,
+			adapter,
+			harness,
+			initialGreetingInstructions,
+			hostOwnsOpening,
+			holdOpeningMaxMs: this.holdOpeningMaxMs,
+			idleHangupMs: this.config.idleHangupMs,
+			getSession: () => nativeConsultOwner,
+			isClosed: () => sessionClosed,
+			closeForInactivity: () => {
+				telephonyBinding.close("inactivity");
+			}
+		});
 		let provisionalCloseReason;
 		let sessionClosed = false;
-		const userTranscriptAdoption = this.beginUserTranscriptOwnerAdoption(callId);
-		const userTranscriptOwner = userTranscriptAdoption.owner;
+		const previousTranscriptOwner = this.userTranscriptStatesByCallId.get(callId);
+		const userTranscriptOwner = {};
+		this.userTranscriptStatesByCallId.set(callId, userTranscriptOwner);
 		let transcriptPersistence = Promise.resolve();
 		let transcriptFailure;
 		const reportTranscriptFailure = (error) => {
@@ -940,53 +1307,42 @@ var RealtimeCallHandler = class {
 			capabilities,
 			audioFormat: REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ,
 			interruptResponseOnInputAudio,
-			instructions: handlesAgentConsult ? `${instructions}\n\nUse native agent delegation for OpenClaw work. End-call and custom realtime function tools are unavailable in this session; the caller can hang up to end the call.` : instructions,
+			instructions: handlesAgentConsult ? `${sessionInstructions}\n\nUse native agent delegation for OpenClaw work. To end the current call, say out loud that you are hanging up and delegate; the OpenClaw agent acts on the transcript. Other custom realtime function tools are unavailable in this session.` : sessionInstructions,
 			tools: handlesAgentConsult ? [] : this.config.tools,
 			...handlesAgentConsult ? { runAgentConsult: async (request) => {
-				const owner = nativeConsultOwner.current;
+				const owner = nativeConsultOwner;
 				const generation = continuityGeneration;
 				request.signal?.throwIfAborted();
-				await transcriptPersistence;
-				if (!owner || sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, owner)) throw new Error("Realtime call delegation owner is no longer active");
-				if (toolPolicy === "none") throw new Error("Agent consultation is disabled for this call");
-				const result = await this.executeToolCall(owner, callId, randomUUID(), REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, { question: request.prompt }, harness.ensureTurn(), harness, userTranscriptOwner, { signal: request.signal });
-				request.signal?.throwIfAborted();
-				if (sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, owner)) throw new Error("Realtime call delegation owner is no longer active");
-				const text = readSpeakableRealtimeVoiceToolResult(result, {
-					keys: ["text", "output"],
-					maxChars: FORCED_CONSULT_RESULT_MAX_CHARS
-				});
-				if (!text) throw new Error("Agent consultation returned no spoken answer");
-				return { text };
-			} } : {},
-			initialGreetingInstructions,
-			triggerGreetingOnReady: Boolean(initialGreetingInstructions),
-			audioSink: {
-				isOpen: () => !sessionClosed && ws.readyState === WebSocket.OPEN,
-				sendAudio: (muLaw, metadata) => {
-					harness.recordOutputAudio(muLaw);
-					audioPacer.sendAudio(muLaw, metadata);
-				},
-				getPlaybackState: () => audioPacer.getPlaybackState(),
-				clearAudio: (reason) => {
-					harness.flushOutput(() => {
-						const clearedBytes = audioPacer.clearAudio();
-						if (reason === "barge-in") {
-							cancelOutputAudioForBargeIn("provider", void 0, clearedBytes);
-							return;
-						}
-						console.log(`[voice-call] realtime outbound audio clear requested callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
-						harness.finishOutputAudio("clear");
+				const invocationId = randomUUID();
+				const transcript = captureNativeConsultTranscript(userTranscriptOwner, invocationId);
+				activity.beginConsult();
+				try {
+					await transcriptPersistence;
+					if (!owner || sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, owner)) throw new Error("Realtime call delegation owner is no longer active");
+					if (toolPolicy === "none") throw new Error("Agent consultation is disabled for this call");
+					const result = await this.executeToolCall(owner, callId, invocationId, REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, { question: request.prompt }, harness.ensureTurn(), harness, userTranscriptOwner, transcript, { signal: request.signal });
+					request.signal?.throwIfAborted();
+					if (sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, owner)) throw new Error("Realtime call delegation owner is no longer active");
+					const text = readSpeakableRealtimeVoiceToolResult(result, {
+						keys: ["text", "output"],
+						maxChars: FORCED_CONSULT_RESULT_MAX_CHARS
 					});
-				},
-				sendMark: (markName, acknowledge) => {
-					audioPacer.sendMark(markName);
-					if (markName && acknowledge) pendingMarkAcks.set(markName, acknowledge);
+					if (!text) throw new Error("Agent consultation returned no spoken answer");
+					return { text };
+				} finally {
+					activity.endConsult();
 				}
-			},
+			} } : {},
+			initialGreetingInstructions,
+			triggerGreetingOnReady: Boolean(initialGreetingInstructions) && !hostOwnsOpening,
+			audioSink: audioController.audioSink,
 			onTranscript: (role, text, isFinal) => {
-				const owner = nativeConsultOwner.current;
-				if (provisionalCloseReason || sessionClosed && !isFinal || !this.getUserTranscriptState(callId, userTranscriptOwner) || owner && !this.isActiveBridgeOwner(callId, owner)) return;
+				const owner = nativeConsultOwner;
+				if (provisionalCloseReason || outboundGreeting.isBlocked() || sessionClosed && !isFinal || !this.getUserTranscriptState(callId, userTranscriptOwner) || owner && !this.isActiveBridgeOwner(callId, owner)) return;
+				if (text.trim()) {
+					outboundGreeting.claim();
+					activity.noteSpeech();
+				}
 				const turnId = harness.ensureTurn();
 				const eventType = role === "assistant" ? isFinal ? "output.text.done" : "output.text.delta" : isFinal ? "transcript.done" : "transcript.delta";
 				const payload = role === "assistant" ? { text } : {
@@ -1010,87 +1366,116 @@ var RealtimeCallHandler = class {
 				});
 				if (!isFinal) {
 					if (role === "user" && text.trim()) {
-						const transcript = this.recordPartialUserTranscript(callId, userTranscriptOwner, text);
-						if (!transcript) return;
-						console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=false chars=${text.trim().length} aggregateChars=${transcript.length}`);
+						const state = this.getUserTranscriptState(callId, userTranscriptOwner);
+						if (!state) return;
+						const partial = state.partial ??= { text: "" };
+						partial.text = limitPartialUserTranscript(appendTranscriptText(partial.text, text));
+						partial.raw = limitPartialUserTranscript(`${partial.raw ?? ""}${text}`);
+						partial.updatedAt = Date.now();
+						console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=false chars=${text.trim().length} aggregateChars=${partial.text.length}`);
 					}
 					return;
 				}
+				let transcript = text;
+				let consultTranscript;
 				if (role === "user") {
 					const state = this.getUserTranscriptState(callId, userTranscriptOwner);
 					if (!state) return;
-					const transcript = resolveFinalTranscriptText({
-						partial: state.partial,
-						rawPartial: state.rawPartial,
+					transcript = resolveFinalTranscriptText({
+						partial: state.partial?.text,
+						rawPartial: state.partial?.raw,
 						final: text
 					});
-					this.clearPartialUserTranscript(callId, userTranscriptOwner);
-					this.setRecentFinalUserTranscript(callId, userTranscriptOwner, transcript);
-					console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=true chars=${text.trim().length} aggregateChars=${transcript.length}`);
-					const event = {
-						id: `realtime-speech-${callSid}-${randomUUID()}`,
-						type: "call.speech",
-						callId,
-						providerCallId: callSid,
-						timestamp: Date.now(),
-						transcript,
-						isFinal: true
+					const buffer = state.partial ?? { text: transcript };
+					buffer.text = transcript;
+					buffer.final = true;
+					state.partial = void 0;
+					clearRecentFinalUserTranscript(state);
+					state.recentFinal = buffer;
+					consultTranscript = {
+						buffer,
+						text: transcript
 					};
-					const generation = continuityGeneration;
-					transcriptPersistence = this.manager.processEvent(event).then(() => {
-						if (handlesAgentConsult || sessionClosed || generation !== continuityGeneration || !this.getUserTranscriptState(callId, userTranscriptOwner) || !this.isActiveBridgeOwner(callId, session)) return;
-						this.scheduleForcedAgentConsult({
-							harness,
-							session,
-							callId,
-							callSid,
-							transcript,
-							userTranscriptOwner,
-							clearAudio: () => {
-								const clearedBytes = audioPacer.clearAudio();
-								console.log(`[voice-call] realtime forced consult cleared outbound audio callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
-							}
-						});
-					});
-					transcriptPersistence.catch(reportTranscriptFailure);
-					return;
+					const timer = setTimeout(() => {
+						if (!this.getUserTranscriptState(callId, state) || state.recentFinalTimer !== timer) return;
+						state.recentFinal = void 0;
+						state.recentFinalTimer = void 0;
+					}, RECENT_FINAL_USER_TRANSCRIPT_TTL_MS);
+					timer.unref?.();
+					state.recentFinalTimer = timer;
+					console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=true chars=${text.trim().length} aggregateChars=${transcript.length}`);
 				}
-				transcriptPersistence = this.manager.processEvent({
-					id: `realtime-bot-${callSid}-${randomUUID()}`,
-					type: "call.assistant-speech",
+				const event = {
+					id: `realtime-${role === "user" ? "speech" : "bot"}-${callSid}-${randomUUID()}`,
 					callId,
 					providerCallId: callSid,
 					timestamp: Date.now(),
-					transcript: text
-				}).then(() => {});
+					transcript,
+					...role === "user" ? {
+						type: "call.speech",
+						isFinal: true
+					} : { type: "call.assistant-speech" }
+				};
+				const generation = continuityGeneration;
+				transcriptPersistence = this.manager.processEvent(event).then(() => {
+					if (role !== "user" || handlesAgentConsult || sessionClosed || generation !== continuityGeneration || !this.getUserTranscriptState(callId, userTranscriptOwner) || !this.isActiveBridgeOwner(callId, session)) return;
+					this.scheduleForcedAgentConsult({
+						harness,
+						session,
+						callId,
+						callSid,
+						transcript,
+						consultTranscript,
+						userTranscriptOwner,
+						clearAudio: () => {
+							const clearedBytes = audioPacer.clearAudio();
+							console.log(`[voice-call] realtime forced consult cleared outbound audio callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
+						},
+						beginConsultActivity: () => activity.beginConsult(),
+						endConsultActivity: () => activity.endConsult()
+					});
+				});
 				transcriptPersistence.catch(reportTranscriptFailure);
 			},
 			onToolCall: async (toolEvent, sessionLocal) => {
 				const generation = continuityGeneration;
-				await transcriptPersistence;
-				if (sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, sessionLocal)) return;
-				const turnId = harness.ensureTurn();
-				harness.emit({
-					type: "tool.call",
-					turnId,
-					itemId: toolEvent.itemId,
-					callId: toolEvent.callId,
-					payload: {
-						name: toolEvent.name,
-						args: toolEvent.args
-					}
-				});
-				console.log(`[voice-call] realtime tool call received callId=${callId} providerCallId=${callSid} tool=${toolEvent.name}`);
-				await this.executeToolCall(sessionLocal, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, harness, userTranscriptOwner);
+				const isConsult = toolEvent.name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME;
+				const invocationId = toolEvent.callId || toolEvent.itemId;
+				const transcript = isConsult ? captureNativeConsultTranscript(userTranscriptOwner, invocationId) : void 0;
+				if (isConsult) activity.beginConsult();
+				try {
+					await transcriptPersistence;
+					if (sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, sessionLocal)) return;
+					const turnId = harness.ensureTurn();
+					harness.emit({
+						type: "tool.call",
+						turnId,
+						itemId: toolEvent.itemId,
+						callId: toolEvent.callId,
+						payload: {
+							name: toolEvent.name,
+							args: toolEvent.args
+						}
+					});
+					console.log(`[voice-call] realtime tool call received callId=${callId} providerCallId=${callSid} tool=${toolEvent.name}`);
+					await this.executeToolCall(sessionLocal, callId, invocationId, toolEvent.name, toolEvent.args, turnId, harness, userTranscriptOwner, transcript);
+				} finally {
+					if (isConsult) activity.endConsult();
+				}
 			},
 			onEvent: (event) => {
 				if (event.direction === "client" && event.type === "session.continuity.reset") {
 					continuityGeneration += 1;
 					const turnId = harness.talk.activeTurnId;
-					const owner = nativeConsultOwner.current;
+					const owner = nativeConsultOwner;
 					if (owner && this.isActiveBridgeOwner(callId, owner)) {
-						this.resetUserTranscriptState(callId, userTranscriptOwner);
-						this.resetConsultSessionForContinuity(callId, owner);
+						const state = this.getUserTranscriptState(callId, userTranscriptOwner);
+						if (state) {
+							state.partial = void 0;
+							clearRecentFinalUserTranscript(state);
+							state.nativeConsultInvocation = void 0;
+						}
+						this.cancelConsultSession(callId, owner, "continuity-reset");
 					}
 					harness.flushOutput(() => {
 						audioPacer.clearAudio();
@@ -1106,7 +1491,9 @@ var RealtimeCallHandler = class {
 					});
 					return;
 				}
-				if (event.type === "input_audio_buffer.speech_started") {
+				if (event.type === "input_audio_buffer.speech_started" && !outboundGreeting.isBlocked()) {
+					outboundGreeting.claim();
+					activity.noteSpeech();
 					harness.ensureTurn();
 					return;
 				}
@@ -1134,7 +1521,7 @@ var RealtimeCallHandler = class {
 			onResponseDone: (outcome) => {
 				if (outcome.status === "failed" || outcome.status === "incomplete") console.warn(`[voice-call] realtime response ${outcome.status}: ${outcome.message}`);
 			},
-			onReady: () => {
+			onReady: (readySession) => {
 				harness.emit({
 					type: "session.ready",
 					payload: {
@@ -1142,6 +1529,7 @@ var RealtimeCallHandler = class {
 						providerCallId: callSid
 					}
 				});
+				outboundGreeting.onReady(readySession);
 			},
 			onError: (error) => {
 				console.error("[voice-call] realtime voice error:", error.message);
@@ -1158,7 +1546,7 @@ var RealtimeCallHandler = class {
 					payload: { reason },
 					final: true
 				});
-				const owner = nativeConsultOwner.current;
+				const owner = nativeConsultOwner;
 				if (!owner) {
 					provisionalCloseReason ??= reason;
 					return;
@@ -1172,7 +1560,7 @@ var RealtimeCallHandler = class {
 				}
 				const ownsCallState = this.isActiveBridgeOwner(callId, owner);
 				if (reason === "completed" && !ownsCallState) return;
-				if (ownsCallState) closeBinding(telephonyBinding, reason);
+				if (ownsCallState) closeBinding(reason);
 				this.streamDisconnectLifecycle.retire(callSid, streamSid);
 				if (ws.readyState === WebSocket.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Bridge disconnected");
 			}
@@ -1184,7 +1572,11 @@ var RealtimeCallHandler = class {
 			console.error("[voice-call] Failed to create realtime bridge:", error);
 		}
 		if (!candidate || provisionalCloseReason) {
-			this.rollbackUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
+			if (this.getUserTranscriptState(callId, userTranscriptOwner)) {
+				clearRecentFinalUserTranscript(userTranscriptOwner);
+				if (previousTranscriptOwner) this.userTranscriptStatesByCallId.set(callId, previousTranscriptOwner);
+				else this.userTranscriptStatesByCallId.delete(callId);
+			}
 			try {
 				await drainProviderClose(() => candidate?.close());
 			} catch (error) {
@@ -1192,14 +1584,20 @@ var RealtimeCallHandler = class {
 			}
 			harness.close();
 			audioPacer.close();
+			outboundGreeting.close();
+			hostSpeech.close();
+			activity.close();
 			const reason = provisionalCloseReason ?? "error";
 			if (!this.activeBridgesByCallId.has(callId)) emitCallEnd(reason);
 			if (ws.readyState === WebSocket.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Failed to create realtime bridge");
 			return null;
 		}
 		const session = candidate;
-		this.commitUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
-		nativeConsultOwner.current = session;
+		if (this.getUserTranscriptState(callId, userTranscriptOwner) && previousTranscriptOwner) {
+			clearTimeout(previousTranscriptOwner.recentFinalTimer);
+			previousTranscriptOwner.recentFinalTimer = void 0;
+		}
+		nativeConsultOwner = session;
 		const localBargeIn = !(session.bridge.handlesInputAudioBargeIn ?? providerHandlesInputAudioBargeIn) && resolveRealtimeVoiceBargeIn({
 			configuredBargeIn: void 0,
 			interruptResponseOnInputAudio,
@@ -1215,12 +1613,17 @@ var RealtimeCallHandler = class {
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
 			if (sessionClosed) return;
+			outboundGreeting.noteInputAudio(audio);
+			if (outboundGreeting.isBlocked() || hostSpeech.isActive()) return;
+			const inputRms = calculateMulawRms(audio);
+			if (inputRms >= CALLER_SPEECH_RMS_THRESHOLD) activity.noteSpeech();
 			if (speechDetector.accept({
-				rms: calculateMulawRms(audio),
+				rms: inputRms,
 				peak: 0
 			})) {
+				outboundGreeting.claim();
 				console.log(`[voice-call] realtime local speech detected callId=${callId} providerCallId=${callSid}`);
-				if (localBargeIn) cancelOutputAudioForBargeIn("local", (audioPlaybackActive) => {
+				if (localBargeIn && !activity.isPaused()) audioController.cancelOutputAudioForBargeIn("local", (audioPlaybackActive) => {
 					session.handleBargeIn({ audioPlaybackActive });
 				});
 			}
@@ -1232,32 +1635,31 @@ var RealtimeCallHandler = class {
 		session.close = () => {
 			if (sessionClosed) return sessionClosePromise ?? Promise.resolve();
 			sessionClosed = true;
+			outboundGreeting.close();
+			hostSpeech.close();
+			activity.close();
 			this.cancelConsultSession(callId, session);
 			audioPacer.close();
 			sessionClosePromise = drainProviderClose(closeSession).finally(() => {
-				this.clearActiveBridgeMappings(callId, callSid, session);
-				this.clearUserTranscriptState(callId, userTranscriptOwner);
+				for (const key of [callId, callSid]) if (this.activeBridgesByCallId.get(key) === session) this.activeBridgesByCallId.delete(key);
+				if (this.getUserTranscriptState(callId, userTranscriptOwner)) {
+					clearRecentFinalUserTranscript(userTranscriptOwner);
+					this.userTranscriptStatesByCallId.delete(callId);
+				}
 				harness.close();
 			});
 			return sessionClosePromise;
 		};
-		let livenessTimer;
-		const clearLivenessTimer = () => {
-			if (livenessTimer) {
-				clearTimeout(livenessTimer);
-				livenessTimer = void 0;
-			}
-		};
 		let bindingClosed = false;
 		let bindingClosePromise;
-		const closeBinding = (binding, cause) => {
+		const closeBinding = (cause) => {
 			if (bindingClosed) return bindingClosePromise ?? callEndPromise ?? Promise.resolve();
 			bindingClosed = true;
-			clearLivenessTimer();
-			const ownsCall = this.activeTelephonyBindingsByCallId.get(callId) === binding;
+			activity.close();
+			const ownsCall = this.activeTelephonyBindingsByCallId.get(callId) === telephonyBinding;
 			const finishClose = () => {
-				const stillOwnsCall = this.activeTelephonyBindingsByCallId.get(callId) === binding;
-				this.clearActiveTelephonyBinding(callId, binding);
+				const stillOwnsCall = this.activeTelephonyBindingsByCallId.get(callId) === telephonyBinding;
+				if (stillOwnsCall) this.activeTelephonyBindingsByCallId.delete(callId);
 				if (cause === "disconnect") this.streamDisconnectLifecycle.disconnect(callSid, streamSid);
 				else this.streamDisconnectLifecycle.retire(callSid, streamSid);
 				if (ownsCall && stillOwnsCall && cause && cause !== "disconnect") return emitCallEnd(cause);
@@ -1292,200 +1694,69 @@ var RealtimeCallHandler = class {
 					acknowledge();
 				}
 			},
-			close: (cause) => closeBinding(telephonyBinding, cause),
+			close: (cause) => closeBinding(cause),
 			endCall: () => {
-				closeBinding(telephonyBinding);
+				closeBinding();
 				if (ws.readyState === WebSocket.OPEN) ws.close(1e3, "Call ended");
 			},
-			noteMediaActivity: () => {
-				if (bindingClosed || this.activeTelephonyBindingsByCallId.get(callId) !== telephonyBinding) return;
-				clearLivenessTimer();
-				livenessTimer = setTimeout(() => {
-					console.warn(`[voice-call] Realtime media inactive callId=${callId} providerCallId=${callSid} timeoutMs=${REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS} graceMs=${REALTIME_DISCONNECT_HANGUP_GRACE_MS}`);
-					livenessTimer = setTimeout(() => {
-						telephonyBinding.close("inactivity");
-						if (ws.readyState === WebSocket.OPEN) ws.close(1e3, "Media inactivity");
-					}, REALTIME_DISCONNECT_HANGUP_GRACE_MS);
-					livenessTimer.unref?.();
-				}, REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS);
-				livenessTimer.unref?.();
-			},
+			noteMediaActivity: () => activity.noteMedia(),
+			playVoicemail: (speechInstructions) => hostSpeech.speak(speechInstructions),
 			retire: () => {
-				closeBinding(telephonyBinding);
+				closeBinding();
 			}
 		};
 		this.activeBridgesByCallId.set(callId, session);
 		this.activeBridgesByCallId.set(callSid, session);
 		this.activeTelephonyBindingsByCallId.set(callId, telephonyBinding);
 		telephonyBinding.noteMediaActivity();
+		activity.start();
+		if (this.config.idleHangupMs) console.log(`[voice-call] Realtime speech idle monitor armed callId=${callId} providerCallId=${callSid} timeoutMs=${this.config.idleHangupMs}`);
 		if (previousTelephonyBinding && previousTelephonyBinding !== telephonyBinding) previousTelephonyBinding.retire();
 		session.connect().catch(async (error) => {
 			console.error("[voice-call] Failed to connect realtime bridge:", error);
 			try {
-				await closeBinding(telephonyBinding, "error");
+				await closeBinding("error");
 			} catch {} finally {
 				ws.close(1011, "Failed to connect");
 			}
 		});
 		return telephonyBinding;
 	}
-	beginUserTranscriptOwnerAdoption(callId) {
-		const adoption = {
-			owner: {},
-			previous: this.userTranscriptStatesByCallId.get(callId)
-		};
-		this.userTranscriptStatesByCallId.set(callId, adoption.owner);
-		return adoption;
-	}
-	commitUserTranscriptOwnerAdoption(callId, adoption) {
-		if (this.userTranscriptStatesByCallId.get(callId) !== adoption.owner) return;
-		if (adoption.previous?.recentFinalTimer) {
-			clearTimeout(adoption.previous.recentFinalTimer);
-			adoption.previous.recentFinalTimer = void 0;
-		}
-	}
-	rollbackUserTranscriptOwnerAdoption(callId, adoption) {
-		if (this.userTranscriptStatesByCallId.get(callId) !== adoption.owner) return;
-		if (adoption.owner.recentFinalTimer) {
-			clearTimeout(adoption.owner.recentFinalTimer);
-			adoption.owner.recentFinalTimer = void 0;
-		}
-		if (adoption.previous) {
-			this.userTranscriptStatesByCallId.set(callId, adoption.previous);
-			return;
-		}
-		this.userTranscriptStatesByCallId.delete(callId);
-	}
 	getUserTranscriptState(callId, owner) {
 		const state = this.userTranscriptStatesByCallId.get(callId);
 		return state === owner ? state : void 0;
 	}
-	recordPartialUserTranscript(callId, owner, text) {
-		const state = this.getUserTranscriptState(callId, owner);
-		if (!state) return;
-		const next = limitPartialUserTranscript(appendTranscriptText(state.partial, text));
-		const raw = limitPartialUserTranscript(`${state.rawPartial ?? ""}${text}`);
-		state.partial = next;
-		state.rawPartial = raw;
-		state.partialUpdatedAt = Date.now();
-		return next;
-	}
-	clearPartialUserTranscript(callId, owner) {
-		const state = this.getUserTranscriptState(callId, owner);
-		if (!state) return;
-		state.partial = void 0;
-		state.rawPartial = void 0;
-		state.partialUpdatedAt = void 0;
-	}
-	setRecentFinalUserTranscript(callId, owner, text) {
-		const state = this.getUserTranscriptState(callId, owner);
-		if (!state) return;
-		this.clearRecentFinalUserTranscript(callId, owner);
-		state.recentFinal = text;
-		const timer = setTimeout(() => {
-			if (this.userTranscriptStatesByCallId.get(callId) !== state) return;
-			if (state.recentFinal === text) state.recentFinal = void 0;
-			if (state.recentFinalTimer === timer) state.recentFinalTimer = void 0;
-		}, RECENT_FINAL_USER_TRANSCRIPT_TTL_MS);
-		timer.unref?.();
-		state.recentFinalTimer = timer;
-	}
-	clearRecentFinalUserTranscript(callId, owner) {
-		const state = this.getUserTranscriptState(callId, owner);
-		if (!state) return;
-		if (state.recentFinalTimer) {
-			clearTimeout(state.recentFinalTimer);
-			state.recentFinalTimer = void 0;
-		}
-		state.recentFinal = void 0;
-	}
-	resetUserTranscriptState(callId, owner) {
-		this.clearPartialUserTranscript(callId, owner);
-		this.clearRecentFinalUserTranscript(callId, owner);
-	}
-	clearUserTranscriptState(callId, owner) {
-		const state = this.getUserTranscriptState(callId, owner);
-		if (!state) return;
-		if (state.recentFinalTimer) clearTimeout(state.recentFinalTimer);
-		this.userTranscriptStatesByCallId.delete(callId);
-	}
-	cancelNativeConsult(callId, owner) {
-		const state = this.nativeConsultsInFlightByCallId.get(callId);
-		if (!state || state.owner !== owner) return;
-		this.nativeConsultsInFlightByCallId.delete(callId);
-		state.cancel();
-	}
-	cancelForcedConsult(callId, owner) {
-		const state = this.forcedConsultsByCallId.get(callId);
-		if (!state || state.owner !== owner) return;
-		state.cancelled = true;
-		state.sendSpeechPrompt = false;
-		state.cancel();
-		this.forcedConsultsByCallId.delete(callId);
-	}
-	resetConsultSessionForContinuity(callId, owner) {
-		const session = this.consultSessionsByCallId.get(callId);
-		if (!session || session.owner !== owner) return;
-		this.cancelForcedConsult(callId, owner);
-		this.cancelNativeConsult(callId, owner);
-		session.coordinator.clear();
-	}
-	cancelConsultSession(callId, owner) {
+	cancelConsultSession(callId, owner, mode = "retire") {
 		const session = this.consultSessionsByCallId.get(callId);
 		if (!session || session.owner !== owner) return;
-		session.coordinator.clearPending();
-		this.cancelForcedConsult(callId, owner);
-		this.cancelNativeConsult(callId, owner);
-		this.consultSessionsByCallId.delete(callId);
+		if (mode === "retire") session.coordinator.clearPending();
+		const forced = this.forcedConsultsByCallId.get(callId);
+		if (forced?.owner === owner) {
+			forced.cancelled = true;
+			forced.sendSpeechPrompt = false;
+			forced.cancel();
+			this.forcedConsultsByCallId.delete(callId);
+		}
+		const native = this.nativeConsultsInFlightByCallId.get(callId);
+		if (native?.owner === owner) {
+			this.nativeConsultsInFlightByCallId.delete(callId);
+			native.cancel();
+		}
+		if (mode === "continuity-reset") session.coordinator.clear();
+		else this.consultSessionsByCallId.delete(callId);
 	}
 	isActiveBridgeOwner(callId, owner) {
 		return this.activeBridgesByCallId.get(callId) === owner;
 	}
-	clearActiveBridgeMappings(callId, callSid, owner) {
-		for (const key of [callId, callSid]) {
-			if (this.activeBridgesByCallId.get(key) !== owner) continue;
-			this.activeBridgesByCallId.delete(key);
-		}
-	}
-	clearActiveTelephonyBinding(callId, binding) {
-		if (this.activeTelephonyBindingsByCallId.get(callId) === binding) this.activeTelephonyBindingsByCallId.delete(callId);
-	}
-	resolveUserTranscriptContext(callId, owner) {
-		const state = this.getUserTranscriptState(callId, owner);
-		return state?.partial ?? state?.recentFinal;
-	}
-	consumePartialUserTranscript(callId, owner, consumed) {
-		const text = consumed?.trim();
-		if (!text) return;
-		const state = this.getUserTranscriptState(callId, owner);
-		const current = state?.partial;
-		if (!current) return;
-		if (current === text) {
-			this.clearPartialUserTranscript(callId, owner);
-			return;
-		}
-		if (current.toLowerCase().startsWith(text.toLowerCase())) {
-			const remaining = current.slice(text.length).trimStart();
-			if (remaining) {
-				state.partial = remaining;
-				state.rawPartial = remaining;
-			} else this.clearPartialUserTranscript(callId, owner);
-		}
-		const recent = state.recentFinal;
-		if (!recent) return;
-		if (recent === text || recent.toLowerCase().startsWith(text.toLowerCase())) this.clearRecentFinalUserTranscript(callId, owner);
-	}
 	async waitForConsultTranscriptSettle(callId, owner, startedAt) {
 		const deadline = startedAt + CONSULT_TRANSCRIPT_SETTLE_MAX_MS;
 		while (true) {
-			const updatedAt = this.getUserTranscriptState(callId, owner)?.partialUpdatedAt;
+			const updatedAt = this.getUserTranscriptState(callId, owner)?.partial?.updatedAt;
 			if (!updatedAt) return;
 			const now = Date.now();
 			const quietFor = now - updatedAt;
 			if (quietFor >= CONSULT_TRANSCRIPT_SETTLE_MS || now >= deadline) return;
-			await new Promise((resolve) => {
-				setTimeout(resolve, Math.min(CONSULT_TRANSCRIPT_SETTLE_MS - quietFor, deadline - now));
-			});
+			await sleep(Math.min(CONSULT_TRANSCRIPT_SETTLE_MS - quietFor, deadline - now));
 		}
 	}
 	scheduleForcedAgentConsult(params) {
@@ -1518,9 +1789,11 @@ var RealtimeCallHandler = class {
 		logger.debug(`[voice-call] realtime forced agent consult reason=${FORCED_CONSULT_REASON} consultPolicy=always callId=${params.callId} providerCallId=${params.callSid} chars=${params.handle.question.length}`);
 		console.log(`[voice-call] realtime forced agent consult starting callId=${params.callId} providerCallId=${params.callSid} chars=${params.handle.question.length}`);
 		params.clearAudio();
+		params.beginConsultActivity();
 		const abortController = new AbortController();
 		const state = {
 			owner: params.session,
+			handle: params.handle,
 			sendSpeechPrompt: true,
 			cancelled: false,
 			cancel: () => {
@@ -1551,7 +1824,7 @@ var RealtimeCallHandler = class {
 				params.session.sendUserMessage(buildForcedConsultSpeechPrompt(text));
 			}
 			console.log(`[voice-call] realtime forced agent consult completed callId=${params.callId} providerCallId=${params.callSid} elapsedMs=${Date.now() - startedAt}`);
-			this.consumePartialUserTranscript(params.callId, params.userTranscriptOwner, params.handle.question);
+			consumeUserTranscript(this.getUserTranscriptState(params.callId, params.userTranscriptOwner), params.consultTranscript);
 		} catch (error) {
 			if (!state.cancelled) {
 				const result = buildRealtimeVoiceAgentErrorProviderResult(error);
@@ -1559,6 +1832,7 @@ var RealtimeCallHandler = class {
 				(failed ? console.warn : console.log)(`[voice-call] realtime forced agent consult ${failed ? "failed" : "cancelled"} callId=${params.callId} providerCallId=${params.callSid}${failed ? ` error=${result.error}` : ""}`);
 			}
 		} finally {
+			params.endConsultActivity();
 			if (!state.cancelled) {
 				if (this.forcedConsultsByCallId.get(params.callId) !== state) coordinator.remove(params.handle);
 				else setTimeout(() => {
@@ -1636,7 +1910,7 @@ var RealtimeCallHandler = class {
 		});
 		binding.endCall();
 	}
-	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness, userTranscriptOwner, delegation) {
+	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness, userTranscriptOwner, consultTranscript, delegation) {
 		if (name === "openclaw_end_call") {
 			await this.executeEndCallTool({
 				bridge,
@@ -1696,6 +1970,12 @@ var RealtimeCallHandler = class {
 		};
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
 			if (this.activeBridgesByCallId.get(callId) !== bridge) return;
+			const submitBusyResult = () => submitFinalToolResult({
+				status: "busy",
+				started: false,
+				retryable: true,
+				error: "OpenClaw is still consulting on a different request. This request has not started. Wait for that consult's result before you retry this request; do not poll while it is running."
+			});
 			const coordinator = harness.forcedConsults;
 			const forcedMatch = coordinator.recordNativeConsult(args, bridgeCallId);
 			if (forcedMatch.kind === "none") {
@@ -1704,25 +1984,27 @@ var RealtimeCallHandler = class {
 			}
 			const forcedConsultState = this.forcedConsultsByCallId.get(callId);
 			const forcedConsult = forcedConsultState?.owner === bridge && !forcedConsultState.cancelled ? forcedConsultState : void 0;
-			if (forcedMatch.kind === "already_delivered" && coordinator.isCancelled(forcedMatch.handle)) {
-				if (forcedConsult) forcedConsult.sendSpeechPrompt = false;
-				return await submitFinalToolResult({
+			if (forcedMatch.kind === "already_delivered") {
+				const cancelled = coordinator.isCancelled(forcedMatch.handle);
+				if (cancelled && forcedConsult?.handle === forcedMatch.handle) forcedConsult.sendSpeechPrompt = false;
+				return await submitFinalToolResult(cancelled ? {
 					status: "cancelled",
 					message: "OpenClaw cancelled this consult before completion. Do not restart it."
-				});
-			}
-			if (forcedConsult) {
-				if (forcedConsult.completedAt || forcedMatch.kind === "already_delivered") return await submitFinalToolResult({
+				} : {
 					status: "already_delivered",
 					message: "OpenClaw already delivered this consult result internally. Do not repeat it."
 				});
+			}
+			if (forcedConsult && forcedMatch.kind !== "none" && forcedMatch.handle === forcedConsult.handle) {
 				forcedConsult.sendSpeechPrompt = false;
 				const result = await forcedConsult.promise.catch(buildRealtimeVoiceAgentErrorProviderResult);
 				if (forcedConsult.cancelled || forcedConsult.owner !== bridge || this.forcedConsultsByCallId.get(callId) !== forcedConsult) return;
 				return await submitFinalToolResult(result);
 			}
+			if (forcedConsult && !forcedConsult.completedAt) return await submitBusyResult();
 			const existingNativeConsult = this.nativeConsultsInFlightByCallId.get(callId);
-			if (existingNativeConsult) {
+			if (existingNativeConsult?.owner === bridge && !existingNativeConsult.cancelled) {
+				if (!bridgeCallId.trim() || existingNativeConsult.invocationId !== bridgeCallId) return await submitBusyResult();
 				console.log(`[voice-call] realtime tool call sharing in-flight agent consult callId=${callId} ageMs=${Date.now() - existingNativeConsult.startedAt}`);
 				await submitWorkingResponse();
 				const outcome = await waitForNativeConsult(existingNativeConsult);
@@ -1734,6 +2016,7 @@ var RealtimeCallHandler = class {
 			const { promise: consult, resolve: completeConsult } = createDeferred();
 			const state = {
 				owner: bridge,
+				invocationId: bridgeCallId,
 				startedAt,
 				promise: consult,
 				cancellation,
@@ -1754,11 +2037,12 @@ var RealtimeCallHandler = class {
 					if (state.cancelled || !this.isActiveBridgeOwner(callId, bridge)) return;
 					await Promise.race([this.waitForConsultTranscriptSettle(callId, userTranscriptOwner, startedAt), state.cancellation]);
 					if (state.cancelled || !this.isActiveBridgeOwner(callId, bridge)) return;
+					const transcript = consultTranscript?.();
 					const context = {
-						partialUserTranscript: this.resolveUserTranscriptContext(callId, userTranscriptOwner),
+						partialUserTranscript: transcript?.text,
 						abortSignal: abortController.signal
 					};
-					state.partialUserTranscript = context.partialUserTranscript;
+					state.transcript = transcript;
 					const handlerArgs = withFallbackConsultQuestion(args, context.partialUserTranscript);
 					return await invokeHandler(handlerArgs, context);
 				} catch (error) {
@@ -1771,14 +2055,15 @@ var RealtimeCallHandler = class {
 				const result = outcome.result;
 				const failed = logResult(result);
 				await submitFinalToolResult(result);
-				if (!failed) this.consumePartialUserTranscript(callId, userTranscriptOwner, state.partialUserTranscript);
+				if (!failed) consumeUserTranscript(this.getUserTranscriptState(callId, userTranscriptOwner), state.transcript);
 				return result;
 			} finally {
 				delegation?.signal?.removeEventListener("abort", state.cancel);
 				if (this.nativeConsultsInFlightByCallId.get(callId) === state) this.nativeConsultsInFlightByCallId.delete(callId);
 			}
 		}
-		const result = await invokeHandler(args, { partialUserTranscript: this.resolveUserTranscriptContext(callId, userTranscriptOwner) });
+		const transcript = this.getUserTranscriptState(callId, userTranscriptOwner);
+		const result = await invokeHandler(args, { partialUserTranscript: (transcript?.partial ?? transcript?.recentFinal)?.text });
 		logResult(result);
 		return await submitFinalToolResult(result);
 	}