@elizaos/app-core 2.0.3-beta.2 → 2.0.3-beta.4

package/scripts/serve-real-local-agent.ts

@@ -0,0 +1,72 @@
+/**
+ * Persistent real local agent for device e2e.
+ *
+ * This is the long-running counterpart to check-real-local-chat.ts: it boots a
+ * real AgentRuntime + real app-core HTTP API with a deterministic model plugin,
+ * then stays alive until the surrounding workflow sends SIGTERM. Android
+ * WebView tests reach it through adb reverse as a "remote" first-run target.
+ */
+
+import { createDeterministicLlmProxyPlugin } from "../../test/mocks/helpers/llm-proxy-plugin.ts";
+import { startApiServer } from "../src/api/server.ts";
+import { useIsolatedConfigEnv } from "../test/helpers/isolated-config.ts";
+import { createRealTestRuntime } from "../test/helpers/real-runtime.ts";
+
+function resolvePort(): number {
+  const raw = process.env.ELIZA_API_PORT ?? process.env.ELIZA_PORT ?? "31337";
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isFinite(port) || port <= 0) {
+    throw new Error(`Invalid ELIZA_API_PORT/ELIZA_PORT: ${raw}`);
+  }
+  return port;
+}
+
+async function main(): Promise<void> {
+  const t0 = Date.now();
+  const port = resolvePort();
+
+  process.env.ELIZA_PAIRING_DISABLED ??= "1";
+
+  const configEnv = useIsolatedConfigEnv("eliza-device-e2e-host-agent-");
+  const proxy = createDeterministicLlmProxyPlugin({
+    failOnUnhandledAction: false,
+  });
+  const runtimeResult = await createRealTestRuntime({
+    characterName: "DeviceE2EHostAgent",
+    plugins: [proxy],
+  });
+  const server = await startApiServer({
+    port,
+    runtime: runtimeResult.runtime,
+    skipDeferredStartupWork: true,
+  });
+
+  console.log(
+    `[device-e2e-host-agent] real API up on :${server.port} in ${Date.now() - t0}ms`,
+  );
+
+  let stopping = false;
+  const stop = async (signal: string) => {
+    if (stopping) return;
+    stopping = true;
+    console.log(`[device-e2e-host-agent] stopping (${signal})`);
+    await server.close().catch(() => undefined);
+    await runtimeResult.cleanup().catch(() => undefined);
+    await configEnv.restore().catch(() => undefined);
+  };
+
+  for (const signal of ["SIGINT", "SIGTERM"] as const) {
+    process.once(signal, () => {
+      void stop(signal).finally(() => process.exit(0));
+    });
+  }
+
+  await new Promise<never>(() => {});
+}
+
+main().catch((error) => {
+  console.error(
+    `[device-e2e-host-agent] FAILED: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`,
+  );
+  process.exit(1);
+});

package/scripts/stage-desktop-fused-lib.mjs

@@ -236,9 +236,12 @@ function backendCmakeFlags(backend) {
   }
 }
 
-const { variant, outDir: outOverride, jobs: jobsArg, force } = parseArgs(
-  process.argv.slice(2),
-);
+const {
+  variant,
+  outDir: outOverride,
+  jobs: jobsArg,
+  force,
+} = parseArgs(process.argv.slice(2));
 
 if (!existsSync(path.join(forkSrc, "CMakeLists.txt"))) {
   die(
@@ -249,12 +252,13 @@ if (!have("cmake")) die("cmake not found on PATH");
 
 const backend = variant === "auto" ? detectBackend() : variant;
 log(`host: ${process.platform}/${process.arch}`);
-log(`backend: ${backend}${variant === "auto" ? " (autodetected)" : ""} (GGML_CPU always on for fallback)`);
+log(
+  `backend: ${backend}${variant === "auto" ? " (autodetected)" : ""} (GGML_CPU always on for fallback)`,
+);
 
 const buildDir = path.join(forkSrc, `build-desktop-${backend}`);
 const outDir =
-  outOverride ||
-  path.join(resolveStateDir(), "local-inference", "lib");
+  outOverride || path.join(resolveStateDir(), "local-inference", "lib");
 
 if (force && existsSync(buildDir)) {
   rmSync(buildDir, { recursive: true, force: true });
@@ -276,7 +280,7 @@ const jobs =
 // (so the GPU backend can load the system driver at runtime) and matches the
 // dlopen()-able sibling set the runtime resolves. LLAMA_BUILD_OMNIVOICE +
 // LLAMA_BUILD_MTMD + LLAMA_BUILD_KOKORO are required for the fused
-// `elizainference` SHARED target (TTS + Qwen3-ASR + Kokoro). GGML_NATIVE=ON tunes
+// `elizainference` SHARED target (TTS + local ASR + Kokoro). GGML_NATIVE=ON tunes
 // the CPU backend to the build host — correct for a local/dev build; a
 // redistributable build should pin explicit CPU features instead.
 run("cmake", [
@@ -310,6 +314,11 @@ run("cmake", [
   buildDir,
   "--target",
   "elizainference",
+  // Multi-config generators (MSVC, Xcode) ignore -DCMAKE_BUILD_TYPE and pick
+  // Debug unless the build step names the config; single-config generators
+  // (Make, Ninja) silently ignore --config, so this is safe everywhere.
+  "--config",
+  "Release",
   "-j",
   String(jobs),
 ]);
@@ -317,14 +326,23 @@ run("cmake", [
 // Collect the produced shared libs (the fused lib + its ggml/llama/mtmd
 // backends) and stage them as one consistent set. Sweep the out dir first so a
 // backend switch never leaves a stale sibling the loader could pick up.
-const binDir = path.join(buildDir, "bin");
+// Multi-config generators (MSVC, Xcode) nest the artifacts under bin/<Config>;
+// single-config generators (Make, Ninja) emit straight into bin/.
+let binDir = path.join(buildDir, "bin");
+const releaseBinDir = path.join(binDir, "Release");
+if (existsSync(releaseBinDir)) binDir = releaseBinDir;
 const libExt =
   process.platform === "darwin"
     ? ".dylib"
     : process.platform === "win32"
       ? ".dll"
       : ".so";
-const fusedName = `libelizainference${libExt}`;
+// CMake prepends the `lib` prefix to shared libs on Unix only; MSVC/Windows
+// emits the bare target name (elizainference.dll).
+const fusedName =
+  process.platform === "win32"
+    ? `elizainference${libExt}`
+    : `libelizainference${libExt}`;
 if (!existsSync(path.join(binDir, fusedName))) {
   die(`build did not produce ${fusedName} in ${binDir}`);
 }
@@ -378,7 +396,10 @@ function definedSymbols(libPath) {
     process.platform === "darwin"
       ? { cmd: "nm", args: ["-gU", libPath] }
       : process.platform === "win32"
-        ? { cmd: "objdump", args: ["-T", libPath] }
+        ? // PE exports live in the export-address table shown by `objdump -p`
+          // ("[Ordinal/Name Pointer] Table"); `-T` is the ELF dynamic-symbol
+          // flag and lists nothing for a .dll, so it would false-fail the verify.
+          { cmd: "objdump", args: ["-p", libPath] }
         : { cmd: "nm", args: ["-D", "--defined-only", libPath] };
   try {
     return execFileSync(tool.cmd, tool.args, {
@@ -396,8 +417,14 @@ function verifyFusedSymbols(stagedDir) {
     log("symbol verify skipped (nm/objdump unavailable)");
     return;
   }
-  // eliza_inference_* and ov_* must be in the fused lib itself.
-  const inFused = { "eliza_inference_*": /\beliza_inference_/, "ov_*": /\bov_/ };
+  // eliza_inference_* and ov_* must be in the fused lib itself. Anchor to the
+  // symbol start after nm's type column and allow the Mach-O leading underscore
+  // (`_eliza_inference_*` on macOS, `eliza_inference_*` on Linux) — a bare `\b`
+  // does NOT match between `_` and a letter, so it false-fails on macOS.
+  const inFused = {
+    "eliza_inference_*": /(?:^|\s)_?eliza_inference_/m,
+    "ov_*": /(?:^|\s)_?ov_/m,
+  };
   const missingFused = Object.entries(inFused)
     .filter(([, re]) => !re.test(fusedSyms))
     .map(([n]) => n);
@@ -410,12 +437,14 @@ function verifyFusedSymbols(stagedDir) {
   // llama_* across the staged set (the sibling libllama in a shared build).
   const llamaHere = staged.some((n) => {
     const s = definedSymbols(path.join(stagedDir, n));
-    return s !== null && /\bllama_/.test(s);
+    return s !== null && /(?:^|\s)_?llama_/m.test(s);
   });
   if (!llamaHere) {
     die(`llama_* symbols not found in the staged lib set — incomplete build.`);
   }
-  log("symbol verify OK: eliza_inference_* + ov_* in fused lib, llama_* in set");
+  log(
+    "symbol verify OK: eliza_inference_* + ov_* in fused lib, llama_* in set",
+  );
 }
 
 log("");

package/scripts/verify-ondevice-artifact.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * CLI: verify a staged on-device artifact contains the freshly built renderer +
+ * required companion files (agent bundle, native libs). A post-build CI gate for
+ * issue #9309.
+ *
+ * Usage:
+ *   node verify-ondevice-artifact.mjs \
+ *     --renderer-dir packages/app/ios/App/App/public \
+ *     --fresh-dist packages/app/dist \
+ *     --require agent/agent-bundle.js \
+ *     --label ios
+ *
+ *   # presets resolve the standard paths for a platform:
+ *   node verify-ondevice-artifact.mjs --platform ios [--local]
+ *   node verify-ondevice-artifact.mjs --platform desktop
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { verifyStagedArtifact } from "./lib/verify-ondevice-artifact.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..", "..", "..");
+
+function arg(name) {
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx >= 0 ? process.argv[idx + 1] : undefined;
+}
+function flag(name) {
+  return process.argv.includes(`--${name}`);
+}
+function repeatedArg(name) {
+  const out = [];
+  for (let i = 0; i < process.argv.length; i += 1) {
+    if (process.argv[i] === `--${name}` && process.argv[i + 1]) {
+      out.push(process.argv[i + 1]);
+    }
+  }
+  return out;
+}
+
+function presetFor(platform, { local }) {
+  const appDist = path.join(repoRoot, "packages", "app", "dist");
+  if (platform === "ios") {
+    return {
+      rendererDir: path.join(
+        repoRoot,
+        "packages",
+        "app",
+        "ios",
+        "App",
+        "App",
+        "public",
+      ),
+      freshDistDir: appDist,
+      requiredFiles: local ? ["agent/agent-bundle.js"] : [],
+      label: "ios",
+    };
+  }
+  if (platform === "android") {
+    return {
+      rendererDir: path.join(
+        repoRoot,
+        "packages",
+        "app-core",
+        "platforms",
+        "android",
+        "app",
+        "src",
+        "main",
+        "assets",
+        "public",
+      ),
+      freshDistDir: appDist,
+      requiredFiles: [],
+      label: "android",
+    };
+  }
+  if (platform === "desktop") {
+    return {
+      rendererDir: appDist,
+      freshDistDir: appDist,
+      requiredFiles: [],
+      label: "desktop",
+    };
+  }
+  throw new Error(`unknown --platform ${platform}`);
+}
+
+const platform = arg("platform");
+const config = platform
+  ? presetFor(platform, { local: flag("local") })
+  : {
+      rendererDir: path.resolve(arg("renderer-dir") ?? "."),
+      freshDistDir: arg("fresh-dist") ? path.resolve(arg("fresh-dist")) : null,
+      requiredFiles: repeatedArg("require"),
+      label: arg("label") ?? "artifact",
+    };
+
+const result = verifyStagedArtifact(config);
+if (!result.ok) {
+  console.error(`[verify-ondevice-artifact] FAIL (${config.label}):`);
+  for (const problem of result.problems) console.error(`  - ${problem}`);
+  process.exit(1);
+}
+console.log(
+  `[verify-ondevice-artifact] OK (${config.label}): renderer buildId=${
+    result.manifest ? String(result.manifest.buildId).slice(0, 12) : "?"
+  }, ${config.requiredFiles.length} required file(s) present.`,
+);

package/scripts/voice-attribution-smoke.ts

@@ -22,13 +22,22 @@
  *     --models /path/to/dir/with/{silero-vad-v5,wespeaker-resnet34-lm,pyannote-segmentation-3.0}.gguf
  *   ELIZA_VOICE_REAL_MODEL_DIR=/path/to/models bun packages/app-core/scripts/voice-attribution-smoke.ts
  *
- * Exit 0 on pass OR when models / the fused lib are absent (skipped); 1 on any
- * assertion fail.
+ * Exit 0 on pass OR when models / the fused lib are absent (skipped). Pass
+ * `--require-real` (or set `ELIZA_VOICE_REAL_REQUIRE=1`) in provisioned CI to
+ * convert any skip into a hard failure; the real matrix must produce evidence,
+ * not a green skip.
  */
-import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { buildVoiceTurnSignal } from "../../../packages/shared/src/voice/respond-gate.ts";
 import { handleLiveVoiceAttribution } from "../../../plugins/plugin-local-inference/src/runtime/voice-entity-binding.ts";
 import { resolveFusedLibraryPath } from "../../../plugins/plugin-local-inference/src/services/desktop-fused-ffi-backend-runtime.ts";
 import {
@@ -40,14 +49,10 @@ import { VoiceProfileStore } from "../../../plugins/plugin-local-inference/src/s
 import { VoiceAttributionPipeline } from "../../../plugins/plugin-local-inference/src/services/voice/speaker/attribution-pipeline.ts";
 import { FusedDiarizer } from "../../../plugins/plugin-local-inference/src/services/voice/speaker/diarizer-fused.ts";
 import { FusedSpeakerEncoder } from "../../../plugins/plugin-local-inference/src/services/voice/speaker/encoder-fused.ts";
-import type { VadDetector } from "../../../plugins/plugin-local-inference/src/services/voice/vad.ts";
-
-// The Silero VAD is exclusively the fused `libelizainference` runtime
-// (`eliza_inference_vad_*`, the `GgmlSileroVad` / `silero-ggml` backend). The
-// two VAD-driven stages below need a live VAD-driven turn segmenter; the
-// AudioFrameConsumer stage is gated as a documented follow-up until this
-// harness drives `GgmlSileroVad` off the fused ctx.
-const FUSED_VAD_AVAILABLE = false;
+import {
+  GgmlSileroVad,
+  VadDetector,
+} from "../../../plugins/plugin-local-inference/src/services/voice/vad.ts";
 
 const REPO_ROOT = path.resolve(import.meta.dir, "../../..");
 const WAV = path.join(
@@ -60,49 +65,104 @@ function arg(name: string): string | undefined {
   return i >= 0 ? process.argv[i + 1] : undefined;
 }
 
+const REQUIRE_REAL =
+  process.argv.includes("--require-real") ||
+  process.env.ELIZA_VOICE_REAL_REQUIRE?.trim() === "1";
+
+function skip(message: string): never {
+  const prefix = REQUIRE_REAL ? "FAIL" : "SKIP";
+  console.log(`[voice-attribution-smoke] ${prefix} — ${message}`);
+  process.exit(REQUIRE_REAL ? 1 : 0);
+}
+
 const modelsDir =
   arg("--models") ??
   process.env.ELIZA_VOICE_REAL_MODEL_DIR?.trim() ??
   "/tmp/voice-models";
+function firstExisting(...parts: string[]): string | null {
+  for (const part of parts) {
+    const p = path.isAbsolute(part) ? part : path.join(modelsDir, part);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
 const M = {
-  vad: path.join(modelsDir, "silero-vad-v5.gguf"),
-  enc: path.join(modelsDir, "wespeaker-resnet34-lm.gguf"),
-  dia: path.join(modelsDir, "pyannote-segmentation-3.0.gguf"),
+  vad: firstExisting(
+    "silero-vad-v5.1.2.ggml.bin",
+    "silero-vad-v5.gguf",
+    "vad/silero-vad-v5.1.2.ggml.bin",
+    "vad/silero-vad-v5.gguf",
+    "voice/vad/silero-vad-v5.1.2.ggml.bin",
+    "bundles/2b/vad/silero-vad-v5.gguf",
+  ),
+  enc: firstExisting(
+    "wespeaker-resnet34-lm.gguf",
+    "speaker/wespeaker-resnet34-lm.gguf",
+    "speaker-encoder/wespeaker-resnet34-lm.gguf",
+    "voice/speaker-encoder/wespeaker-resnet34-lm.gguf",
+  ),
+  dia: firstExisting(
+    "pyannote-segmentation-3.0.gguf",
+    "diariz/pyannote-segmentation-3.0.gguf",
+    "diarizer/pyannote-segmentation-3.0.gguf",
+    "voice/diarizer/pyannote-segmentation-3.0.gguf",
+  ),
 };
 
-if (!existsSync(M.vad) || !existsSync(M.enc) || !existsSync(M.dia)) {
-  console.log(
-    `[voice-attribution-smoke] SKIP — GGUF models not found under ${modelsDir}.\n` +
-      "  Produce them with the converters in packages/native/plugins/<lib>/scripts/ and pass --models <dir>.",
+if (!M.vad || !M.enc || !M.dia) {
+  skip(
+    `GGUF models not found under ${modelsDir}.\n` +
+      "  Expected Silero VAD, WeSpeaker, and pyannote assets; pass --models <dir> or set ELIZA_VOICE_REAL_MODEL_DIR.",
   );
-  process.exit(0);
 }
 
+function stageVoiceBundle(models: { vad: string; enc: string; dia: string }): {
+  root: string;
+  vad: string;
+  enc: string;
+  dia: string;
+} {
+  const root = mkdtempSync(path.join(tmpdir(), "voice-model-bundle-"));
+  const out = {
+    root,
+    vad: path.join(root, "vad", path.basename(models.vad)),
+    enc: path.join(root, "speaker", "wespeaker-resnet34-lm.gguf"),
+    dia: path.join(root, "diariz", "pyannote-segmentation-3.0.gguf"),
+  };
+  mkdirSync(path.dirname(out.vad), { recursive: true });
+  mkdirSync(path.dirname(out.enc), { recursive: true });
+  mkdirSync(path.dirname(out.dia), { recursive: true });
+  copyFileSync(models.vad, out.vad);
+  copyFileSync(models.enc, out.enc);
+  copyFileSync(models.dia, out.dia);
+  return out;
+}
+
+const BUNDLE = stageVoiceBundle(M as { vad: string; enc: string; dia: string });
+
 // Resolve the fused libelizainference. The speaker encoder + diarizer run
 // EXCLUSIVELY through it (the `eliza_inference_speaker_*` / `_diariz_*` ABI off
 // one handle); there is no standalone runtime to fall back to.
 const FUSED_LIB = resolveFusedLibraryPath(modelsDir, process.env);
 if (!FUSED_LIB) {
-  console.log(
-    "[voice-attribution-smoke] SKIP — fused libelizainference not found.\n" +
+  skip(
+    "fused libelizainference not found.\n" +
       "  Set $ELIZA_INFERENCE_LIBRARY (exact) or $ELIZA_INFERENCE_LIB_DIR, or build it via packages/app-core/scripts/build-llama-cpp-mtp.mjs.",
   );
-  process.exit(0);
 }
 const FFI = loadElizaInferenceFfi(FUSED_LIB);
-const FFI_CTX = FFI.create(modelsDir);
+const FFI_CTX = FFI.create(BUNDLE.root);
 if (!FusedSpeakerEncoder.isSupported(FFI)) {
-  console.log(
-    `[voice-attribution-smoke] SKIP — the fused lib at ${FUSED_LIB} (ABI v${FFI.libraryAbiVersion}) lacks the speaker ABI (eliza_inference_speaker_supported() == 0). Rebuild with the WeSpeaker forward graph linked in.`,
+  skip(
+    `the fused lib at ${FUSED_LIB} (ABI v${FFI.libraryAbiVersion}) lacks the speaker ABI (eliza_inference_speaker_supported() == 0). Rebuild with the WeSpeaker forward graph linked in.`,
   );
-  process.exit(0);
 }
 if (!FusedDiarizer.isSupported(FFI)) {
-  console.log(
-    `[voice-attribution-smoke] SKIP — the fused lib at ${FUSED_LIB} (ABI v${FFI.libraryAbiVersion}) lacks the diarizer ABI (eliza_inference_diariz_supported() == 0). Rebuild with the pyannote forward graph linked in.`,
+  skip(
+    `the fused lib at ${FUSED_LIB} (ABI v${FFI.libraryAbiVersion}) lacks the diarizer ABI (eliza_inference_diariz_supported() == 0). Rebuild with the pyannote forward graph linked in.`,
   );
-  process.exit(0);
 }
+const FUSED_VAD_AVAILABLE = GgmlSileroVad.isSupported(FFI);
 
 /** Decode a PCM16 mono WAV → { pcm, sampleRate }. */
 function decodeWavMono(file: string): {
@@ -168,13 +228,43 @@ console.log(
 );
 
 // VAD — fused-only; the fused ffi + ctx are booted above, but the VAD-driven
-// turn-segmentation stage is not wired in this pass. See FUSED_VAD_AVAILABLE.
+// turn-segmentation stage runs through GgmlSileroVad on the same FFI context.
 if (FUSED_VAD_AVAILABLE) {
-  // Re-enable once this harness drives `GgmlSileroVad` off FFI/FFI_CTX.
-} else {
-  console.log(
-    "[voice-attribution-smoke] SKIP VAD stage — fused libelizainference VAD context not booted in this harness.",
+  const vad = await GgmlSileroVad.load({ ffi: FFI, ctx: FFI_CTX });
+  const silence = new Float32Array(vad.windowSamples);
+  let speechMax = 0;
+  for (
+    let off = 0;
+    off + vad.windowSamples <= Math.min(pcm.length, 16_000 * 4);
+    off += vad.windowSamples
+  ) {
+    const p = await vad.process(pcm.subarray(off, off + vad.windowSamples));
+    if (p > speechMax) speechMax = p;
+  }
+  vad.reset();
+  let silenceMax = 0;
+  for (let i = 0; i < 8; i += 1) {
+    const p = await vad.process(silence);
+    if (p > silenceMax) silenceMax = p;
+  }
+  vad.close();
+  ok(
+    "Silero VAD: real speech scores above silence",
+    speechMax > silenceMax && speechMax > 0.2,
+    `speechMax=${speechMax.toFixed(3)} silenceMax=${silenceMax.toFixed(3)}`,
   );
+} else {
+  if (REQUIRE_REAL) {
+    ok(
+      "Silero VAD: fused lib advertises eliza_inference_vad_* support",
+      false,
+      "fused libelizainference does not advertise eliza_inference_vad_* support",
+    );
+  } else {
+    console.log(
+      "[voice-attribution-smoke] SKIP VAD stage — fused libelizainference does not advertise eliza_inference_vad_* support.",
+    );
+  }
 }
 
 // Encoder
@@ -204,6 +294,17 @@ if (FUSED_VAD_AVAILABLE) {
     cos(eA, eB) > 0.78,
     `cos(A,B)=${cos(eA, eB).toFixed(3)}`,
   );
+  const selfVoiceSimilarity = cos(eA, eA2);
+  const selfVoiceSignal = buildVoiceTurnSignal("misheard synthetic echo", {
+    agentSpeaking: true,
+    selfVoiceSimilarity,
+  });
+  ok(
+    "Live selfVoiceSimilarity cosine suppresses an agent-echo turn",
+    selfVoiceSignal.agentShouldSpeak === false &&
+      selfVoiceSignal.source === "client-ambient+self-voice",
+    `selfVoiceSimilarity=${selfVoiceSimilarity.toFixed(4)} source=${selfVoiceSignal.source}`,
+  );
   await enc.dispose();
 }
 
@@ -401,8 +502,7 @@ if (FUSED_VAD_AVAILABLE) {
 //
 // Gated on FUSED_VAD_AVAILABLE: AudioFrameConsumer needs a real VAD to segment
 // turns, and the sole VAD runtime is now the fused libelizainference engine,
-// which requires an EngineVoiceBridge (ffi + ctx) this standalone-model harness
-// does not boot. Follow-up: stand up the bridge and feed `GgmlSileroVad`.
+// which this standalone-model harness now boots from the same FFI context.
 if (FUSED_VAD_AVAILABLE) {
   /** Encode a Float32 [-1,1] window → base64 LE-s16, as the native side does. */
   function encodeFrame(
@@ -428,8 +528,13 @@ if (FUSED_VAD_AVAILABLE) {
     };
   }
 
-  // Fused VAD detector (wired once the bridge is stood up).
-  const detector = null as unknown as VadDetector;
+  const fusedVad = await GgmlSileroVad.load({ ffi: FFI, ctx: FFI_CTX });
+  const detector = new VadDetector(fusedVad, {
+    onsetThreshold: 0.5,
+    pauseHangoverMs: 120,
+    endHangoverMs: 500,
+    minSpeechMs: 250,
+  });
   const encoder = await FusedSpeakerEncoder.load({
     ffi: FFI,
     ctx: FFI_CTX,
@@ -526,6 +631,7 @@ if (FUSED_VAD_AVAILABLE) {
   );
 
   await consumer.close();
+  fusedVad.close();
   await encoder.dispose();
   await diarizer.dispose?.();
 }

package/scripts/voice-duet.mjs

@@ -3,7 +3,7 @@
  * Two-agents-talking-endlessly voice harness for Eliza-1 (`bun run voice:duet`).
  *
  * Agent A and agent B are two `LocalInferenceEngine` instances on the **same
- * tier bundle** (`eliza-1-0_8b` by default, then `eliza-1-2b`) but with
+ * tier bundle** (`eliza-1-2b` by default — the smallest/entry tier) but with
  * **different characters** — A's `replyText` → A's OmniVoice TTS →
  * `InMemoryAudioSink`-shaped `DuetSink` (24 kHz → 16 kHz) → a ring →
  * B's `PushMicSource` → B's VAD + streaming ASR → B's `VoiceTurnController`
@@ -60,7 +60,7 @@ const __filename = fileURLToPath(import.meta.url);
 
 function parseArgs(argv) {
   const out = {
-    model: "eliza-1-0_8b",
+    model: "eliza-1-2b",
     turns: Infinity,
     characterA: null,
     characterB: null,
@@ -126,7 +126,7 @@ function intArg(s) {
 
 const USAGE = `Usage: bun run voice:duet [-- <options>]
 
-  --model <id>            tier bundle (default eliza-1-0_8b; also eliza-1-2b)
+  --model <id>            tier bundle (default eliza-1-2b; also eliza-1-4b)
   --turns <N>             stop after N round-trips (default: endless)
   --character-a <path>    agent A's Character JSON (default: a baked-in persona)
   --character-b <path>    agent B's Character JSON (default: a baked-in persona)
@@ -789,7 +789,7 @@ async function main() {
     let perceived = null;
     if (perceivedRaw) {
       perceived = asrEmotionToTag(perceivedRaw) ?? null;
-      emotionPerceiver = "qwen3-asr-emotion";
+      emotionPerceiver = "local-asr-emotion";
     } else {
       emotionPerceiver = "fallback-classifier:unavailable";
     }
@@ -1039,7 +1039,7 @@ async function main() {
         },
         notes:
           accuracy == null
-            ? "emotionFidelity.accuracy is null — the GGUF-converted Qwen3-ASR did not surface an emotion label in this run and no fallback emotion-from-audio classifier was available; recorded as null per the honesty contract, not fabricated. structured-decode token-savings % is null when the running llama-server's /metrics did not expose the guided-decode counter."
+            ? "emotionFidelity.accuracy is null — the GGUF-converted local ASR did not surface an emotion label in this run and no fallback emotion-from-audio classifier was available; recorded as null per the honesty contract, not fabricated. structured-decode token-savings % is null when the running llama-server's /metrics did not expose the guided-decode counter."
             : `emotionFidelity perceiver: ${emotionPerceiver}.`,
         turns: turnLog,
       };
@@ -1098,7 +1098,7 @@ async function main() {
 }
 
 // ---------------------------------------------------------------------------
-// Best-effort transcript emotion extraction (Qwen3-ASR `<emotion>…</emotion>`
+// Best-effort transcript emotion extraction (local ASR `<emotion>…</emotion>`
 // or a `[emotion:happy]`-style tag, if the GGUF-ASR surfaces one). Returns the
 // raw label or null. Honest: if the transcript has no emotion marker, null —
 // the fidelity metric records "perceiver: fallback-classifier (unavailable)".