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

package/src/services/voice/self-voice-imprint.ts

@@ -0,0 +1,102 @@
+import { averageEmbeddings, type SpeakerEncoder } from "./speaker/encoder";
+import {
+	SPEAKER_GGML_MIN_SAMPLES,
+	SPEAKER_GGML_SAMPLE_RATE,
+} from "./speaker/encoder-ggml";
+import { cosineSimilarity } from "./speaker-imprint";
+import { resampleLinear } from "./transcriber";
+
+export interface AgentSelfVoiceImprintOptions {
+	encoder: SpeakerEncoder;
+	/** Minimum 16 kHz samples before one self-voice embedding is encoded. */
+	minSamples?: number;
+	/** Maximum 16 kHz samples to encode for one centroid update. */
+	maxSamples?: number;
+	/** Number of recent agent-TTS embeddings retained in the centroid. */
+	maxEmbeddings?: number;
+}
+
+function concatSegments(
+	segments: readonly Float32Array[],
+	totalSamples: number,
+): Float32Array {
+	const out = new Float32Array(totalSamples);
+	let offset = 0;
+	for (const segment of segments) {
+		out.set(segment, offset);
+		offset += segment.length;
+	}
+	return out;
+}
+
+/**
+ * Maintains a bounded centroid of the agent's own synthesized voice.
+ *
+ * The live mic path already gets WeSpeaker embeddings from attribution. This
+ * helper observes the PCM that the scheduler hands to audio output, embeds that
+ * actual TTS audio, and exposes cosine similarity against future mic turns.
+ */
+export class AgentSelfVoiceImprint {
+	private readonly encoder: SpeakerEncoder;
+	private readonly minSamples: number;
+	private readonly maxSamples: number;
+	private readonly maxEmbeddings: number;
+	private readonly pendingSegments: Float32Array[] = [];
+	private pendingSamples = 0;
+	private readonly embeddings: Float32Array[] = [];
+	private centroid: Float32Array | null = null;
+	private queue: Promise<void> = Promise.resolve();
+
+	constructor(options: AgentSelfVoiceImprintOptions) {
+		this.encoder = options.encoder;
+		this.minSamples = options.minSamples ?? SPEAKER_GGML_MIN_SAMPLES;
+		this.maxSamples = options.maxSamples ?? SPEAKER_GGML_SAMPLE_RATE * 6;
+		this.maxEmbeddings = Math.max(1, options.maxEmbeddings ?? 8);
+	}
+
+	observeAudio(pcm: Float32Array, sampleRate: number): Promise<void> {
+		const work = this.queue.then(() =>
+			this.observeAudioLocked(pcm, sampleRate),
+		);
+		this.queue = work.catch(() => {});
+		return work;
+	}
+
+	async similarity(embedding: Float32Array): Promise<number | null> {
+		await this.queue;
+		if (!this.centroid) return null;
+		if (embedding.length !== this.centroid.length) return null;
+		return cosineSimilarity(embedding, this.centroid);
+	}
+
+	private async observeAudioLocked(
+		pcm: Float32Array,
+		sampleRate: number,
+	): Promise<void> {
+		if (pcm.length === 0 || sampleRate <= 0) return;
+		const speakerPcm =
+			sampleRate === SPEAKER_GGML_SAMPLE_RATE
+				? new Float32Array(pcm)
+				: resampleLinear(pcm, sampleRate, SPEAKER_GGML_SAMPLE_RATE);
+		if (speakerPcm.length === 0) return;
+
+		this.pendingSegments.push(speakerPcm);
+		this.pendingSamples += speakerPcm.length;
+		if (this.pendingSamples < this.minSamples) return;
+
+		const toEncode = concatSegments(this.pendingSegments, this.pendingSamples);
+		this.pendingSegments.length = 0;
+		this.pendingSamples = 0;
+
+		const window =
+			toEncode.length > this.maxSamples
+				? toEncode.subarray(0, this.maxSamples)
+				: toEncode;
+		const embedding = await this.encoder.encode(window);
+		this.embeddings.push(embedding);
+		while (this.embeddings.length > this.maxEmbeddings) {
+			this.embeddings.shift();
+		}
+		this.centroid = averageEmbeddings(this.embeddings);
+	}
+}

package/src/services/voice/shared-resources.ts

@@ -227,11 +227,34 @@ export class SharedResourceRegistry {
 		RegistryEntry<RefCountedResource>
 	>();
 	private readonly log?: Logger;
+	/**
+	 * When a higher-level component (the `MemoryArbiter`) owns the eviction
+	 * decision for this registry, it claims ownership here so the simpler
+	 * `MemoryMonitor` poll defers instead of evicting in parallel — a single
+	 * eviction decision point, no double-eviction on one pressure event
+	 * (#8809 AC#2). Null = no external owner, the monitor evicts itself.
+	 */
+	private evictionOwner: string | null = null;
 
 	constructor(opts: { logger?: Logger } = {}) {
 		this.log = opts.logger;
 	}
 
+	/** Claim the single eviction-decision ownership for this registry. */
+	claimEvictionOwnership(owner: string): void {
+		this.evictionOwner = owner;
+	}
+
+	/** Release ownership (only the current owner may release it). */
+	releaseEvictionOwnership(owner: string): void {
+		if (this.evictionOwner === owner) this.evictionOwner = null;
+	}
+
+	/** True when an external component owns the eviction decision. */
+	hasExternalEvictionOwner(): boolean {
+		return this.evictionOwner !== null;
+	}
+
 	/**
 	 * Register a resource if absent, increment refcount otherwise. Returns
 	 * the canonical instance — callers MUST use the returned value, not the

package/src/services/voice/speaker/attribution-pipeline.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it } from "vitest";
+import {
+	VOICE_PROFILE_RECORD_SCHEMA_VERSION,
+	type VoiceProfileRecord,
+	type VoiceProfileStore,
+} from "../profile-store";
+import { VoiceAttributionPipeline } from "./attribution-pipeline";
+import type { Diarizer } from "./diarizer";
+import { PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID } from "./diarizer";
+import type { SpeakerEncoder } from "./encoder";
+
+describe("VoiceAttributionPipeline", () => {
+	it("does not double-count overlapping spans when choosing the primary local speaker", async () => {
+		const encoder: SpeakerEncoder & { windows: Float32Array[] } = {
+			embeddingDim: 2,
+			sampleRate: 16_000,
+			modelId: "test-speaker-encoder",
+			windows: [],
+			async encode(pcm) {
+				this.windows.push(pcm);
+				return new Float32Array([1, 0]);
+			},
+			async dispose() {},
+		};
+		const diarizer: Diarizer = {
+			modelId: PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID,
+			sampleRate: 16_000,
+			async diarizeWindow() {
+				return {
+					localSpeakerCount: 2,
+					speechMs: 2_500,
+					segments: [
+						{
+							startMs: 0,
+							endMs: 1_000,
+							localSpeakerId: 0,
+							confidence: 0.9,
+							hasOverlap: false,
+						},
+						{
+							startMs: 0,
+							endMs: 1_000,
+							localSpeakerId: 0,
+							confidence: 0.9,
+							hasOverlap: false,
+						},
+						{
+							startMs: 1_000,
+							endMs: 2_500,
+							localSpeakerId: 1,
+							confidence: 0.8,
+							hasOverlap: false,
+						},
+					],
+				};
+			},
+			async dispose() {},
+		};
+		const profileStore: Pick<
+			VoiceProfileStore,
+			"findBestMatch" | "createProfile" | "refine"
+		> = {
+			async findBestMatch() {
+				return null;
+			},
+			async createProfile(args): Promise<VoiceProfileRecord> {
+				return {
+					schemaVersion: VOICE_PROFILE_RECORD_SCHEMA_VERSION,
+					profileId: "profile-primary",
+					embeddingModel: args.embeddingModel,
+					embeddingDim: args.centroid.length,
+					centroid: Array.from(args.centroid),
+					variance: new Array(args.centroid.length).fill(0),
+					welfordM2: new Array(args.centroid.length).fill(0),
+					sampleCount: 1,
+					totalDurationMs: args.durationMs,
+					firstObservedAt: "2026-01-01T00:00:00.000Z",
+					lastObservedAt: "2026-01-01T00:00:00.000Z",
+					lastRefinedAt: "2026-01-01T00:00:00.000Z",
+					entityId: null,
+					imprintClusterId: "cluster-primary",
+					confidence: args.confidence,
+					consent: {
+						attributionAuthorized: false,
+						synthesisAuthorized: false,
+					},
+				};
+			},
+			async refine() {
+				return null;
+			},
+		};
+		const pipeline = new VoiceAttributionPipeline({
+			encoder,
+			diarizer,
+			profileStore: profileStore as VoiceProfileStore,
+		});
+
+		const output = await pipeline.attribute({
+			turnId: "turn-overlap-primary",
+			pcm: new Float32Array(16_000 * 3),
+		});
+
+		expect(encoder.windows).toHaveLength(1);
+		expect(encoder.windows[0]).toHaveLength(24_000);
+		expect(
+			output.segments.map((segment) => ({
+				localSpeakerId: segment.metadata?.localSpeakerId,
+				primary: segment.metadata?.primary,
+			})),
+		).toEqual([
+			{ localSpeakerId: 0, primary: false },
+			{ localSpeakerId: 0, primary: false },
+			{ localSpeakerId: 1, primary: true },
+		]);
+	});
+
+	it("uses overlap-marked diarizer spans when strict non-overlap spans are too short", async () => {
+		const encoder: SpeakerEncoder & { windows: Float32Array[] } = {
+			embeddingDim: 2,
+			sampleRate: 16_000,
+			modelId: "test-speaker-encoder",
+			windows: [],
+			async encode(pcm) {
+				this.windows.push(pcm);
+				return new Float32Array([1, 0]);
+			},
+			async dispose() {},
+		};
+		const diarizer: Diarizer = {
+			modelId: PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID,
+			sampleRate: 16_000,
+			async diarizeWindow() {
+				return {
+					localSpeakerCount: 3,
+					speechMs: 1_720,
+					segments: [
+						{
+							startMs: 0,
+							endMs: 20,
+							localSpeakerId: 0,
+							confidence: 0.5,
+							hasOverlap: false,
+						},
+						{
+							startMs: 0,
+							endMs: 1_000,
+							localSpeakerId: 1,
+							confidence: 0.5,
+							hasOverlap: true,
+						},
+						{
+							startMs: 500,
+							endMs: 1_500,
+							localSpeakerId: 1,
+							confidence: 0.5,
+							hasOverlap: true,
+						},
+						{
+							startMs: 1_600,
+							endMs: 1_800,
+							localSpeakerId: 2,
+							confidence: 0.5,
+							hasOverlap: true,
+						},
+					],
+				};
+			},
+			async dispose() {},
+		};
+		const profileStore: Pick<
+			VoiceProfileStore,
+			"findBestMatch" | "createProfile" | "refine"
+		> = {
+			async findBestMatch() {
+				return null;
+			},
+			async createProfile(args): Promise<VoiceProfileRecord> {
+				return {
+					schemaVersion: VOICE_PROFILE_RECORD_SCHEMA_VERSION,
+					profileId: "profile-overlap",
+					embeddingModel: args.embeddingModel,
+					embeddingDim: args.centroid.length,
+					centroid: Array.from(args.centroid),
+					variance: new Array(args.centroid.length).fill(0),
+					welfordM2: new Array(args.centroid.length).fill(0),
+					sampleCount: 1,
+					totalDurationMs: args.durationMs,
+					firstObservedAt: "2026-01-01T00:00:00.000Z",
+					lastObservedAt: "2026-01-01T00:00:00.000Z",
+					lastRefinedAt: "2026-01-01T00:00:00.000Z",
+					entityId: null,
+					imprintClusterId: "cluster-overlap",
+					confidence: args.confidence,
+					consent: {
+						attributionAuthorized: false,
+						synthesisAuthorized: false,
+					},
+				};
+			},
+			async refine() {
+				return null;
+			},
+		};
+		const pipeline = new VoiceAttributionPipeline({
+			encoder,
+			diarizer,
+			profileStore: profileStore as VoiceProfileStore,
+		});
+
+		const output = await pipeline.attribute({
+			turnId: "turn-overlap-fallback",
+			pcm: new Float32Array(16_000 * 2),
+		});
+
+		expect(output.observation?.imprintClusterId).toBe("cluster-overlap");
+		expect(output.primarySpeaker?.imprintClusterId).toBe("cluster-overlap");
+		expect(encoder.windows).toHaveLength(1);
+		expect(encoder.windows[0]).toHaveLength(24_000);
+	});
+});

package/src/services/voice/speaker/attribution-pipeline.ts

@@ -69,17 +69,52 @@ function nonOverlappingSegments(
 		);
 }
 
+function spanDurationMs(spans: ReadonlyArray<LocalSpeakerSegment>): number {
+	let total = 0;
+	for (const span of mergeSpanRanges(spans)) {
+		total += Math.max(0, span.endMs - span.startMs);
+	}
+	return total;
+}
+
+function mergeSpanRanges(
+	spans: ReadonlyArray<LocalSpeakerSegment>,
+): Array<{ startMs: number; endMs: number }> {
+	const sorted = spans
+		.map((span) => ({
+			startMs: Math.max(0, span.startMs),
+			endMs: Math.max(0, span.endMs),
+		}))
+		.filter((span) => span.endMs > span.startMs)
+		.sort((a, b) =>
+			a.startMs !== b.startMs ? a.startMs - b.startMs : a.endMs - b.endMs,
+		);
+	const merged: Array<{ startMs: number; endMs: number }> = [];
+	for (const span of sorted) {
+		const last = merged[merged.length - 1];
+		if (last && span.startMs <= last.endMs) {
+			last.endMs = Math.max(last.endMs, span.endMs);
+		} else {
+			merged.push({ ...span });
+		}
+	}
+	return merged;
+}
+
 function pickPrimaryLocalSpeaker(
 	local: ReadonlyArray<LocalSpeakerSegment>,
 ): number | null {
 	if (local.length === 0) return null;
 	const durations = new Map<number, number>();
+	const bySpeaker = new Map<number, LocalSpeakerSegment[]>();
 	for (const seg of local) {
-		const ms = Math.max(0, seg.endMs - seg.startMs);
-		durations.set(
-			seg.localSpeakerId,
-			(durations.get(seg.localSpeakerId) ?? 0) + ms,
-		);
+		const list = bySpeaker.get(seg.localSpeakerId) ?? [];
+		list.push(seg);
+		bySpeaker.set(seg.localSpeakerId, list);
+	}
+	for (const [localSpeakerId, spans] of bySpeaker.entries()) {
+		const ms = spanDurationMs(spans);
+		durations.set(localSpeakerId, (durations.get(localSpeakerId) ?? 0) + ms);
 	}
 	let best: { id: number; ms: number } | null = null;
 	for (const [id, ms] of durations.entries()) {
@@ -117,36 +152,63 @@ export class VoiceAttributionPipeline {
 		}
 		// Diarizer is optional — when missing we treat the whole turn as
 		// one segment with `localSpeakerId=0`.
+		let rawLocal: LocalSpeakerSegment[] = [];
 		let local: LocalSpeakerSegment[] = [];
 		if (this.deps.diarizer) {
 			try {
 				const out = await this.deps.diarizer.diarizeWindow(req.pcm);
-				local = nonOverlappingSegments(out.segments);
+				rawLocal = out.segments.sort((a, b) =>
+					a.startMs !== b.startMs ? a.startMs - b.startMs : a.endMs - b.endMs,
+				);
+				local = nonOverlappingSegments(rawLocal);
 			} catch {
 				local = [];
 			}
 		}
 		if (local.length === 0) {
-			local = [
-				{
-					startMs: 0,
-					endMs: Math.round(
-						(req.pcm.length / this.deps.encoder.sampleRate) * 1000,
-					),
-					localSpeakerId: 0,
-					confidence: 0.5,
-					hasOverlap: false,
-				},
-			];
+			local =
+				rawLocal.length > 0
+					? rawLocal
+					: [
+							{
+								startMs: 0,
+								endMs: Math.round(
+									(req.pcm.length / this.deps.encoder.sampleRate) * 1000,
+								),
+								localSpeakerId: 0,
+								confidence: 0.5,
+								hasOverlap: false,
+							},
+						];
 		}
-		const primaryLocal = pickPrimaryLocalSpeaker(local);
+		let primaryLocal = pickPrimaryLocalSpeaker(local);
 		if (primaryLocal === null) return this.buildEmptyOutput(req);
 		// Concatenate the primary local speaker's spans into a single PCM
 		// window for the embedding.
-		const primarySpans = local.filter(
+		let primarySpans = local.filter(
 			(seg) => seg.localSpeakerId === primaryLocal,
 		);
-		const window = this.spliceSpans(req.pcm, primarySpans);
+		let window = this.spliceSpans(req.pcm, primarySpans);
+		if (
+			window.length < WESPEAKER_MIN_SAMPLES &&
+			rawLocal.length > local.length
+		) {
+			const fallbackPrimary = pickPrimaryLocalSpeaker(rawLocal);
+			const fallbackSpans =
+				fallbackPrimary === null
+					? []
+					: rawLocal.filter((seg) => seg.localSpeakerId === fallbackPrimary);
+			const fallbackWindow = this.spliceSpans(req.pcm, fallbackSpans);
+			if (
+				fallbackPrimary !== null &&
+				fallbackWindow.length >= WESPEAKER_MIN_SAMPLES
+			) {
+				local = rawLocal;
+				primaryLocal = fallbackPrimary;
+				primarySpans = fallbackSpans;
+				window = fallbackWindow;
+			}
+		}
 		if (window.length < WESPEAKER_MIN_SAMPLES) {
 			// Not enough audio for a stable embedding — emit an
 			// "unknown speaker" segment, no profile observation.
@@ -302,9 +364,10 @@ export class VoiceAttributionPipeline {
 		spans: ReadonlyArray<LocalSpeakerSegment>,
 	): Float32Array {
 		const sr = this.deps.encoder.sampleRate;
+		const merged = mergeSpanRanges(spans);
 		// Compute total length first so we can allocate once.
 		let total = 0;
-		for (const span of spans) {
+		for (const span of merged) {
 			const a = Math.max(0, Math.floor((span.startMs / 1000) * sr));
 			const b = Math.min(pcm.length, Math.ceil((span.endMs / 1000) * sr));
 			if (b > a) total += b - a;
@@ -312,7 +375,7 @@ export class VoiceAttributionPipeline {
 		if (total === 0) return new Float32Array(0);
 		const out = new Float32Array(total);
 		let cursor = 0;
-		for (const span of spans) {
+		for (const span of merged) {
 			const a = Math.max(0, Math.floor((span.startMs / 1000) * sr));
 			const b = Math.min(pcm.length, Math.ceil((span.endMs / 1000) * sr));
 			if (b > a) {

package/src/services/voice/speaker/encoder-ggml.test.ts

@@ -0,0 +1,59 @@
+/**
+ * Unit coverage for voiceSpeakerDistance (#9147 self-voice-rejection / speaker ID).
+ *
+ * `voiceSpeakerDistance` is the pure cosine-distance metric (`1 - cos_sim`,
+ * range [0,2]) that the diarizer / self-voice-rejection compares against a
+ * threshold — small distance = same speaker. It mirrors the C-side
+ * `voice_speaker_distance` and shipped untested. No GGUF / FFI / audio.
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+	SPEAKER_GGML_EMBEDDING_DIM as DIM,
+	voiceSpeakerDistance,
+} from "./encoder-ggml";
+
+const vec = (fill: number) => new Float32Array(DIM).fill(fill);
+const unit = (index: number) => {
+	const v = new Float32Array(DIM);
+	v[index] = 1;
+	return v;
+};
+
+describe("voiceSpeakerDistance", () => {
+	it("is 0 for identical embeddings (same speaker)", () => {
+		expect(voiceSpeakerDistance(vec(1), vec(1))).toBeCloseTo(0, 6);
+	});
+
+	it("is scale-invariant (cosine ignores magnitude)", () => {
+		expect(voiceSpeakerDistance(vec(1), vec(2))).toBeCloseTo(0, 6);
+	});
+
+	it("is 1 for orthogonal embeddings", () => {
+		expect(voiceSpeakerDistance(unit(0), unit(1))).toBeCloseTo(1, 6);
+	});
+
+	it("is 2 for opposite embeddings (max distance)", () => {
+		expect(voiceSpeakerDistance(vec(1), vec(-1))).toBeCloseTo(2, 6);
+	});
+
+	it("returns 1 when either embedding is the zero vector", () => {
+		expect(voiceSpeakerDistance(new Float32Array(DIM), vec(1))).toBe(1);
+		expect(voiceSpeakerDistance(vec(1), new Float32Array(DIM))).toBe(1);
+	});
+
+	it("is symmetric", () => {
+		const a = unit(3);
+		const b = vec(1);
+		expect(voiceSpeakerDistance(a, b)).toBe(voiceSpeakerDistance(b, a));
+	});
+
+	it("throws on a wrong-dimension embedding (either side)", () => {
+		expect(() => voiceSpeakerDistance(new Float32Array(8), vec(1))).toThrow(
+			/expected 256/,
+		);
+		expect(() => voiceSpeakerDistance(vec(1), new Float32Array(8))).toThrow(
+			/expected 256/,
+		);
+	});
+});

package/src/services/voice/transcriber.asr-backend.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Unit coverage for the ASR-backend preference resolvers (#9147 voice).
+ *
+ * normalizeAsrBackendPreference / readAsrBackendPreferenceFromEnv /
+ * ffiSupportsStreamingAsr are the pure selection helpers that decide whether
+ * transcription runs on the fused streaming ASR, the FFI batch path, or auto.
+ * They were untested. No GGUF / FFI loaded (the module has only type imports).
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+	ffiSupportsStreamingAsr,
+	normalizeAsrBackendPreference,
+	readAsrBackendPreferenceFromEnv,
+} from "./transcriber";
+
+type FfiArg = Parameters<typeof ffiSupportsStreamingAsr>[0];
+const fakeFfi = (supported: boolean): FfiArg =>
+	({ asrStreamSupported: () => supported }) as unknown as FfiArg;
+
+describe("normalizeAsrBackendPreference", () => {
+	it("maps the canonical names and their aliases", () => {
+		expect(normalizeAsrBackendPreference("auto")).toBe("auto");
+		expect(normalizeAsrBackendPreference("fused")).toBe("fused");
+		expect(normalizeAsrBackendPreference("streaming")).toBe("fused");
+		expect(normalizeAsrBackendPreference("fused-streaming")).toBe("fused");
+		expect(normalizeAsrBackendPreference("batch")).toBe("ffi-batch");
+		expect(normalizeAsrBackendPreference("ffi-batch")).toBe("ffi-batch");
+		expect(normalizeAsrBackendPreference("fused-batch")).toBe("ffi-batch");
+	});
+
+	it("normalizes case, whitespace and underscores", () => {
+		expect(normalizeAsrBackendPreference("  FUSED_STREAMING ")).toBe("fused");
+		expect(normalizeAsrBackendPreference("FFI_BATCH")).toBe("ffi-batch");
+	});
+
+	it("returns null for empty / unknown input", () => {
+		expect(normalizeAsrBackendPreference(null)).toBeNull();
+		expect(normalizeAsrBackendPreference(undefined)).toBeNull();
+		expect(normalizeAsrBackendPreference("   ")).toBeNull();
+		expect(normalizeAsrBackendPreference("nonsense")).toBeNull();
+	});
+});
+
+describe("readAsrBackendPreferenceFromEnv", () => {
+	it("reads ELIZA_LOCAL_ASR_BACKEND from the provided env", () => {
+		expect(
+			readAsrBackendPreferenceFromEnv({ ELIZA_LOCAL_ASR_BACKEND: "streaming" }),
+		).toBe("fused");
+		expect(
+			readAsrBackendPreferenceFromEnv({
+				ELIZA_LOCAL_ASR_BACKEND: "fused-batch",
+			}),
+		).toBe("ffi-batch");
+	});
+
+	it("returns null when the env var is unset or unknown", () => {
+		expect(readAsrBackendPreferenceFromEnv({})).toBeNull();
+		expect(
+			readAsrBackendPreferenceFromEnv({ ELIZA_LOCAL_ASR_BACKEND: "xyz" }),
+		).toBeNull();
+	});
+});
+
+describe("ffiSupportsStreamingAsr", () => {
+	it("is false for null/undefined or an ffi missing the probe", () => {
+		expect(ffiSupportsStreamingAsr(null)).toBe(false);
+		expect(ffiSupportsStreamingAsr(undefined)).toBe(false);
+		expect(ffiSupportsStreamingAsr({} as unknown as FfiArg)).toBe(false);
+	});
+
+	it("delegates to ffi.asrStreamSupported() when present", () => {
+		expect(ffiSupportsStreamingAsr(fakeFfi(true))).toBe(true);
+		expect(ffiSupportsStreamingAsr(fakeFfi(false))).toBe(false);
+	});
+});

package/src/services/voice/transcriber.ts

@@ -20,8 +20,8 @@
  *      v1) over a sliding window with overlap, so each call covers ≤ ~6–7 s
  *      of audio — incremental, not "buffer the whole utterance, one giant
  *      decode". It lives inside the single shipped llama.cpp/GGML build and
- *      emits the Qwen2-BPE text-vocab (AGENTS.md §1/§4), so it does not
- *      vendor a second ggml or introduce a tokenizer-family mismatch.
+ *      emits Gemma text-vocabulary tokens, so it does not vendor a second
+ *      ggml or introduce a tokenizer-family mismatch.
  *      Selected whenever a `libelizainference` handle + bundled ASR model are
  *      present (which is always true when the fused build is loaded).
  *
@@ -449,8 +449,8 @@ export interface FfiBatchTranscriberOptions {
  * streaming decoder (`eliza_inference_asr_stream_*`, ABI v2) reports unsupported
  * until its runtime lands; this adapter is the contract-clean interim — it runs
  * inside the one shipped llama.cpp/GGML build and emits
- * Qwen2-BPE token-vocab text (AGENTS.md §1, §4), so no second ggml is
- * vendored and no tokenizer-family mismatch is introduced.
+ * Gemma token-vocab text, so no second ggml is vendored and no
+ * tokenizer-family mismatch is introduced.
  *
  * It runs a *windowed re-transcription with overlap* strategy: a prefix older
  * than `windowSeconds` is committed (decoded once, in window-sized chunks