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

package/src/services/voice/transcript-service.test.ts

@@ -59,6 +59,12 @@ function fakeRuntime(opts: {
 		async getMemoryById(id) {
 			return rows.get(id) ?? null;
 		},
+		async updateMemory(memory) {
+			const existing = rows.get(memory.id);
+			if (!existing) return false;
+			rows.set(memory.id, { ...existing, ...memory });
+			return true;
+		},
 		async deleteMemory(id) {
 			rows.delete(id);
 		},
@@ -134,4 +140,56 @@ describe("TranscriptService", () => {
 		expect(rt.rows.has(t.id)).toBe(false);
 		expect(rt.rows.has(docId)).toBe(false);
 	});
+
+	it("applies an edit, re-derives metadata, and re-mirrors to knowledge", async () => {
+		const rt = fakeRuntime({ withDocuments: true });
+		const svc = new TranscriptService(rt);
+		const t = makeTranscript();
+		await svc.create(input(t));
+		const firstDocId = "dddddddd-0000-0000-0000-000000000001";
+		rt.rows.set(firstDocId, { id: firstDocId } as Memory); // the create mirror row
+		rt.addDocument.mockClear();
+		rt.addDocument.mockResolvedValueOnce({
+			storedDocumentMemoryId: "dddddddd-0000-0000-0000-000000000002" as UUID,
+		});
+
+		const updated = await svc.update(t.id as UUID, {
+			worldId: WORLD,
+			roomId: ROOM,
+			entityId: ENTITY,
+			patch: {
+				title: "Edited title",
+				segments: [
+					{ ...t.segments[0], text: "corrected words here", words: [] },
+				],
+			},
+		});
+
+		expect(updated?.title).toBe("Edited title");
+		expect(updated?.editedAt).toBeGreaterThan(0);
+		expect(updated?.segments[0].text).toBe("corrected words here");
+		// Re-mirrored: the stale doc was removed and a fresh one created + linked.
+		expect(rt.rows.has(firstDocId)).toBe(false);
+		expect(rt.addDocument).toHaveBeenCalledTimes(1);
+		expect(updated?.knowledgeDocumentId).toBe(
+			"dddddddd-0000-0000-0000-000000000002",
+		);
+		// The store now round-trips the edited record.
+		expect((await svc.get(t.id as UUID))?.title).toBe("Edited title");
+	});
+
+	it("returns null when updating a transcript that does not exist", async () => {
+		const rt = fakeRuntime({ withDocuments: true });
+		const svc = new TranscriptService(rt);
+		const result = await svc.update(
+			"99999999-0000-0000-0000-000000000000" as UUID,
+			{
+				worldId: WORLD,
+				roomId: ROOM,
+				entityId: ENTITY,
+				patch: { title: "nope" },
+			},
+		);
+		expect(result).toBeNull();
+	});
 });

package/src/services/voice/transcript-service.ts

@@ -11,8 +11,13 @@ import { logger, type UUID } from "@elizaos/core";
 import type {
 	Transcript,
 	TranscriptScope,
+	TranscriptSegment,
 	TranscriptSummary,
 } from "@elizaos/shared/transcripts";
+import {
+	transcriptDurationMs,
+	transcriptSpeakerCount,
+} from "@elizaos/shared/transcripts";
 import { transcriptKnowledgePayload } from "./transcript-knowledge";
 import {
 	TranscriptStore,
@@ -48,6 +53,15 @@ export interface CreateTranscriptInput {
 	transcript: Transcript;
 }
 
+export interface UpdateTranscriptInput {
+	/** Ids the knowledge re-mirror is attributed to (default to the agent ctx). */
+	worldId: UUID;
+	roomId: UUID;
+	entityId: UUID;
+	/** The user edit: a new title and/or replacement segments. */
+	patch: { title?: string; segments?: TranscriptSegment[] };
+}
+
 export class TranscriptService {
 	private readonly store: TranscriptStore;
 
@@ -78,6 +92,56 @@ export class TranscriptService {
 		return this.store.get(id);
 	}
 
+	/**
+	 * Apply a user edit to a transcript record (title and/or segment text) and
+	 * persist it, re-mirroring the new text into the knowledge index so search
+	 * reflects the correction. Returns the updated record, or null if no record
+	 * with that id exists. Timing/speaker metadata is re-derived from the edited
+	 * segments; the knowledge mirror is replaced (old doc removed best-effort).
+	 */
+	async update(
+		id: UUID,
+		input: UpdateTranscriptInput,
+	): Promise<Transcript | null> {
+		const existing = await this.store.get(id);
+		if (!existing) return null;
+
+		const segments = input.patch.segments ?? existing.segments;
+		const next: Transcript = {
+			...existing,
+			title: input.patch.title?.trim() || existing.title,
+			segments,
+			durationMs: transcriptDurationMs(segments),
+			speakerCount: transcriptSpeakerCount(segments),
+			editedAt: Date.now(),
+		};
+
+		// Replace the knowledge mirror so search reflects the corrected text.
+		if (existing.knowledgeDocumentId) {
+			try {
+				await this.runtime.deleteMemory(existing.knowledgeDocumentId as UUID);
+			} catch (err) {
+				logger.warn(
+					{
+						transcriptId: id,
+						knowledgeDocumentId: existing.knowledgeDocumentId,
+						error: err instanceof Error ? err.message : String(err),
+					},
+					"[TranscriptService] failed to remove stale knowledge mirror on update",
+				);
+			}
+		}
+		const knowledgeDocumentId = await this.mirrorToKnowledge(
+			input.worldId,
+			input.roomId,
+			input.entityId,
+			next,
+		);
+		next.knowledgeDocumentId = knowledgeDocumentId;
+
+		return this.store.update(next);
+	}
+
 	/** Delete the record + its knowledge mirror (mirror removal best-effort). */
 	async delete(id: UUID): Promise<void> {
 		const existing = await this.store.get(id);

package/src/services/voice/transcript-store.test.ts

@@ -60,6 +60,12 @@ function fakeRuntime(): TranscriptStoreRuntime & { rows: Map<string, Memory> } {
 		async getMemoryById(id) {
 			return rows.get(id) ?? null;
 		},
+		async updateMemory(memory) {
+			const existing = rows.get(memory.id);
+			if (!existing) return false;
+			rows.set(memory.id, { ...existing, ...memory });
+			return true;
+		},
 		async deleteMemory(id) {
 			rows.delete(id);
 		},
@@ -147,6 +153,36 @@ describe("TranscriptStore", () => {
 		expect(await store.get(t.id as UUID)).toBeNull();
 	});
 
+	it("updates a record in place and re-derives the preview + metadata", async () => {
+		const rt = fakeRuntime();
+		const store = new TranscriptStore(rt);
+		const t = makeTranscript();
+		await store.create({ roomId: ROOM, entityId: ENTITY, transcript: t });
+
+		const edited: Transcript = {
+			...t,
+			title: "Standup (edited)",
+			segments: [{ ...t.segments[0], text: "hello edited world", words: [] }],
+			editedAt: 5000,
+		};
+		const returned = await store.update(edited);
+		expect(returned).toEqual(edited);
+
+		// Same row id, overwritten content + re-derived preview text.
+		const row = rt.rows.get(t.id) as Memory;
+		expect(rt.rows.size).toBe(1);
+		expect(row.content.text).toBe("hello edited world");
+		expect(row.metadata?.transcriptId).toBe(t.id);
+		// store.get round-trips the edited record exactly.
+		expect(await store.get(t.id as UUID)).toEqual(edited);
+	});
+
+	it("throws when updating a record that does not exist", async () => {
+		const rt = fakeRuntime();
+		const store = new TranscriptStore(rt);
+		await expect(store.update(makeTranscript())).rejects.toThrow(/not found/);
+	});
+
 	it("exposes the partition name", () => {
 		expect(TRANSCRIPTS_TABLE).toBe("transcripts");
 	});

package/src/services/voice/transcript-store.ts

@@ -42,6 +42,9 @@ export interface TranscriptStoreRuntime {
 		orderDirection?: "asc" | "desc";
 	}): Promise<Memory[]>;
 	getMemoryById(id: UUID): Promise<Memory | null>;
+	updateMemory(
+		memory: Partial<Memory> & { id: UUID; metadata?: MemoryMetadata },
+	): Promise<boolean>;
 	deleteMemory(id: UUID): Promise<void>;
 }
 
@@ -125,6 +128,35 @@ export class TranscriptStore {
 		return row ? rowToTranscript(row) : null;
 	}
 
+	/**
+	 * Overwrite an existing transcript record in place (same id/row) — used when
+	 * the user edits the transcript text. Re-derives the preview text body and
+	 * the timing/speaker metadata from the updated record so generic memory
+	 * consumers and the list stay consistent. Returns the record as stored.
+	 */
+	async update(transcript: Transcript): Promise<Transcript> {
+		const ok = await this.runtime.updateMemory({
+			id: transcript.id as UUID,
+			content: {
+				text: transcriptPreview(transcript.segments),
+				transcript: JSON.stringify(transcript),
+			},
+			metadata: {
+				type: "custom",
+				source: TRANSCRIPT_METADATA_TYPE,
+				timestamp: transcript.createdAt,
+				transcriptId: transcript.id,
+				durationMs: transcript.durationMs,
+				speakerCount: transcript.speakerCount,
+				status: transcript.status,
+			},
+		});
+		if (!ok) {
+			throw new Error(`transcript ${transcript.id} not found`);
+		}
+		return transcript;
+	}
+
 	/** Delete a transcript record (the knowledge mirror is removed separately). */
 	async delete(id: UUID): Promise<void> {
 		await this.runtime.deleteMemory(id);

package/src/services/voice/types.ts

@@ -3,10 +3,10 @@ export interface TextToken {
 	text: string;
 	/**
 	 * Text-model vocabulary token id, when the producer knows it. ASR
-	 * (fused Qwen3-ASR) and the text backbone share the Qwen2 BPE 151 936
-	 * vocab + merges (AGENTS.md §1), so an ASR-emitted token id is the same
-	 * id the text model would assign — a downstream in-process handoff can
-	 * inject `id` directly into the text KV cache without detokenize →
+	 * (fused Gemma ASR) and the text backbone share the Gemma tokenizer, so an
+	 * ASR-emitted token id is the same id the text model would assign — a
+	 * downstream in-process handoff can inject `id` directly into the text KV
+	 * cache without detokenize →
 	 * retokenize. Absent for producers that only have surface text (the
 	 * word-chunk approximation in `splitTranscriptToTokens`).
 	 */
@@ -258,7 +258,7 @@ export interface VoiceTurnMetadata {
  * VAD gating + barge-in word-confirm (`voice/vad.ts`, `voice/barge-in.ts`),
  * the turn controller / speculative-on-pause path, and the overlapped
  * `VoicePipeline` (`voice/pipeline.ts`). The `StreamingTranscriber` below
- * is the single ASR contract; the two fused adapters (fused Qwen3-ASR
+ * is the single ASR contract; the two fused adapters (fused Gemma ASR
  * streaming and fused batch, both via libelizainference) implement it in
  * `voice/transcriber.ts`. It consumes the canonical `PcmFrame` (defined
  * below in the audio front-end section) off a `MicSource` and is gated by
@@ -284,7 +284,7 @@ export interface TranscriptUpdate {
 	turn?: VoiceTurnMetadata;
 	/**
 	 * Text-model token ids for `partial`, when the backend can supply them
-	 * cheaply (fused Qwen3-ASR shares the text vocabulary). Absent when the
+	 * cheaply (fused Gemma ASR shares the text vocabulary). Absent when the
 	 * decoder reports surface text only (re-tokenization is the LLM stage's
 	 * job there).
 	 */
@@ -682,7 +682,7 @@ export type VoiceSchedulerTelemetryListener = (
 // ---------------------------------------------------------------------------
 
 /** Minimal VAD model contract consumed by the fused `GgmlSileroVad` and the
- *  optional injected qwen-toolkit adapter. */
+ *  optional injected external adapter. */
 export interface VadLike {
 	readonly windowSamples: number;
 	readonly sampleRate: number;

package/src/services/voice/vad.test.ts

@@ -324,11 +324,11 @@ describe("VadDetector", () => {
 });
 
 describe("GgmlSileroVad", () => {
-	it("documents the auto provider order: optional Qwen toolkit adapter → fused native Silero", () => {
+	it("documents the auto provider order: optional external VAD adapter → fused native Silero", () => {
 		// Fused `silero-ggml` (the one libelizainference handle) is the sole
-		// on-device VAD runtime; the optional injected `qwen-toolkit` adapter is
+		// on-device VAD runtime; the optional injected `external-vad` adapter is
 		// tried first only when a caller supplies one.
-		expect(vadProviderOrder()).toEqual(["qwen-toolkit", "silero-ggml"]);
+		expect(vadProviderOrder()).toEqual(["external-vad", "silero-ggml"]);
 		expect(vadProviderOrder("silero-ggml")).toEqual(["silero-ggml"]);
 	});
 
@@ -336,8 +336,8 @@ describe("GgmlSileroVad", () => {
 		expect(NativeSileroVad).toBe(GgmlSileroVad);
 	});
 
-	it("prefers a supplied Qwen toolkit VAD adapter over the native provider", async () => {
-		const qwenVad = new ScriptedSilero([
+	it("prefers a supplied external VAD adapter over the native provider", async () => {
+		const externalVad = new ScriptedSilero([
 			0.01, 0.9, 0.9, 0.02, 0.02, 0.02, 0.02, 0.02,
 		]);
 		const ffi = fakeFfi("x", {
@@ -345,20 +345,20 @@ describe("GgmlSileroVad", () => {
 			vadProbs: [0.01],
 		});
 		const resolved = await resolveVadProvider({
-			qwenToolkitVad: {
+			externalVad: {
 				isAvailable: () => true,
-				loadVad: async () => qwenVad,
+				loadVad: async () => externalVad,
 			},
 			ffi,
 			ctx: 1n,
 		});
 
-		expect(resolved.id).toBe("qwen-toolkit");
-		expect(resolved.vad).toBe(qwenVad);
+		expect(resolved.id).toBe("external-vad");
+		expect(resolved.vad).toBe(externalVad);
 
 		const det = await createVadDetector({
-			qwenToolkitVad: {
-				loadVad: async () => qwenVad,
+			externalVad: {
+				loadVad: async () => externalVad,
 			},
 			ffi,
 			ctx: 1n,
@@ -388,15 +388,15 @@ describe("GgmlSileroVad", () => {
 	});
 
 	it("createSileroVadDetector goes through the unified resolver", async () => {
-		// The Qwen toolkit adapter short-circuits resolution before any
+		// The external adapter short-circuits resolution before any
 		// FFI / model-file checks run, which exercises the unified resolver
 		// end-to-end without needing a libelizainference build.
-		const qwenVad = new ScriptedSilero([
+		const externalVad = new ScriptedSilero([
 			0.01, 0.9, 0.9, 0.02, 0.02, 0.02, 0.02, 0.02,
 		]);
 		const det = await createSileroVadDetector({
-			qwenToolkitVad: {
-				loadVad: async () => qwenVad,
+			externalVad: {
+				loadVad: async () => externalVad,
 			},
 			config: {
 				onsetThreshold: 0.5,
@@ -477,4 +477,22 @@ describe("GgmlSileroVad", () => {
 			rmSync(dir, { recursive: true, force: true });
 		}
 	});
+
+	it("accepts the bundled silero-vad-v5.gguf alias used by published bundles", async () => {
+		const dir = mkdtempSync(path.join(os.tmpdir(), "fused-vad-gguf-"));
+		try {
+			const gguf = path.join(dir, "vad", "silero-vad-v5.gguf");
+			mkdirSync(path.dirname(gguf), { recursive: true });
+			writeFileSync(gguf, "");
+			const ffi = fakeFfi("x", { vadSupported: true, vadProbs: [0.1] });
+			const resolved = await resolveVadProvider({
+				ffi,
+				ctx: 1n,
+				bundleRoot: dir,
+			});
+			expect(resolved.id).toBe("silero-ggml");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
 });

package/src/services/voice/vad.ts

@@ -9,7 +9,7 @@
  *            acoustic activity right now".
  *
  *   Tier 2 — a model VAD provider. Resolver order is an optional injected
- *            Qwen toolkit adapter when supplied, otherwise the fused
+ *            external VAD adapter when supplied, otherwise the fused
  *            `libelizainference` Silero v5 VAD ABI (`eliza_inference_vad_*`,
  *            backend id `silero-ggml`). 512-sample windows at 16 kHz (32 ms
  *            hop), one speech probability per window. This is the
@@ -61,9 +61,13 @@ export class VadUnavailableError extends Error {
 	}
 }
 
-/** Relative path of the fused Silero v5 GGML VAD model inside an Eliza-1
- *  bundle. The file is read by `libelizainference`'s native VAD ABI. */
+/** Relative paths of the fused Silero v5 model inside an Eliza-1 bundle. */
 const SILERO_VAD_GGML_REL_PATH = path.join("vad", "silero-vad-v5.1.2.ggml.bin");
+const SILERO_VAD_GGUF_REL_PATH = path.join("vad", "silero-vad-v5.gguf");
+const SILERO_VAD_REL_PATHS = [
+	SILERO_VAD_GGML_REL_PATH,
+	SILERO_VAD_GGUF_REL_PATH,
+] as const;
 
 /**
  * Resolve the fused-libelizainference Silero GGML VAD model on disk. An
@@ -71,7 +75,8 @@ const SILERO_VAD_GGML_REL_PATH = path.join("vad", "silero-vad-v5.1.2.ggml.bin");
  * result is `null` (no silent substitution of a different model). When
  * `modelPath` is not given the search order is:
  *   1. `<bundleRoot>/vad/silero-vad-v5.1.2.ggml.bin`
- *   2. `<state-dir>/local-inference/vad/silero-vad-v5.1.2.ggml.bin`
+ *   2. `<bundleRoot>/vad/silero-vad-v5.gguf`
+ *   3. `<state-dir>/local-inference/vad/<same filenames>`
  *   3. `$ELIZA_VAD_MODEL_PATH`
  * Returns `null` when none exist.
  */
@@ -83,10 +88,10 @@ export function resolveSileroVadPath(opts: {
 		return existsSync(opts.modelPath) ? path.resolve(opts.modelPath) : null;
 	}
 	const candidates: Array<string | undefined> = [
-		opts.bundleRoot
-			? path.join(opts.bundleRoot, SILERO_VAD_GGML_REL_PATH)
-			: undefined,
-		path.join(localInferenceRoot(), SILERO_VAD_GGML_REL_PATH),
+		...SILERO_VAD_REL_PATHS.map((rel) =>
+			opts.bundleRoot ? path.join(opts.bundleRoot, rel) : undefined,
+		),
+		...SILERO_VAD_REL_PATHS.map((rel) => path.join(localInferenceRoot(), rel)),
 		process.env.ELIZA_VAD_MODEL_PATH?.trim() || undefined,
 	];
 	for (const c of candidates) {
@@ -371,10 +376,10 @@ export type { VadLike } from "./types.js";
 
 import type { VadLike } from "./types.js";
 
-export type VadProviderId = "qwen-toolkit" | "silero-ggml";
+export type VadProviderId = "external-vad" | "silero-ggml";
 export type VadProviderPreference = "auto" | VadProviderId;
 
-export interface QwenToolkitVadAdapter {
+export interface ExternalVadAdapter {
 	isAvailable?(): boolean | Promise<boolean>;
 	loadVad(opts: { sampleRate: number }): Promise<VadLike>;
 }
@@ -389,7 +394,7 @@ export interface CreateVadDetectorOptions {
 	bundleRoot?: string;
 	ffi?: ElizaInferenceFfi | null;
 	ctx?: ElizaInferenceContextHandle | (() => ElizaInferenceContextHandle);
-	qwenToolkitVad?: QwenToolkitVadAdapter | null;
+	externalVad?: ExternalVadAdapter | null;
 	config?: VadDetectorConfig;
 	prefer?: VadProviderPreference;
 }
@@ -399,10 +404,10 @@ export function vadProviderOrder(
 ): VadProviderId[] {
 	if (prefer !== "auto") return [prefer];
 	// `silero-ggml` is the fused `libelizainference` VAD ABI — the sole
-	// on-device VAD runtime. The optional injected `qwen-toolkit` adapter is
+	// on-device VAD runtime. The optional injected `external-vad` adapter is
 	// tried first only when a caller supplies one; otherwise the fused engine
 	// is the single path, and an unavailable fused VAD fails fast.
-	return ["qwen-toolkit", "silero-ggml"];
+	return ["external-vad", "silero-ggml"];
 }
 
 export async function resolveVadProvider(
@@ -414,20 +419,20 @@ export async function resolveVadProvider(
 
 	for (const provider of vadProviderOrder(opts.prefer)) {
 		switch (provider) {
-			case "qwen-toolkit": {
+			case "external-vad": {
 				tried.push(provider);
-				if (!opts.qwenToolkitVad) {
-					reasons.push("qwen-toolkit: no adapter supplied");
+				if (!opts.externalVad) {
+					reasons.push("external-vad: no adapter supplied");
 					break;
 				}
-				const available = (await opts.qwenToolkitVad.isAvailable?.()) ?? true;
+				const available = (await opts.externalVad.isAvailable?.()) ?? true;
 				if (!available) {
-					reasons.push("qwen-toolkit: adapter reported unavailable");
+					reasons.push("external-vad: adapter reported unavailable");
 					break;
 				}
 				return {
 					id: provider,
-					vad: await opts.qwenToolkitVad.loadVad({ sampleRate }),
+					vad: await opts.externalVad.loadVad({ sampleRate }),
 				};
 			}
 			case "silero-ggml": {
@@ -454,7 +459,7 @@ export async function resolveVadProvider(
 				if (!modelPath) {
 					throw new VadUnavailableError(
 						"model-missing",
-						`[voice] Fused Silero v5 GGML VAD model not found. Looked for ${SILERO_VAD_GGML_REL_PATH} in the Eliza-1 bundle and under ${localInferenceRoot()}, or set ELIZA_VAD_MODEL_PATH.`,
+						`[voice] Fused Silero v5 GGML/GGUF VAD model not found. Looked for ${SILERO_VAD_REL_PATHS.join(" or ")} in the Eliza-1 bundle and under ${localInferenceRoot()}, or set ELIZA_VAD_MODEL_PATH.`,
 					);
 				}
 				return {

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

@@ -366,9 +366,6 @@ describe("pickVoiceTierSlot", () => {
 		expect(
 			pickVoiceTierSlot({ textModelId: "eliza-1-2b", deviceTier: "GOOD" }),
 		).toBe("desktop-2b");
-		expect(
-			pickVoiceTierSlot({ textModelId: "eliza-1-1_7b", deviceTier: "GOOD" }),
-		).toBe("desktop-2b");
 	});
 
 	it("falls through to desktop-2b (the entry tier) for small / unknown ids", () => {

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

@@ -237,11 +237,11 @@ export interface VoiceEnsembleBudget {
  * the largest co-resident knob is the LM itself.
  */
 export type VoiceTierSlot =
-	| "mobile-2b" // mobile profile: kokoro-q8 + turnsense + ASR-0.6B + LM-2B (entry tier), no dedicated embedding
+	| "mobile-2b" // mobile profile: kokoro-q8 + turnsense + entry ASR + LM-2B (entry tier), no dedicated embedding
 	| "desktop-2b" // 2b LM (entry tier) + full voice stack + embedding
 	| "desktop-4b" // 4b LM + full voice stack + embedding
-	| "workstation-9b" // 9b LM + omnivoice-Q8 + ASR-0.6B + embedding
-	| "workstation-27b"; // 27b LM + omnivoice-Q8 + ASR-1.7B + embedding
+	| "workstation-9b" // 9b LM + omnivoice-Q8 + entry ASR + embedding
+	| "workstation-27b"; // 27b LM + omnivoice-Q8 + large ASR + embedding
 
 const _MB = 1; // alias for readability inside the table
 const _GB = 1024;
@@ -256,7 +256,7 @@ export const VOICE_ENSEMBLE_BUDGETS: Readonly<
 		lmKvMb: 0.075 * _GB,
 		drafterMb: 0.5 * _GB,
 		ttsMb: 0.08 * _GB, // kokoro-q8 ONNX
-		asrMb: 0.4 * _GB, // qwen3-asr-0.6B documented Q4-equiv
+		asrMb: 0.4 * _GB, // entry Gemma-compatible ASR placeholder budget
 		asrMmprojMb: 0.2 * _GB,
 		embeddingMb: 0, // pools from the text backbone on the 2b entry tier
 		vadMb: 2 * _MB, // silero-vad documented baseline
@@ -293,7 +293,7 @@ export const VOICE_ENSEMBLE_BUDGETS: Readonly<
 		embeddingMb: 0.4 * _GB,
 		vadMb: 2 * _MB,
 		wakeWordMb: 4 * _MB,
-		turnDetectorMb: 400 * _MB, // livekit/turn-detector v0.4.1-intl Qwen2.5-0.5B
+		turnDetectorMb: 400 * _MB, // livekit/turn-detector v0.4.1-intl semantic model
 		emotionMb: 40 * _MB,
 		speakerEncoderMb: 10 * _MB,
 		transientTtsBufferMb: 1.17 * _GB,
@@ -320,7 +320,7 @@ export const VOICE_ENSEMBLE_BUDGETS: Readonly<
 		lmKvMb: 2.75 * _GB,
 		drafterMb: 2.6 * _GB,
 		ttsMb: 1.28 * _GB,
-		asrMb: 1.1 * _GB, // qwen3-asr-1.7B on the 27B tier
+		asrMb: 1.1 * _GB, // large Gemma-compatible ASR placeholder budget
 		asrMmprojMb: 0.3 * _GB,
 		embeddingMb: 0.4 * _GB,
 		vadMb: 2 * _MB,

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

@@ -20,7 +20,7 @@
  *   (f) a cancel mid-`generate` (the producer's `AbortSignal`) stops the turn
  *       and doesn't wedge the loop
  *
- * The *real-output* run (a real `eliza-1-0_8b` duet, gated behind the catalog
+ * The *real-output* run (a real `eliza-1-2b` duet, gated behind the catalog
  * +-fused-build probe) lives in `voice-duet.e2e.test.ts`.
  */