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

package/src/services/voice/voice-scenario.test.ts

@@ -0,0 +1,159 @@
+// Coverage for the pure VoiceScenario validator + turn helpers (#9147). The
+// validator gates every test-matrix scenario before the corpus build, so its
+// id/participant/turn/agent/environment checks are worth pinning directly.
+
+import { describe, expect, it } from "vitest";
+import {
+	resolveTurnEnvironment,
+	turnReferenceTranscript,
+	turnSpeakerLabel,
+	type VoiceEnvironment,
+	type VoiceScenario,
+	validateVoiceScenario,
+} from "./voice-scenario";
+
+function validScenario(): VoiceScenario {
+	return {
+		id: "s1",
+		classes: ["diarization"],
+		participants: [{ label: "alice" }, { label: "bob" }],
+		turns: [
+			{ speaker: "alice", text: "hello", expectRespond: true },
+			{ speaker: "bob", text: "hi there", expectRespond: false },
+		],
+	};
+}
+
+describe("validateVoiceScenario", () => {
+	it("accepts a well-formed scenario", () => {
+		expect(validateVoiceScenario(validScenario())).toEqual({
+			valid: true,
+			errors: [],
+		});
+	});
+
+	it("requires id, a non-empty classes array, participants, and turns", () => {
+		const r = validateVoiceScenario({
+			id: "  ",
+			classes: [],
+			participants: [],
+			turns: [],
+		});
+		expect(r.valid).toBe(false);
+		expect(r.errors).toContain("scenario.id is required");
+		expect(r.errors).toContain("scenario.classes must be a non-empty array");
+		expect(r.errors).toContain("scenario.participants must be non-empty");
+		expect(r.errors).toContain("scenario.turns must be a non-empty array");
+	});
+
+	it("flags duplicate participant labels", () => {
+		const s = validScenario();
+		s.participants = [{ label: "alice" }, { label: "alice" }];
+		expect(validateVoiceScenario(s).errors).toContain(
+			"duplicate participant label: alice",
+		);
+	});
+
+	it("flags a turn whose speaker is not a participant", () => {
+		const s = validScenario();
+		s.turns = [{ speaker: "carol", text: "hi", expectRespond: true }];
+		expect(validateVoiceScenario(s).errors).toContain(
+			'turn[0].speaker "carol" is not a participant',
+		);
+	});
+
+	it("requires each turn to carry text or audioRef and a boolean expectRespond", () => {
+		const s = validScenario();
+		// @ts-expect-error — exercising the runtime guard for a missing expectRespond
+		s.turns = [{ speaker: "alice" }];
+		const errors = validateVoiceScenario(s).errors;
+		expect(errors).toContain("turn[0] must have either text or audioRef");
+		expect(errors).toContain("turn[0].expectRespond must be a boolean");
+	});
+
+	it("flags an agent label that is not a participant", () => {
+		const s = validScenario();
+		s.agents = ["ghost"];
+		expect(validateVoiceScenario(s).errors).toContain(
+			'agent "ghost" is not a participant',
+		);
+	});
+
+	it("validates acoustic environment ranges (reverb in [0,1], far-field >= 0)", () => {
+		const s = validScenario();
+		s.environment = { reverb: 2, farFieldDb: -3 } as VoiceEnvironment;
+		const errors = validateVoiceScenario(s).errors;
+		expect(errors).toContain("scenario.environment.reverb must be in [0, 1]");
+		expect(errors).toContain(
+			"scenario.environment.farFieldDb must be a non-negative dB attenuation",
+		);
+	});
+
+	it("collects every error at once instead of throwing on the first", () => {
+		const r = validateVoiceScenario({
+			id: "",
+			classes: [],
+			participants: [{ label: "alice" }],
+			turns: [{ speaker: "nope", text: "x", expectRespond: true }],
+		});
+		expect(r.valid).toBe(false);
+		expect(r.errors.length).toBeGreaterThanOrEqual(3);
+	});
+});
+
+describe("turn helpers", () => {
+	it("resolveTurnEnvironment merges turn over scenario (turn wins)", () => {
+		const s = validScenario();
+		s.environment = { reverb: 0.2, noiseSnrDb: 10 } as VoiceEnvironment;
+		const turn = {
+			speaker: "alice",
+			text: "hi",
+			expectRespond: true,
+			environment: { reverb: 0.8 } as VoiceEnvironment,
+		};
+		expect(resolveTurnEnvironment(s, turn)).toEqual({
+			reverb: 0.8,
+			noiseSnrDb: 10,
+		});
+		// Both absent → undefined.
+		expect(
+			resolveTurnEnvironment(validScenario(), {
+				speaker: "alice",
+				text: "hi",
+				expectRespond: true,
+			}),
+		).toBeUndefined();
+	});
+
+	it("turnReferenceTranscript prefers the explicit override, else the text", () => {
+		expect(
+			turnReferenceTranscript({
+				speaker: "a",
+				text: "spoken",
+				expectedTranscript: "  override  ",
+				expectRespond: true,
+			}),
+		).toBe("override");
+		expect(
+			turnReferenceTranscript({
+				speaker: "a",
+				text: "  just text  ",
+				expectRespond: true,
+			}),
+		).toBe("just text");
+	});
+
+	it("turnSpeakerLabel prefers the explicit diarization label, else the speaker", () => {
+		expect(
+			turnSpeakerLabel({
+				speaker: "alice",
+				text: "x",
+				expectedSpeakerLabel: "SPEAKER_01",
+				expectRespond: true,
+			}),
+		).toBe("SPEAKER_01");
+		expect(
+			turnSpeakerLabel({ speaker: "alice", text: "x", expectRespond: true }),
+		).toBe("alice");
+	});
+});

package/src/services/voice/voice-scenario.ts

@@ -13,6 +13,17 @@
  * import from the runner, the player, and tests alike.
  */
 
+import type { AugmentationSpec } from "./corpus-augment";
+
+/**
+ * Acoustic environment for a scenario or a single turn: room noise, reverb,
+ * far-field attenuation, low-quality line, background talkers. Drives the
+ * corpus generator's degradation chain ({@link AugmentationSpec}). A turn's
+ * environment is merged over the scenario's, so a scenario can declare a noisy
+ * room once and an individual turn can override it (e.g. one talker steps away).
+ */
+export type VoiceEnvironment = AugmentationSpec;
+
 /** A named voice/entity participating in the scenario. */
 export interface VoiceScenarioParticipant {
 	/** Stable label used in turns + diarization ground truth (e.g. "alice"). */
@@ -39,12 +50,33 @@ export interface VoiceScenarioTurn {
 	pausesMs?: number[];
 	/** Ground truth: SHOULD the agent respond to this turn? */
 	expectRespond: boolean;
+	/** Ground truth: is this segment a real end-of-turn boundary? */
+	expectEndOfTurn?: boolean;
 	/** Expected ASR transcript (for WER scoring); defaults to `text`. */
 	expectedTranscript?: string;
 	/** Expected diarization label (defaults to `speaker`). */
 	expectedSpeakerLabel?: string;
 	/** Expected entity inferred/recognized from this turn (name extraction). */
 	expectedEntity?: string;
+	/**
+	 * Acoustic degradation for THIS turn, merged over the scenario environment.
+	 * Use it to model one talker stepping away (far-field) or onto a bad line
+	 * while the rest of the room stays clean.
+	 */
+	environment?: VoiceEnvironment;
+	/**
+	 * Ground truth for echo/self-voice rejection: this "turn" is the agent's own
+	 * TTS bleeding back into the mic (not a real user turn). The respond gate
+	 * MUST suppress it. Always implies `expectRespond: false`.
+	 */
+	isAgentEcho?: boolean;
+	/**
+	 * The agent's spoken reply to THIS turn (when it responds). The real-decision
+	 * logic adapter uses it as the "recent agent reply" the echo gate compares a
+	 * following `isAgentEcho` turn against — so echo rejection is tested against a
+	 * genuine reply string, not a circular self-reference.
+	 */
+	agentReplyText?: string;
 }
 
 /** Scenario-level pass/fail thresholds the benchmark layer enforces. */
@@ -62,6 +94,10 @@ export interface VoiceScenarioAssertions {
 	/** Latency budgets (ms) — first-audio / time-to-first-token, etc. */
 	maxFirstAudioMs?: number;
 	maxTtftMs?: number;
+	/** Min echo/self-voice rejection rate (agent-echo turns correctly suppressed). */
+	minEchoRejectionRate?: number;
+	/** Min owner-vs-intruder accuracy for security scenarios. */
+	minOwnerAccuracy?: number;
 }
 
 export type VoiceScenarioClass =
@@ -75,7 +111,15 @@ export type VoiceScenarioClass =
 	| "eot"
 	| "transcription-mode"
 	| "multi-agent-room"
-	| "long-form-monologue";
+	| "long-form-monologue"
+	// Robustness: degraded acoustics (noise / reverb / far-field / low-quality).
+	| "robustness"
+	// Self-echo: the agent's own TTS must not be treated as a user turn.
+	| "echo-rejection"
+	// Security: owner vs. intruder / non-owner voice gating.
+	| "owner-security"
+	// Two voices overlapping / interrupting each other.
+	| "overlapping-speech";
 
 export interface VoiceScenario {
 	/** Stable id (also the corpus subdirectory name). */
@@ -89,6 +133,15 @@ export interface VoiceScenario {
 	assertions?: VoiceScenarioAssertions;
 	/** Agent labels present in a multi-agent room (subset of participants). */
 	agents?: string[];
+	/** Scenario-wide acoustic environment; per-turn `environment` overrides it. */
+	environment?: VoiceEnvironment;
+	/**
+	 * Entity ids the agent answers WITHOUT a wake word (owner + enrolled
+	 * speakers). The respond gate suppresses a confident speaker NOT in this set
+	 * as a bystander. Defaults (in the runner) to every participant that has an
+	 * `entityId`; set it explicitly to mark some bound voices as strangers.
+	 */
+	knownSpeakerEntityIds?: string[];
 }
 
 export interface VoiceScenarioValidation {
@@ -102,17 +155,37 @@ export interface VoiceScenarioValidation {
  * exist as participants. Returns all errors (does not throw) so a corpus build
  * can report every problem at once.
  */
+/** True when a value is not a non-empty string (so `.trim()` is never called on a non-string). */
+function isBlank(v: unknown): boolean {
+	return typeof v !== "string" || v.trim().length === 0;
+}
+
 export function validateVoiceScenario(
 	scenario: VoiceScenario,
 ): VoiceScenarioValidation {
 	const errors: string[] = [];
-	if (!scenario.id?.trim()) errors.push("scenario.id is required");
+	// A malformed/empty scenario file can deserialize to a non-object; guard the
+	// boundary so the validator reports an error instead of throwing.
+	if (!scenario || typeof scenario !== "object" || Array.isArray(scenario)) {
+		return { valid: false, errors: ["scenario must be an object"] };
+	}
+	if (isBlank(scenario.id)) errors.push("scenario.id is required");
 	if (!Array.isArray(scenario.classes) || scenario.classes.length === 0) {
 		errors.push("scenario.classes must be a non-empty array");
 	}
+	// Iterate defensively: a malformed scenario may carry non-array fields.
+	const participants = Array.isArray(scenario.participants)
+		? scenario.participants
+		: [];
+	const turns = Array.isArray(scenario.turns) ? scenario.turns : [];
+	const agents = Array.isArray(scenario.agents) ? scenario.agents : [];
 	const labels = new Set<string>();
-	for (const p of scenario.participants ?? []) {
-		if (!p.label?.trim()) {
+	for (const p of participants) {
+		if (!p || typeof p !== "object") {
+			errors.push("participant must be an object");
+			continue;
+		}
+		if (isBlank(p.label)) {
 			errors.push("participant.label is required");
 			continue;
 		}
@@ -124,25 +197,78 @@ export function validateVoiceScenario(
 	if (!Array.isArray(scenario.turns) || scenario.turns.length === 0) {
 		errors.push("scenario.turns must be a non-empty array");
 	}
-	scenario.turns?.forEach((t, i) => {
+	turns.forEach((t, i) => {
+		if (!t || typeof t !== "object") {
+			errors.push(`turn[${i}] must be an object`);
+			return;
+		}
 		if (!labels.has(t.speaker)) {
 			errors.push(`turn[${i}].speaker "${t.speaker}" is not a participant`);
 		}
-		if (!t.text?.trim() && !t.audioRef?.trim()) {
+		if (isBlank(t.text) && isBlank(t.audioRef)) {
 			errors.push(`turn[${i}] must have either text or audioRef`);
 		}
 		if (typeof t.expectRespond !== "boolean") {
 			errors.push(`turn[${i}].expectRespond must be a boolean`);
 		}
+		if (
+			t.expectEndOfTurn !== undefined &&
+			typeof t.expectEndOfTurn !== "boolean"
+		) {
+			errors.push(`turn[${i}].expectEndOfTurn must be a boolean`);
+		}
 	});
-	for (const agent of scenario.agents ?? []) {
+	for (const agent of agents) {
 		if (!labels.has(agent)) {
 			errors.push(`agent "${agent}" is not a participant`);
 		}
 	}
+	validateEnvironment(scenario.environment, "scenario.environment", errors);
+	turns.forEach((t, i) => {
+		validateEnvironment(t?.environment, `turn[${i}].environment`, errors);
+	});
 	return { valid: errors.length === 0, errors };
 }
 
+/** Validate an acoustic environment's ranges (pure; appends to `errors`). */
+function validateEnvironment(
+	env: VoiceEnvironment | undefined,
+	where: string,
+	errors: string[],
+): void {
+	if (!env) return;
+	if (
+		env.reverb !== undefined &&
+		(!Number.isFinite(env.reverb) || env.reverb < 0 || env.reverb > 1)
+	) {
+		errors.push(`${where}.reverb must be in [0, 1]`);
+	}
+	if (env.noiseSnrDb !== undefined && !Number.isFinite(env.noiseSnrDb)) {
+		errors.push(`${where}.noiseSnrDb must be a finite number`);
+	}
+	if (
+		env.farFieldDb !== undefined &&
+		(!Number.isFinite(env.farFieldDb) || env.farFieldDb < 0)
+	) {
+		errors.push(`${where}.farFieldDb must be a non-negative dB attenuation`);
+	}
+	if (
+		env.backgroundTalkersDb !== undefined &&
+		!Number.isFinite(env.backgroundTalkersDb)
+	) {
+		errors.push(`${where}.backgroundTalkersDb must be a finite number`);
+	}
+}
+
+/** Merge a turn's environment over the scenario's (turn wins, field by field). */
+export function resolveTurnEnvironment(
+	scenario: VoiceScenario,
+	turn: VoiceScenarioTurn,
+): VoiceEnvironment | undefined {
+	if (!scenario.environment && !turn.environment) return undefined;
+	return { ...scenario.environment, ...turn.environment };
+}
+
 /** The expected ASR reference for a turn (explicit override or its text). */
 export function turnReferenceTranscript(turn: VoiceScenarioTurn): string {
 	return (turn.expectedTranscript ?? turn.text ?? "").trim();

package/src/services/voice/voice-scenario.turn-helpers.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Unit coverage for the voice-scenario per-turn resolvers (#9147 voice).
+ *
+ * resolveTurnEnvironment / turnReferenceTranscript / turnSpeakerLabel are the
+ * pure helpers that resolve a scenario turn's augmentation environment, its
+ * reference transcript, and its expected speaker label — the inputs the
+ * multi-speaker / noise-music / self-rejection scenario harness scores against.
+ * They were untested. No GGUF / audio.
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+	resolveTurnEnvironment,
+	turnReferenceTranscript,
+	turnSpeakerLabel,
+	type VoiceScenario,
+	type VoiceScenarioTurn,
+} from "./voice-scenario";
+
+const turn = (over: Partial<VoiceScenarioTurn>): VoiceScenarioTurn =>
+	({ speaker: "alice", text: "hi", ...over }) as VoiceScenarioTurn;
+const scenario = (over: Partial<VoiceScenario>): VoiceScenario =>
+	({ ...over }) as VoiceScenario;
+
+describe("resolveTurnEnvironment", () => {
+	it("returns undefined when neither scenario nor turn set an environment", () => {
+		expect(resolveTurnEnvironment(scenario({}), turn({}))).toBeUndefined();
+	});
+
+	it("merges scenario + turn environment with the turn winning", () => {
+		const merged = resolveTurnEnvironment(
+			scenario({ environment: { noiseSnrDb: 20, reverb: 0.3 } }),
+			turn({ environment: { noiseSnrDb: 5 } }),
+		);
+		expect(merged).toEqual({ noiseSnrDb: 5, reverb: 0.3 });
+	});
+
+	it("uses the scenario environment alone when the turn has none", () => {
+		expect(
+			resolveTurnEnvironment(
+				scenario({ environment: { noiseSnrDb: 12 } }),
+				turn({}),
+			),
+		).toEqual({ noiseSnrDb: 12 });
+	});
+});
+
+describe("turnReferenceTranscript", () => {
+	it("prefers expectedTranscript, then text, then empty — trimmed", () => {
+		expect(
+			turnReferenceTranscript(turn({ expectedTranscript: "  hello  " })),
+		).toBe("hello");
+		expect(
+			turnReferenceTranscript(
+				turn({ expectedTranscript: undefined, text: "  hey " }),
+			),
+		).toBe("hey");
+		expect(
+			turnReferenceTranscript(
+				turn({ expectedTranscript: undefined, text: undefined }),
+			),
+		).toBe("");
+	});
+});
+
+describe("turnSpeakerLabel", () => {
+	it("prefers expectedSpeakerLabel, falls back to speaker", () => {
+		expect(
+			turnSpeakerLabel(turn({ speaker: "bob", expectedSpeakerLabel: "Bob" })),
+		).toBe("Bob");
+		expect(
+			turnSpeakerLabel(
+				turn({ speaker: "carol", expectedSpeakerLabel: undefined }),
+			),
+		).toBe("carol");
+	});
+});

package/src/services/voice/voice-workbench-report.ts

@@ -13,11 +13,30 @@
  */
 
 import type { VoiceE2eCaseResult } from "./e2e-harness";
+import { percentile, round4 } from "./metric-math";
 import type { VoiceScenarioClass } from "./voice-scenario";
 
 export type VoiceWorkbenchStatus = "ran" | "skipped";
 export type VoiceWorkbenchVerdict = "pass" | "fail" | "skipped";
 
+/**
+ * A `.wav` artifact written for one scenario run when a capture sink is active.
+ * `path` is RELATIVE to the run dir the headless runner was told to write under,
+ * so the scenario run viewer (served from that dir) can reference it directly.
+ */
+export interface VoiceAudioArtifact {
+	/** Turn index this artifact belongs to; the full corpus uses turn 0. */
+	turnIndex: number;
+	/** `generated` = the full synthesized corpus; `consumed` = a per-turn slice. */
+	kind: "generated" | "consumed";
+	/** Path to the `.wav`, relative to the run dir (forward-slash separated). */
+	path: string;
+	sampleRate: number;
+	durationMs?: number;
+	/** Diarization ground-truth speaker label for a consumed per-turn slice. */
+	speakerLabel?: string;
+}
+
 /** One scenario's outcome in a workbench run. */
 export interface VoiceWorkbenchScenarioRun {
 	scenarioId: string;
@@ -28,6 +47,8 @@ export interface VoiceWorkbenchScenarioRun {
 	cases: VoiceE2eCaseResult[];
 	/** Why the scenario was skipped (artifact/backend absence), if it was. */
 	skipReason?: string;
+	/** `.wav` artifacts written when a capture sink was active (else absent). */
+	audioArtifacts?: VoiceAudioArtifact[];
 }
 
 export interface VoiceWorkbenchScenarioReport {
@@ -64,6 +85,12 @@ export interface VoiceWorkbenchMetrics {
 	voiceEntityMatchRate: MetricRollup;
 	/** First-audio latency ms (`worst` = max). */
 	firstAudioMs: MetricRollup;
+	/** Self-echo rejection rate (`worst` = min). */
+	echoRejectionRate: MetricRollup;
+	/** Owner-vs-intruder accuracy (`worst` = min). */
+	ownerAccuracy: MetricRollup;
+	/** Impostor-accept rate (`worst` = max) — non-owner accepted as owner. */
+	impostorAcceptRate: MetricRollup;
 }
 
 export interface VoiceWorkbenchReport {
@@ -82,23 +109,6 @@ function mean(values: ReadonlyArray<number>): number | null {
 	return round4(sum / values.length);
 }
 
-function round4(n: number): number {
-	return Math.round(n * 1e4) / 1e4;
-}
-
-function round1(n: number): number {
-	return Math.round(n * 10) / 10;
-}
-
-/** Nearest-rank percentile over a sample (null when empty). */
-function percentile(values: ReadonlyArray<number>, p: number): number | null {
-	const finite = values.filter((v) => Number.isFinite(v));
-	if (finite.length === 0) return null;
-	const sorted = [...finite].sort((a, b) => a - b);
-	const rank = Math.ceil((p / 100) * sorted.length);
-	return round1(sorted[Math.min(sorted.length - 1, Math.max(0, rank - 1))]);
-}
-
 function rollupMax(values: ReadonlyArray<number>): MetricRollup {
 	return {
 		count: values.length,
@@ -154,6 +164,9 @@ export function buildVoiceWorkbenchReport(
 	const entityF1: number[] = [];
 	const voiceEntityMatchRate: number[] = [];
 	const firstAudioMs: number[] = [];
+	const echoRejectionRate: number[] = [];
+	const ownerAccuracy: number[] = [];
+	const impostorAcceptRate: number[] = [];
 
 	for (const c of allCases) {
 		switch (c.kind) {
@@ -180,6 +193,13 @@ export function buildVoiceWorkbenchReport(
 			case "first-response-latency":
 				firstAudioMs.push(c.firstAudioMs);
 				break;
+			case "echo-rejection":
+				echoRejectionRate.push(c.rejectionRate);
+				break;
+			case "owner-security":
+				ownerAccuracy.push(c.accuracy);
+				impostorAcceptRate.push(c.impostorAcceptRate);
+				break;
 			default:
 				break;
 		}
@@ -211,6 +231,9 @@ export function buildVoiceWorkbenchReport(
 			entityF1: rollupMin(entityF1),
 			voiceEntityMatchRate: rollupMin(voiceEntityMatchRate),
 			firstAudioMs: rollupMax(firstAudioMs),
+			echoRejectionRate: rollupMin(echoRejectionRate),
+			ownerAccuracy: rollupMin(ownerAccuracy),
+			impostorAcceptRate: rollupMax(impostorAcceptRate),
 		},
 	};
 }
@@ -242,6 +265,9 @@ export function formatVoiceWorkbenchMarkdown(
 		`| Entity F1 | ${fmt(m.entityF1.mean)} | ${fmt(m.entityF1.worst)} | ${m.entityF1.count} |`,
 		`| Voice→entity match | ${fmt(m.voiceEntityMatchRate.mean)} | ${fmt(m.voiceEntityMatchRate.worst)} | ${m.voiceEntityMatchRate.count} |`,
 		`| First-audio (ms) | ${fmt(m.firstAudioMs.mean)} | ${fmt(m.firstAudioMs.worst)} | ${m.firstAudioMs.count} |`,
+		`| Echo rejection rate | ${fmt(m.echoRejectionRate.mean)} | ${fmt(m.echoRejectionRate.worst)} | ${m.echoRejectionRate.count} |`,
+		`| Owner accuracy | ${fmt(m.ownerAccuracy.mean)} | ${fmt(m.ownerAccuracy.worst)} | ${m.ownerAccuracy.count} |`,
+		`| Impostor-accept rate | ${fmt(m.impostorAcceptRate.mean)} | ${fmt(m.impostorAcceptRate.worst)} | ${m.impostorAcceptRate.count} |`,
 		"",
 		"## Scenarios",
 		"",
@@ -295,6 +321,11 @@ export function regressionsAgainstBaseline(
 			current.metrics.firstAudioMs.mean,
 			baseline.metrics.firstAudioMs.mean,
 		],
+		[
+			"impostorAcceptRate",
+			current.metrics.impostorAcceptRate.mean,
+			baseline.metrics.impostorAcceptRate.mean,
+		],
 	];
 	const higherBetter: Array<[string, number | null, number | null]> = [
 		[
@@ -308,6 +339,16 @@ export function regressionsAgainstBaseline(
 			current.metrics.voiceEntityMatchRate.mean,
 			baseline.metrics.voiceEntityMatchRate.mean,
 		],
+		[
+			"echoRejectionRate",
+			current.metrics.echoRejectionRate.mean,
+			baseline.metrics.echoRejectionRate.mean,
+		],
+		[
+			"ownerAccuracy",
+			current.metrics.ownerAccuracy.mean,
+			baseline.metrics.ownerAccuracy.mean,
+		],
 	];
 	const out: MetricRegression[] = [];
 	for (const [metric, cur, base] of lowerBetter) {

package/src/services/voice/wake-word-ggml.ts

@@ -2,12 +2,15 @@
  * Wake-word detection — native runtime binding.
  *
  * Loads the standalone `packages/native/plugins/wakeword-cpp/`
- * library directly via `bun:ffi` and exposes the same `WakeWordModel`
- * interface as the previous `onnxruntime-node`-backed implementation
- * in `./wake-word.ts`, so the voice lifecycle can swap the two without
- * changing anything upstream.
+ * library directly via `bun:ffi` and exposes the `WakeWordModel`
+ * interface as `OpenWakeWordGgmlModel`. The sibling `./wake-word.ts`
+ * is the fused-`libelizainference` path (`GgmlWakeWordModel`, the
+ * `eliza_inference_wakeword_*` FFI surface) and selects between the two
+ * native backends; both implement the same interface so the voice
+ * lifecycle can swap them without changing anything upstream. There is
+ * NO ONNX path on either — `onnxruntime-node` was removed.
  *
- * Phase 2 status — this binding is now the default when the
+ * This binding is the standalone-library backend, used when the
  * `libwakeword.{so,dylib,dll}` shared library and three converted
  * GGUFs are present. The C runtime is a pure-fp32 reference
  * implementation of the openWakeWord three-stage pipeline (melspec
@@ -16,10 +19,6 @@
  * upstream openWakeWord ONNX graphs is gated by
  * `packages/native/plugins/wakeword-cpp/test/wakeword_parity_test.py`.
  *
- * The ONNX path in `./wake-word.ts` stays as the fallback while the
- * native binding shakes out. Once the migration is complete the ONNX
- * path can be removed alongside the `onnxruntime-node` dependency.
- *
  * Three GGUFs back one session, mirroring openWakeWord's three ONNX
  * graphs (the C library is the single source of truth on shapes —
  * see `packages/native/plugins/wakeword-cpp/include/wakeword/wakeword.h`):
@@ -112,11 +111,11 @@ interface BoundLibrary {
 
 /** Minimal shape of the bun:ffi module we use here. */
 interface BunFfiModule {
-	dlopen(
+	dlopen<TSymbols>(
 		path: string,
 		def: Record<string, { args: number[]; returns: number }>,
 	): {
-		symbols: Record<string, (...args: unknown[]) => unknown>;
+		symbols: TSymbols;
 		close(): void;
 	};
 	ptr(value: ArrayBufferView): unknown;
@@ -169,7 +168,7 @@ function loadLibrary(libraryPath: string): BoundLibrary {
 	}
 	const bunFfi = loadBunFfiModule();
 	const T = bunFfi.FFIType;
-	const lib = bunFfi.dlopen(libraryPath, {
+	const lib = bunFfi.dlopen<WakeWordBindings>(libraryPath, {
 		wakeword_open: {
 			args: [T.ptr, T.ptr, T.ptr, T.ptr],
 			returns: T.i32,
@@ -192,7 +191,7 @@ function loadLibrary(libraryPath: string): BoundLibrary {
 		},
 	});
 	return {
-		bindings: lib.symbols as unknown as WakeWordBindings,
+		bindings: lib.symbols,
 		close: () => lib.close(),
 		libraryPath,
 		ptr: (v: ArrayBufferView) => bunFfi.ptr(v),