@elizaos/plugin-local-inference 2.0.3-beta.2 → 2.0.3-beta.4

package/src/services/voice/echo-reference-buffer.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { EchoReferenceBuffer } from "./echo-reference-buffer.ts";
+
+/** Ramp where sample i has value i+1 (so 0 = "not filled"). */
+function ramp(from: number, count: number): Float32Array {
+	const out = new Float32Array(count);
+	for (let i = 0; i < count; i++) out[i] = from + i + 1;
+	return out;
+}
+
+describe("EchoReferenceBuffer (#9583)", () => {
+	it("returns the last `length` samples at zero delay", () => {
+		const buf = new EchoReferenceBuffer({ capacitySamples: 1000 });
+		buf.push(ramp(0, 500)); // values 1..500
+		const ref = buf.referenceFor(4, 0);
+		expect(Array.from(ref)).toEqual([497, 498, 499, 500]);
+	});
+
+	it("shifts the window back by the delay", () => {
+		const buf = new EchoReferenceBuffer({ capacitySamples: 1000 });
+		buf.push(ramp(0, 500)); // values 1..500
+		// delay 10 → window ends at sample (500-10)=490 → [487,488,489,490]
+		expect(Array.from(buf.referenceFor(4, 10))).toEqual([487, 488, 489, 490]);
+	});
+
+	it("zero-fills samples not yet pushed (delay+length exceeds stream)", () => {
+		const buf = new EchoReferenceBuffer({ capacitySamples: 1000 });
+		buf.push(ramp(0, 3)); // values 1,2,3
+		// length 5, delay 0 → window [-2,3): two leading zeros then 1,2,3
+		expect(Array.from(buf.referenceFor(5, 0))).toEqual([0, 0, 1, 2, 3]);
+	});
+
+	it("zero-fills the part evicted past capacity", () => {
+		const buf = new EchoReferenceBuffer({ capacitySamples: 8 });
+		buf.push(ramp(0, 12)); // values 1..12; only the last 8 (5..12) retained
+		// delay 0, length 8 → the retained window is values 5..12
+		expect(Array.from(buf.referenceFor(8, 0))).toEqual([
+			5, 6, 7, 8, 9, 10, 11, 12,
+		]);
+		// Asking for 10 reaches before the retained window → 2 leading zeros.
+		expect(Array.from(buf.referenceFor(10, 0))).toEqual([
+			0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+		]);
+	});
+
+	it("accumulates across multiple pushes and tracks position", () => {
+		const buf = new EchoReferenceBuffer({ capacitySamples: 1000 });
+		buf.push(ramp(0, 100));
+		buf.push(ramp(100, 100)); // values 101..200, position now 200
+		expect(buf.position).toBe(200);
+		expect(Array.from(buf.referenceFor(3, 0))).toEqual([198, 199, 200]);
+	});
+
+	it("reset clears the buffer", () => {
+		const buf = new EchoReferenceBuffer({ capacitySamples: 1000 });
+		buf.push(ramp(0, 50));
+		buf.reset();
+		expect(buf.position).toBe(0);
+		expect(Array.from(buf.referenceFor(3, 0))).toEqual([0, 0, 0]);
+	});
+
+	it("preserves timestamp gaps between playback bursts", () => {
+		const buf = new EchoReferenceBuffer({
+			capacitySamples: 4000,
+			sampleRateHz: 16_000,
+		});
+		buf.pushAt(1000, ramp(0, 4)); // samples 0..3
+		buf.pushAt(1100, ramp(100, 4)); // samples 1600..1603
+
+		expect(Array.from(buf.referenceAt(1000, 4, 0))).toEqual([1, 2, 3, 4]);
+		expect(Array.from(buf.referenceAt(1050, 4, 0))).toEqual([0, 0, 0, 0]);
+		expect(Array.from(buf.referenceAt(1100, 4, 0))).toEqual([
+			101, 102, 103, 104,
+		]);
+	});
+
+	it("applies delay to timestamp-aligned reads", () => {
+		const buf = new EchoReferenceBuffer({
+			capacitySamples: 1000,
+			sampleRateHz: 16_000,
+		});
+		buf.pushAt(0, ramp(0, 10));
+
+		expect(Array.from(buf.referenceAt(0.25, 4, 2))).toEqual([3, 4, 5, 6]);
+	});
+});

package/src/services/voice/echo-reference-buffer.ts

@@ -0,0 +1,165 @@
+/**
+ * Echo-reference alignment buffer (#9583, follow-up to #9455/#9586).
+ *
+ * The NLMS echo canceller's `process(nearEnd, farEnd)` needs the far-end
+ * (the agent's TTS playback) **time-aligned** to the current mic frame: the
+ * echo in `nearEnd[t]` is the room-filtered playback from `t − delay`, where
+ * `delay` is the bulk playback→mic transport delay (estimated by
+ * {@link estimateEchoDelaySamples} in `echo-delay.ts`).
+ *
+ * The caller renders playback PCM in real time and `push()`es it here as it goes;
+ * per mic frame it then asks for the aligned far-end slice. This is the
+ * "caller must supply the reference" primitive the consumer seam was missing —
+ * a fixed-capacity delay line, pure logic (no FFI, no device, no audio I/O).
+ * Samples not yet rendered, or already evicted past capacity, are zero-filled
+ * (no echo reference ⇒ the adaptive filter simply has nothing to cancel there).
+ */
+
+export interface EchoReferenceBufferOptions {
+	/**
+	 * Ring-buffer capacity in samples. Must comfortably exceed
+	 * `maxDelaySamples + frameLength`. Default 24000 (1.5 s @ 16 kHz).
+	 */
+	capacitySamples?: number;
+	/** Sample rate for timestamp-based push/read helpers. Default 16000. */
+	sampleRateHz?: number;
+}
+
+export class EchoReferenceBuffer {
+	private readonly buffer: Float32Array;
+	private readonly valid: Uint8Array;
+	private readonly capacity: number;
+	private readonly sampleRateHz: number;
+	/** Total samples ever pushed (monotonic); the logical "now" cursor. */
+	private pushed = 0;
+	/** Timestamp mapped to absolute sample 0 for timestamp-aware playback. */
+	private originMs: number | null = null;
+
+	constructor(options: EchoReferenceBufferOptions = {}) {
+		this.capacity = Math.max(1, Math.floor(options.capacitySamples ?? 24000));
+		this.sampleRateHz = Math.max(1, Math.floor(options.sampleRateHz ?? 16_000));
+		this.buffer = new Float32Array(this.capacity);
+		this.valid = new Uint8Array(this.capacity);
+	}
+
+	/** Append rendered playback (far-end) PCM as it is produced. */
+	push(playback: Float32Array): void {
+		this.writeAt(this.pushed, playback);
+		this.pushed += playback.length;
+	}
+
+	/**
+	 * Store rendered playback at its capture/render timestamp. This preserves
+	 * real gaps between playback bursts instead of treating chunks as contiguous.
+	 */
+	pushAt(timestampMs: number, playback: Float32Array): void {
+		if (!Number.isFinite(timestampMs)) {
+			this.push(playback);
+			return;
+		}
+		if (this.originMs === null) this.originMs = timestampMs;
+		let start = this.sampleIndexFor(timestampMs);
+		if (start < 0) {
+			this.reset();
+			this.originMs = timestampMs;
+			start = 0;
+		}
+		this.writeAt(start, playback);
+		this.pushed = Math.max(this.pushed, start + playback.length);
+	}
+
+	/**
+	 * The far-end reference frame aligned to a mic frame of `length` samples
+	 * captured `delaySamples` after the corresponding playback. Returns the
+	 * playback window `[pushed − delaySamples − length, pushed − delaySamples)`.
+	 * Indices before the retained window (not yet pushed, or evicted past
+	 * capacity) are zero-filled.
+	 */
+	referenceFor(length: number, delaySamples: number): Float32Array {
+		const out = new Float32Array(Math.max(0, Math.floor(length)));
+		const delay = Math.max(0, Math.floor(delaySamples));
+		// Absolute index (in the monotonic stream) of the first output sample.
+		const start = this.pushed - delay - out.length;
+		return this.readWindow(start, out.length);
+	}
+
+	/**
+	 * Reference aligned to a mic frame starting at `timestampMs`.
+	 * Returns playback `[timestampMs - delay, timestampMs - delay + length)`.
+	 */
+	referenceAt(
+		timestampMs: number,
+		length: number,
+		delaySamples: number,
+	): Float32Array {
+		const outLength = Math.max(0, Math.floor(length));
+		if (this.originMs === null || !Number.isFinite(timestampMs)) {
+			return new Float32Array(outLength);
+		}
+		const delay = Math.max(0, Math.floor(delaySamples));
+		const start = this.sampleIndexFor(timestampMs) - delay;
+		return this.readWindow(start, outLength);
+	}
+
+	/** Samples pushed so far (the monotonic stream position). */
+	get position(): number {
+		return this.pushed;
+	}
+
+	/** Drop all buffered playback (e.g. on a new turn / barge-in flush). */
+	reset(): void {
+		this.buffer.fill(0);
+		this.valid.fill(0);
+		this.pushed = 0;
+		this.originMs = null;
+	}
+
+	private sampleIndexFor(timestampMs: number): number {
+		if (this.originMs === null) return 0;
+		return Math.round(
+			((timestampMs - this.originMs) / 1000) * this.sampleRateHz,
+		);
+	}
+
+	private writeAt(start: number, playback: Float32Array): void {
+		const safeStart = Math.max(0, Math.floor(start));
+		const end = safeStart + playback.length;
+		if (safeStart > this.pushed) this.clearRange(this.pushed, safeStart);
+		const oldest = Math.max(0, this.pushed - this.capacity);
+		if (end <= oldest) return;
+		for (let i = 0; i < playback.length; i++) {
+			const abs = safeStart + i;
+			if (abs < oldest) continue;
+			const slot = abs % this.capacity;
+			this.buffer[slot] = playback[i] ?? 0;
+			this.valid[slot] = 1;
+		}
+	}
+
+	private clearRange(from: number, to: number): void {
+		if (to <= from) return;
+		if (to - from >= this.capacity) {
+			this.buffer.fill(0);
+			this.valid.fill(0);
+			return;
+		}
+		for (let abs = Math.max(0, Math.floor(from)); abs < to; abs++) {
+			const slot = abs % this.capacity;
+			this.buffer[slot] = 0;
+			this.valid[slot] = 0;
+		}
+	}
+
+	private readWindow(start: number, length: number): Float32Array {
+		const out = new Float32Array(length);
+		const oldest = Math.max(0, this.pushed - this.capacity);
+		for (let i = 0; i < out.length; i++) {
+			const abs = start + i;
+			if (abs >= oldest && abs >= 0 && abs < this.pushed) {
+				const slot = abs % this.capacity;
+				if (this.valid[slot] === 1) out[i] = this.buffer[slot];
+			}
+		}
+		return out;
+	}
+}

package/src/services/voice/eliza1-eot-scorer.ts

@@ -1,14 +1,14 @@
 /**
  * Eliza-1 EOT scorer — reuses the already-loaded text model to compute
- * P(`<|im_end|>` next | conversation_so_far) without shipping a separate
+ * P(`<end_of_turn>` next | conversation_so_far) without shipping a separate
  * detector ONNX.
  *
  * The runtime keeps a `LlamaModel` resident for chat generation. Voice
- * EOT scoring is a single forward pass over the formatted Qwen chat
- * prompt with the trailing `<|im_end|>` removed. `capacitor-llama`'s
+ * EOT scoring is a single forward pass over the formatted Gemma chat
+ * prompt with the trailing `<end_of_turn>` removed. `capacitor-llama`'s
  * `LlamaContextSequence.controlledEvaluate()` returns the next-token
  * probability distribution, so we simply read the entry for the
- * `<|im_end|>` token id — no sampling loop, no KV-cache growth on the
+ * `<end_of_turn>` token id — no sampling loop, no KV-cache growth on the
  * chat session.
  *
  * A dedicated `LlamaContext` is held just for this scorer so we do not
@@ -70,8 +70,8 @@ export interface ControlledEvaluateOutputLike {
 	};
 }
 
-const IM_END_TOKEN = "<|im_end|>";
-const IM_START_USER_PREFIX = "<|im_start|>user\n";
+const END_OF_TURN_TOKEN = "<end_of_turn>";
+const START_OF_TURN_USER_PREFIX = "<start_of_turn>user\n";
 
 export interface Eliza1EotScorerOptions {
 	/** The already-loaded text model (eliza-1 drafter). */
@@ -89,7 +89,7 @@ export interface Eliza1EotScorerOptions {
 }
 
 export interface Eliza1EotScoreResult {
-	/** Probability of `<|im_end|>` as the next token, ∈ [0, 1]. */
+	/** Probability of `<end_of_turn>` as the next token, ∈ [0, 1]. */
 	probability: number;
 	/** Wall-clock model latency for this scoring call. */
 	latencyMs: number;
@@ -112,7 +112,7 @@ export class Eliza1EotScorer {
 
 	private context: LlamaContextLike | null = null;
 	private sequence: LlamaContextSequenceLike | null = null;
-	private imEndTokenId: number | null = null;
+	private endOfTurnTokenId: number | null = null;
 	private initPromise: Promise<void> | null = null;
 	/** Serializes concurrent calls — controlledEvaluate is not thread-safe per-sequence. */
 	private inflight: Promise<unknown> = Promise.resolve();
@@ -133,15 +133,15 @@ export class Eliza1EotScorer {
 	async score(partialTranscript: string): Promise<Eliza1EotScoreResult> {
 		await this.ensureReady();
 		const sequence = this.sequence;
-		const imEndId = this.imEndTokenId;
-		if (!sequence || imEndId === null) {
+		const endOfTurnId = this.endOfTurnTokenId;
+		if (!sequence || endOfTurnId === null) {
 			throw new Error("[voice] Eliza1EotScorer not initialized.");
 		}
 
 		const tokens = this.tokenizePrompt(partialTranscript);
 		const start = performance.now();
 		const next = this.inflight.then(() =>
-			this.runOnce(sequence, tokens, imEndId),
+			this.runOnce(sequence, tokens, endOfTurnId),
 		);
 		this.inflight = next.catch(() => undefined);
 		const probability = await next;
@@ -156,25 +156,25 @@ export class Eliza1EotScorer {
 		const ctx = this.context;
 		this.context = null;
 		this.sequence = null;
-		this.imEndTokenId = null;
+		this.endOfTurnTokenId = null;
 		this.initPromise = null;
 		if (ctx) await ctx.dispose();
 	}
 
 	private async ensureReady(): Promise<void> {
-		if (this.context && this.sequence && this.imEndTokenId !== null) return;
+		if (this.context && this.sequence && this.endOfTurnTokenId !== null) return;
 		if (!this.initPromise) this.initPromise = this.initialize();
 		await this.initPromise;
 	}
 
 	private async initialize(): Promise<void> {
-		const imEndIds = this.model.tokenize(IM_END_TOKEN, true);
-		if (imEndIds.length !== 1 || !Number.isInteger(imEndIds[0])) {
+		const endOfTurnIds = this.model.tokenize(END_OF_TURN_TOKEN, true);
+		if (endOfTurnIds.length !== 1 || !Number.isInteger(endOfTurnIds[0])) {
 			throw new Error(
-				`[voice] Eliza1EotScorer: model tokenizer did not resolve <|im_end|> to a single special token (got ${JSON.stringify(imEndIds)}). The base model must be Qwen-template compatible.`,
+				`[voice] Eliza1EotScorer: model tokenizer did not resolve <end_of_turn> to a single special token (got ${JSON.stringify(endOfTurnIds)}). The base model must be Gemma-template compatible.`,
 			);
 		}
-		this.imEndTokenId = imEndIds[0];
+		this.endOfTurnTokenId = endOfTurnIds[0];
 
 		const contextOptions: Parameters<LlamaModelLike["createContext"]>[0] = {
 			contextSize: this.contextSize,
@@ -206,7 +206,7 @@ export class Eliza1EotScorer {
 	private async runOnce(
 		sequence: LlamaContextSequenceLike,
 		tokens: number[],
-		imEndId: number,
+		endOfTurnId: number,
 	): Promise<number> {
 		if (tokens.length === 0) return 0.5;
 		await sequence.clearHistory();
@@ -219,15 +219,15 @@ export class Eliza1EotScorer {
 		const last = out[tokens.length - 1];
 		const probs = last?.next.probabilities;
 		if (!probs) return 0.5;
-		const p = probs.get(imEndId);
+		const p = probs.get(endOfTurnId);
 		if (typeof p !== "number" || !Number.isFinite(p)) return 0.5;
 		return Math.max(0, Math.min(1, p));
 	}
 }
 
 /**
- * Format the partial transcript using the Qwen chat template, with the
- * trailing `<|im_end|>` removed so the next predicted token *is* the
+ * Format the partial transcript using the Gemma chat template, with the
+ * trailing `<end_of_turn>` removed so the next predicted token *is* the
  * EOT signal we want to measure.
  *
  * Matches the formatting LiveKit's turn-detector uses (single user turn,
@@ -238,5 +238,5 @@ export class Eliza1EotScorer {
  */
 export function formatEotPrompt(transcript: string): string {
 	const cleaned = transcript.trim();
-	return `${IM_START_USER_PREFIX}${cleaned}`;
+	return `${START_OF_TURN_USER_PREFIX}${cleaned}`;
 }

package/src/services/voice/embedding.ts

@@ -110,9 +110,8 @@ export type LocalEmbeddingSource =
 			/**
 			 * The dedicated model already ships a contrastive `last`-token
 			 * pooling head — `--pooling last` is still passed so llama-server
-			 * doesn't fall back to the GGUF's metadata default (which for a raw
-			 * Qwen3 base is `mean`). The model's own pooling layer dominates;
-			 * this just pins the read.
+			 * doesn't fall back to the GGUF's metadata default. The model's own
+			 * pooling layer dominates; this just pins the read.
 			 */
 			readonly poolingType: "last";
 	  };

package/src/services/voice/engine-bridge-transcript-join.test.ts

@@ -0,0 +1,278 @@
+/**
+ * Regression test for the #8786 in-process transcript join.
+ *
+ * `runVoiceTurn` runs speaker-attribution in parallel with the ASR pipeline.
+ * The attribution result drives `handleLiveVoiceAttribution`, which emits
+ * `VOICE_TURN_OBSERVED` so the merge engine can fold the turn into the entity
+ * graph. Historically the emit carried an empty `text` because the in-process
+ * engine never threaded the turn's ASR transcript into the attribution call —
+ * so the merge engine knew *who* spoke but never *what* they said, and live
+ * name extraction (`VoiceObserver.ingestTurn`) could not fire.
+ *
+ * These tests assert the join: the transcript produced inside the pipeline
+ * (`onAsrComplete`) rides on `VOICE_TURN_OBSERVED` for the same turn. They mock
+ * the attribution + pipeline seams (no model, no FFI, no live voice loop) so the
+ * correlation logic is exercised in isolation.
+ */
+
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { IAgentRuntime } from "@elizaos/core";
+import { EventType } from "@elizaos/core";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { EngineVoiceBridge } from "./engine-bridge";
+import type { VoiceLifecycleLoaders } from "./lifecycle";
+import type { MtpTextRunner } from "./pipeline-impls";
+import type { MmapRegionHandle, RefCountedResource } from "./shared-resources";
+import type { VoiceAttributionOutput } from "./speaker/attribution-pipeline";
+import { writeVoicePresetFile } from "./voice-preset-format";
+
+function writePresetBundle(root: string): void {
+	mkdirSync(path.join(root, "cache"), { recursive: true });
+	const embedding = new Float32Array(16);
+	for (let i = 0; i < embedding.length; i++) embedding[i] = (i + 1) / 100;
+	writeFileSync(
+		path.join(root, "cache", "voice-preset-default.bin"),
+		Buffer.from(writeVoicePresetFile({ embedding, phrases: [] })),
+	);
+}
+
+function lifecycleLoadersOk(): VoiceLifecycleLoaders {
+	const region: MmapRegionHandle = {
+		id: "region-ok",
+		path: "/tmp/tts-ok",
+		sizeBytes: 1024,
+		async evictPages() {},
+		async release() {},
+	};
+	const refc: RefCountedResource = { id: "refc-ok", async release() {} };
+	return {
+		loadTtsRegion: async () => region,
+		loadAsrRegion: async () => region,
+		loadVoiceCaches: async () => refc,
+		loadVoiceSchedulerNodes: async () => refc,
+	};
+}
+
+function unitEmbedding(index = 0): Float32Array {
+	const out = new Float32Array(256);
+	out[index] = 1;
+	return out;
+}
+
+/** Attribution output with a bound speaker (drives the VOICE_TURN_OBSERVED emit). */
+function attributionOutput(
+	embedding: Float32Array = unitEmbedding(),
+): VoiceAttributionOutput {
+	return {
+		turnId: "t1",
+		primarySpeaker: { entityId: "entity-jill", confidence: 0.6 },
+		observation: {
+			imprintClusterId: "cluster-1",
+			confidence: 0.6,
+			entityId: "entity-jill",
+			embedding,
+		},
+		turn: { metadata: {} },
+		segments: [],
+	} as unknown as VoiceAttributionOutput;
+}
+
+/**
+ * Capture `VOICE_TURN_OBSERVED` emits and expose a promise that resolves once the
+ * first one lands (attribution is fire-and-forget, so the test must wait for it).
+ */
+function captureRuntime(): {
+	runtime: IAgentRuntime;
+	observed: Promise<Record<string, unknown>>;
+} {
+	let resolveObserved: (payload: Record<string, unknown>) => void = () => {};
+	const observed = new Promise<Record<string, unknown>>((resolve) => {
+		resolveObserved = resolve;
+	});
+	const runtime = {
+		emitEvent: async (type: unknown, payload: Record<string, unknown>) => {
+			if (type === EventType.VOICE_TURN_OBSERVED) resolveObserved(payload);
+		},
+	} as unknown as IAgentRuntime;
+	return { runtime, observed };
+}
+
+/**
+ * Build a minimal bridge, then inject the attribution + pipeline mocks onto its
+ * private seams. `buildPipeline` is overridden to a fake pipeline that fires
+ * `onAsrComplete` (the in-pipeline transcript source) on `run`.
+ */
+function bridgeWithJoin(opts: {
+	bundleRoot: string;
+	runtime: IAgentRuntime;
+	asrTokens: ReadonlyArray<{ index: number; text: string }>;
+	/** When true, the fake pipeline never fires onAsrComplete (cancelled/no-ASR). */
+	skipAsr?: boolean;
+	/** Resolve the fake attribution only after this promise (timing control). */
+	attributionGate?: Promise<void>;
+	attributionEmbedding?: Float32Array;
+}): EngineVoiceBridge {
+	const bridge = EngineVoiceBridge.start({
+		bundleRoot: opts.bundleRoot,
+		useFfiBackend: false,
+		lifecycleLoaders: lifecycleLoadersOk(),
+	});
+	const internals = bridge as unknown as {
+		attributionPipeline: {
+			attribute(req: unknown): Promise<VoiceAttributionOutput>;
+		};
+		eventRuntime: IAgentRuntime;
+		buildPipeline(
+			runner: unknown,
+			config: unknown,
+			events?: {
+				onAsrComplete?(
+					tokens: ReadonlyArray<{ index: number; text: string }>,
+				): void;
+			},
+		): { run(audio: unknown): Promise<"done">; cancel(): void };
+	};
+	internals.eventRuntime = opts.runtime;
+	internals.attributionPipeline = {
+		async attribute() {
+			if (opts.attributionGate) await opts.attributionGate;
+			return attributionOutput(opts.attributionEmbedding);
+		},
+	};
+	internals.buildPipeline = (_runner, _config, events) => ({
+		async run() {
+			if (!opts.skipAsr) events?.onAsrComplete?.(opts.asrTokens);
+			return "done";
+		},
+		cancel() {},
+	});
+	return bridge;
+}
+
+const TEXT_RUNNER = {} as MtpTextRunner;
+const AUDIO = { pcm: new Float32Array(16_000), sampleRate: 16_000 };
+const CONFIG = { maxDraftTokens: 4 };
+
+describe("EngineVoiceBridge runVoiceTurn — transcript join (#8786)", () => {
+	let bundleRoot: string;
+
+	beforeEach(() => {
+		bundleRoot = mkdtempSync(path.join(tmpdir(), "eliza-transcript-join-"));
+		writePresetBundle(bundleRoot);
+	});
+
+	afterEach(() => {
+		rmSync(bundleRoot, { recursive: true, force: true });
+	});
+
+	it("rides the turn's ASR transcript on VOICE_TURN_OBSERVED (not '')", async () => {
+		const { runtime, observed } = captureRuntime();
+		const bridge = bridgeWithJoin({
+			bundleRoot,
+			runtime,
+			asrTokens: [
+				{ index: 0, text: "I'm " },
+				{ index: 1, text: "Jill" },
+			],
+		});
+		await bridge.arm();
+
+		await bridge.runVoiceTurn(AUDIO, TEXT_RUNNER, CONFIG);
+		const payload = await observed;
+
+		// The whole point of #8786: the merge engine needs the words, not just
+		// the speaker. Previously this was hardcoded "".
+		expect(payload.text).toBe("I'm Jill");
+	});
+
+	it("joins even when attribution resolves before ASR completes", async () => {
+		// Force the attribution to resolve first; the `.then` must still await the
+		// transcript (resolved later, inside the pipeline run) rather than emit "".
+		let openGate: () => void = () => {};
+		const attributionGate = new Promise<void>((r) => {
+			openGate = r;
+		});
+		const { runtime, observed } = captureRuntime();
+		const bridge = bridgeWithJoin({
+			bundleRoot,
+			runtime,
+			asrTokens: [{ index: 0, text: "hello there" }],
+			attributionGate,
+		});
+		await bridge.arm();
+		// Let attribution resolve immediately on the next microtask.
+		openGate();
+
+		await bridge.runVoiceTurn(AUDIO, TEXT_RUNNER, CONFIG);
+		const payload = await observed;
+		expect(payload.text).toBe("hello there");
+	});
+
+	it("emits with text='' for a turn whose ASR never completes (no hang)", async () => {
+		const { runtime, observed } = captureRuntime();
+		const bridge = bridgeWithJoin({
+			bundleRoot,
+			runtime,
+			asrTokens: [{ index: 0, text: "unused" }],
+			skipAsr: true,
+		});
+		await bridge.arm();
+
+		await bridge.runVoiceTurn(AUDIO, TEXT_RUNNER, CONFIG);
+		// The pipeline `finally` settles the transcript promise, so attribution
+		// resolves (with "") rather than hanging the await forever.
+		const payload = await observed;
+		expect(payload.text).toBe("");
+	});
+
+	it("folds live self-voice similarity into the emitted turn signal", async () => {
+		const { runtime, observed } = captureRuntime();
+		const attributionEmbedding = unitEmbedding();
+		const bridge = bridgeWithJoin({
+			bundleRoot,
+			runtime,
+			asrTokens: [{ index: 0, text: "hey eliza" }],
+			attributionEmbedding,
+		});
+		const internals = bridge as unknown as {
+			scheduler: { bargeIn: { setAgentSpeaking(speaking: boolean): void } };
+			selfVoiceImprint: {
+				similarity(embedding: Float32Array): Promise<number | null>;
+			};
+		};
+		internals.scheduler.bargeIn.setAgentSpeaking(true);
+		internals.selfVoiceImprint = {
+			async similarity(embedding) {
+				expect(embedding).toBe(attributionEmbedding);
+				return 0.91;
+			},
+		};
+		let resolveAttribution: (output: VoiceAttributionOutput) => void = () => {};
+		const attributed = new Promise<VoiceAttributionOutput>((resolve) => {
+			resolveAttribution = resolve;
+		});
+		await bridge.arm();
+
+		await bridge.runVoiceTurn(AUDIO, TEXT_RUNNER, CONFIG, {
+			onAttribution(output) {
+				resolveAttribution(output);
+			},
+		});
+		await observed;
+		const attributedOutput = await attributed;
+
+		const signal = attributedOutput.turn.metadata.voiceTurnSignal as
+			| {
+					agentShouldSpeak: boolean | null;
+					nextSpeaker: string;
+					metadata?: { provenance?: string; selfVoiceSimilarity?: number };
+			  }
+			| undefined;
+		expect(signal?.agentShouldSpeak).toBe(false);
+		expect(signal?.nextSpeaker).toBe("user");
+		expect(signal?.metadata?.provenance).toBe("voice-bridge+self-voice");
+		expect(signal?.metadata?.selfVoiceSimilarity).toBeCloseTo(0.91);
+	});
+});