Add worker network telemetry to browser evidence

README.md

@@ -104,9 +104,9 @@ Candidate comparisons to run:
 
 For model comparisons, choose the candidate model before **Load models**, run **Run benchmark suite**, add at least three real microphone rows with **Run 3 real-mic series**, then click **Unload models** and choose the next candidate. The benchmark table is preserved across unloads, shows prompt token/build metrics for LLM-backed rows, and **Copy JSON** can export the summary and all rows after the comparison set. For TTS voice/step comparisons, change the voice or step slider after loading and rerun **Run TTS benchmark** plus the text/loopback benchmarks; those values are captured per row.
 
-Use **Download JSON** after benchmark or real-mic runs on the hosted Space to save a timestamped evidence file with the same payload as **Copy JSON** and `window.browserSpeakBench.exportResults()`. The export includes `schemaVersion`, a unique `exportId`, `generatedAt`, `hostMetadata` with the hosted Space commit when the static host exposes it, the current `runtime`, an `evidence` summary for real-mic/hardware-WebGPU/hosted-build readiness, an embedded `evidenceGuide` with the audit command and row requirements, aggregate `summary`, and raw `results`. The **Run evidence capture** button starts a timestamped `browser-speak-evidence-*.json` download when the capture sequence finishes; if the browser blocks the automatic download, **Download JSON** saves the same payload manually. Benchmark rows are also autosaved in browser storage for the current host and Space commit, so a reload during manual evidence capture can restore rows from the same deployed build; **Clear** removes both the visible rows and the saved copy.
+Use **Download JSON** after benchmark or real-mic runs on the hosted Space to save a timestamped evidence file with the same payload as **Copy JSON** and `window.browserSpeakBench.exportResults()`. The export includes `schemaVersion`, a unique `exportId`, `generatedAt`, `hostMetadata` with the hosted Space commit when the static host exposes it, the current `runtime`, a bounded `network` trace of model-worker fetches with benchmark-phase server-inference suspect counts, an `evidence` summary for real-mic/hardware-WebGPU/hosted-build readiness, an embedded `evidenceGuide` with the audit command and row requirements, aggregate `summary`, and raw `results`. Each benchmark row also records worker-network request counts and the recent per-row worker requests when any fetch occurs while the row is active. The **Run evidence capture** button starts a timestamped `browser-speak-evidence-*.json` download when the capture sequence finishes; if the browser blocks the automatic download, **Download JSON** saves the same payload manually. Benchmark rows are also autosaved in browser storage for the current host and Space commit, so a reload during manual evidence capture can restore rows from the same deployed build; **Clear** removes both the visible rows and the saved copy.
 
-Use `node tools/audit-browser-evidence.mjs path/to/browser-speak-benchmarks.json` to audit a JSON file downloaded from the hosted browser UI. This checks that the export came from the static Space revision, reports the page-generated `evidence` summary, verifies that at least three real-mic rows meet the WER/identity/latency gates from raw rows, and verifies that at least one completed row reports hardware WebGPU rather than a software adapter. Browser-downloaded JSON cannot prove no-server network behavior or Chrome launch flags by itself, so pair it with `node tools/run-hosted-smoke.mjs` for network evidence or `node tools/run-real-mic-series.mjs` for harness-collected real-mic provenance.
+Use `node tools/audit-browser-evidence.mjs path/to/browser-speak-benchmarks.json` to audit a JSON file downloaded from the hosted browser UI. This checks that the export came from the static Space revision, reports the page-generated `evidence` summary, verifies that at least three real-mic rows meet the WER/identity/latency gates from raw rows, and verifies that at least one completed row reports hardware WebGPU rather than a software adapter. Browser-downloaded JSON includes worker-side fetch telemetry, but it cannot prove whole-page no-server network behavior or Chrome launch flags by itself, so pair it with `node tools/run-hosted-smoke.mjs` for CDP network evidence or `node tools/run-real-mic-series.mjs` for harness-collected real-mic provenance.
 
 When served from localhost or the hosted Hugging Face Space, the page installs `window.browserSpeakBench` for browser automation. It exposes `loadStack(options)`, `setRuntimeOptions(options)`, `preloadVoice(options)`, `runSuite()`, `runMicSeries()`, `runEvidenceCapture()`, one-off runners such as `runTts()`, `runLoopback()`, and `runWebGpuEvidence()`, `exportResults()`, `downloadResults(options)`, `clearResults()`, `webgpuInfo()`, and `state()`. This lets a Playwright, Puppeteer, or DevTools Protocol harness drive the same UI-backed benchmark paths and collect the same JSON as **Copy JSON**. `setRuntimeOptions()` and `loadStack()` also accept `ttsChunking` so first-response chunk thresholds can be benchmarked without editing source; the exported stack records the active chunk profile. The helper `node tools/run-fake-mic-benchmark.mjs` synthesizes the scripted prompt with local Supertonic, relaunches Chrome with that WAV as `--use-file-for-fake-audio-capture`, and runs three scripted mic rows through getUserMedia, the audio worklet, VAD, STT, LLM, and TTS. Set `BROWSER_SPEAK_REUSE_FAKE_MIC_WAV=true` to reuse an existing fixture WAV and skip the synthesis/load pass during regression checks; row timeouts can be adjusted with `BROWSER_SPEAK_FAKE_MIC_TURN_TIMEOUT_MS` and `BROWSER_SPEAK_FAKE_MIC_ROW_TIMEOUT_MS`. The CDP harnesses use a 60-second protocol watchdog by default, configurable with `BROWSER_SPEAK_CDP_TIMEOUT_MS`, short 5-second status-poll watchdogs, configurable with `BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS`, and a page-unresponsive watchdog, configurable with `BROWSER_SPEAK_PAGE_UNRESPONSIVE_TIMEOUT_MS`, so a slow or wedged browser target produces a controlled failure and cleanup instead of blocking indefinitely. A fake capture file is useful for regression testing the mic pipeline, but real microphone rows are still required before judging conversational quality.
 

app.js

@@ -152,6 +152,8 @@ const HARDWARE_WEBGPU_EVIDENCE_STACK = Object.freeze({
 const MIC_START_TIMEOUT_MS = 15000;
 const WEBGPU_ADAPTER_TIMEOUT_MS = 5000;
 const MIC_LEVEL_UI_INTERVAL_MS = 80;
+const MAX_WORKER_NETWORK_EVENTS = 300;
+const MAX_ROW_WORKER_NETWORK_EVENTS = 40;
 const DEFAULT_TTS_CHUNKING = Object.freeze({
   firstSentenceMinChars: 5,
   sentenceMinChars: 8,
@@ -229,6 +231,8 @@ const state = {
     completed: 0,
     timer: 0,
   },
+  workerNetworkSeq: 0,
+  workerNetworkEvents: [],
   ttsChunking: { ...DEFAULT_TTS_CHUNKING },
   benchmarkResults: [],
 };
@@ -812,7 +816,13 @@ async function resolveDevice() {
 
 function createWorker(path, kind, handler) {
   const worker = new Worker(new URL(path, import.meta.url), { type: "module" });
-  worker.addEventListener("message", handler);
+  worker.addEventListener("message", (event) => {
+    if (event.data?.type === "network") {
+      handleWorkerNetworkEvent(kind, event.data);
+      return;
+    }
+    handler(event);
+  });
   worker.addEventListener("error", (event) => {
     const message = `${path} error: ${event.message || "worker failed to load"}`;
     logEvent(message);
@@ -1448,6 +1458,91 @@ function handleStatus(kind, message) {
   if (message.detail) logEvent(message.detail);
 }
 
+function handleWorkerNetworkEvent(worker, message) {
+  const event = {
+    id: ++state.workerNetworkSeq,
+    capturedAt: new Date().toISOString(),
+    elapsedMs: Math.round(performance.now()),
+    phase: workerNetworkPhase(),
+    worker,
+    method: String(message.method || "GET").toUpperCase(),
+    url: sanitizeNetworkUrl(message.responseUrl || message.url),
+    requestUrl: sanitizeNetworkUrl(message.url),
+    status: Number.isFinite(message.status) ? message.status : null,
+    ok: typeof message.ok === "boolean" ? message.ok : null,
+    durationMs: Number.isFinite(message.durationMs) ? message.durationMs : null,
+    error: message.error ? String(message.error) : "",
+  };
+  event.serverInferenceSuspect = isWorkerServerInferenceSuspect(event);
+  state.workerNetworkEvents.push(event);
+  if (state.workerNetworkEvents.length > MAX_WORKER_NETWORK_EVENTS) {
+    state.workerNetworkEvents.splice(0, state.workerNetworkEvents.length - MAX_WORKER_NETWORK_EVENTS);
+  }
+
+  if (!state.activeBenchmark) return;
+  state.activeBenchmark.workerNetworkRequestCount += 1;
+  if (event.serverInferenceSuspect) state.activeBenchmark.workerNetworkServerInferenceSuspects += 1;
+  state.activeBenchmark.workerNetworkRequests.push(event);
+  if (state.activeBenchmark.workerNetworkRequests.length > MAX_ROW_WORKER_NETWORK_EVENTS) {
+    state.activeBenchmark.workerNetworkRequests.splice(
+      0,
+      state.activeBenchmark.workerNetworkRequests.length - MAX_ROW_WORKER_NETWORK_EVENTS,
+    );
+  }
+}
+
+function workerNetworkPhase() {
+  if (state.modelsLoading) return "load";
+  if (state.activeBenchmark) return "benchmark";
+  if (state.modelsLoaded) return "ready";
+  return "idle";
+}
+
+function sanitizeNetworkUrl(value = "") {
+  const raw = String(value || "");
+  if (!raw) return "";
+  try {
+    const url = new URL(raw, location.href);
+    url.hash = "";
+    url.search = "";
+    return url.href;
+  } catch {
+    return raw.slice(0, 500);
+  }
+}
+
+function isWorkerServerInferenceSuspect(event) {
+  if (!event.url) return false;
+  const lowerUrl = event.url.toLowerCase();
+  if (isKnownModelAssetUrl(lowerUrl)) return false;
+  if (
+    lowerUrl.includes("/v1/chat/completions") ||
+    lowerUrl.includes("/v1/completions") ||
+    lowerUrl.includes("/v1/audio/") ||
+    lowerUrl.includes("/api/inference") ||
+    lowerUrl.includes("/api/pipeline")
+  ) {
+    return true;
+  }
+  return event.phase === "benchmark";
+}
+
+function isKnownModelAssetUrl(value = "") {
+  try {
+    const url = new URL(value);
+    const host = url.hostname.toLowerCase();
+    return (
+      host === "cdn.jsdelivr.net" ||
+      host === "huggingface.co" ||
+      host.endsWith(".huggingface.co") ||
+      host.endsWith(".hf.co") ||
+      host.endsWith(".xethub.hf.co")
+    );
+  } catch {
+    return false;
+  }
+}
+
 function currentBenchmarkStack() {
   return {
     ...state.loadedStack,
@@ -1604,12 +1699,15 @@ function startBenchmark(kind, prompt, { referenceText = "", timeoutMs = 120000 }
     micInputRms: null,
     loopbackSampleRate: null,
     bargeInMs: null,
-    bargeInPass: null,
-    firstAudioMs: null,
-    speechEndToFirstAudioMs: null,
-    decodeRate: "-",
-    llmCompleteMs: null,
-    llmQualityPass: null,
+	    bargeInPass: null,
+	    firstAudioMs: null,
+	    speechEndToFirstAudioMs: null,
+	    workerNetworkRequestCount: 0,
+	    workerNetworkServerInferenceSuspects: 0,
+	    workerNetworkRequests: [],
+	    decodeRate: "-",
+	    llmCompleteMs: null,
+	    llmQualityPass: null,
     llmQualityScore: null,
     llmQualityTotal: APP_IDENTITY_QUALITY_RULES.length,
     llmQualityHits: [],
@@ -1931,6 +2029,7 @@ function benchmarkExportPayload() {
     generatedAt,
     hostMetadata: { ...state.hostMetadata },
     runtime: runtimeEnvironment(),
+    network: workerNetworkSummary(),
     evidence,
     evidenceGuide: browserEvidenceGuide(evidence),
     summary: exportBenchmarkSummary(),
@@ -1982,12 +2081,24 @@ function browserEvidenceGuide(evidence) {
     nextActions: browserEvidenceNextActions(evidence),
     limitations: [
       "Downloaded browser JSON proves page-reported rows and adapter metadata.",
+      "Worker fetch telemetry is bounded and page-reported; hosted CDP smoke is the authoritative whole-page network check.",
       "Pair with hosted smoke for no-server network evidence.",
       "Use the real-mic harness for Chrome launch provenance when fake-capture flags must be ruled out.",
     ],
   };
 }
 
+function workerNetworkSummary() {
+  const events = [...state.workerNetworkEvents];
+  const benchmarkEvents = events.filter((event) => event.phase === "benchmark");
+  return {
+    capturedEvents: events.length,
+    benchmarkRequests: benchmarkEvents.length,
+    benchmarkServerInferenceSuspects: benchmarkEvents.filter((event) => event.serverInferenceSuspect).length,
+    recent: events.slice(-MAX_WORKER_NETWORK_EVENTS),
+  };
+}
+
 function browserEvidenceNextActions(evidence) {
   const actions = [];
   if (!evidence.hosted.passed) {
@@ -2900,9 +3011,10 @@ function automationSnapshot() {
     suiteRunning: state.suiteRunning,
     evidenceCaptureRunning: state.evidenceCaptureRunning,
     micSeries: { ...state.micSeries, timer: Boolean(state.micSeries.timer) },
-    ttsChunking: { ...state.ttsChunking },
-    stack: state.loadedStack ? currentBenchmarkStack() : null,
-    summary: exportBenchmarkSummary(),
+	    ttsChunking: { ...state.ttsChunking },
+	    network: workerNetworkSummary(),
+	    stack: state.loadedStack ? currentBenchmarkStack() : null,
+	    summary: exportBenchmarkSummary(),
     results: [...state.benchmarkResults],
     events: [...elements.eventLog.children].map((item) => item.textContent),
   };

tools/audit-browser-evidence.mjs

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const rawInputPath = process.argv[2] ?? process.env.BROWSER_SPEAK_BROWSER_EXPORT_JSON ?? "";
+const inputPath = rawInputPath ? resolve(rawInputPath) : "";
+const resultPath = resolve(
+  process.env.BROWSER_SPEAK_BROWSER_AUDIT_JSON ?? `${tmpdir()}/browser-speak-browser-evidence-audit.json`,
+);
+const requireRealMic = process.env.BROWSER_SPEAK_BROWSER_AUDIT_REQUIRE_REAL_MIC !== "false";
+const requireHardwareWebgpu = process.env.BROWSER_SPEAK_BROWSER_AUDIT_REQUIRE_HARDWARE_WEBGPU !== "false";
+const minRealMicRows = Math.max(1, Number(process.env.BROWSER_SPEAK_BROWSER_AUDIT_REAL_MIC_ROWS ?? 3));
+const realMicMaxWer = Number(process.env.BROWSER_SPEAK_BROWSER_AUDIT_REAL_MIC_MAX_WER ?? 0.25);
+const expectedHostSuffix = process.env.BROWSER_SPEAK_BROWSER_AUDIT_HOST_SUFFIX ?? ".hf.space";
+
+async function main() {
+  if (!inputPath) {
+    throw new Error(
+      "Pass a downloaded benchmark JSON path, or set BROWSER_SPEAK_BROWSER_EXPORT_JSON.",
+    );
+  }
+  const exportPayload = JSON.parse(await readFile(inputPath, "utf8"));
+  const browserEvidence = evidenceSummaryFromPayload(exportPayload);
+  const checks = [
+    checkExportShape(exportPayload),
+    checkSelfDescription(exportPayload),
+    checkBrowserEvidenceSummary(exportPayload),
+    checkHostedMetadata(exportPayload),
+    checkRealMic(exportPayload),
+    checkHardwareWebgpu(exportPayload),
+  ];
+  const requiredChecks = checks.filter((check) => check.required);
+  const passed = requiredChecks.every((check) => check.status === "pass");
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    passed,
+    inputPath,
+    config: {
+      requireRealMic,
+      requireHardwareWebgpu,
+      minRealMicRows,
+      realMicMaxWer,
+      expectedHostSuffix,
+    },
+    browserEvidence,
+    checks,
+    limitations: [
+      "Downloaded browser benchmark JSON can prove the page-reported runtime, real-mic rows, and WebGPU adapter metadata.",
+      "It cannot prove the absence of server inference by itself; pair it with tools/run-hosted-smoke.mjs or tools/run-client-side-smoke.mjs network evidence.",
+      "It cannot prove Chrome was not launched with fake microphone capture flags; use tools/run-real-mic-series.mjs when that provenance matters.",
+    ],
+  };
+  await mkdir(dirname(resultPath), { recursive: true });
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote browser evidence audit JSON: ${resultPath}`);
+  for (const check of checks) {
+    console.log(`${check.required ? "required" : "supporting"} ${check.status}: ${check.name} - ${check.message}`);
+  }
+  if (!passed) process.exitCode = 1;
+}
+
+function checkExportShape(payload) {
+  const rows = rowsFromPayload(payload);
+  const hostMetadata = hostMetadataFromPayload(payload);
+  const passed =
+    typeof generatedAtFromPayload(payload) === "string" &&
+    summaryFromPayload(payload) &&
+    typeof summaryFromPayload(payload) === "object" &&
+    Array.isArray(rows);
+  return {
+    name: "browser export shape",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? `Export has ${rows.length} benchmark row(s).`
+      : "Export is missing generatedAt, summary, or benchmark rows.",
+    evidence: {
+      generatedAt: generatedAtFromPayload(payload),
+      schemaVersion: schemaVersionFromPayload(payload),
+      exportId: exportIdFromPayload(payload),
+      rowCount: rows.length,
+      summaryScopes: summaryFromPayload(payload) ? Object.keys(summaryFromPayload(payload)) : [],
+      hostMetadata,
+      runtimePresent: Boolean(runtimeFromPayload(payload)),
+      evidenceSummaryPresent: Boolean(evidenceSummaryFromPayload(payload)),
+    },
+  };
+}
+
+function checkSelfDescription(payload) {
+  const schemaVersion = schemaVersionFromPayload(payload);
+  const exportId = exportIdFromPayload(payload);
+  const guide = evidenceGuideFromPayload(payload);
+  const realMic = guide?.requirements?.realMic ?? {};
+  const hardwareWebgpu = guide?.requirements?.hardwareWebgpu ?? {};
+  const passed =
+    typeof schemaVersion === "string" &&
+    schemaVersion.startsWith("browser-speak-benchmarks/") &&
+    typeof exportId === "string" &&
+    exportId.length > 12 &&
+    typeof guide?.auditCommand === "string" &&
+    guide.auditCommand.includes("audit-browser-evidence.mjs") &&
+    realMic.requiredRows >= minRealMicRows &&
+    hardwareWebgpu.requiredRows >= 1;
+  return {
+    name: "browser export self-description",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? `Export ${exportId} declares ${schemaVersion} and embeds audit requirements.`
+      : "Export is missing schemaVersion, exportId, or embedded audit requirements.",
+    evidence: {
+      schemaVersion,
+      exportId,
+      auditCommand: guide?.auditCommand ?? null,
+      realMic,
+      hardwareWebgpu,
+      nextActions: guide?.nextActions ?? [],
+    },
+  };
+}
+
+function checkBrowserEvidenceSummary(payload) {
+  const evidence = evidenceSummaryFromPayload(payload);
+  if (!evidence) {
+    return {
+      name: "browser evidence summary",
+      required: false,
+      status: "missing",
+      message: "Export does not include the page-generated evidence summary.",
+      evidence: {},
+    };
+  }
+  return {
+    name: "browser evidence summary",
+    required: false,
+    status: "pass",
+    message: summaryEvidenceMessage(evidence),
+    evidence,
+  };
+}
+
+function checkHostedMetadata(payload) {
+  const hostMetadata = hostMetadataFromPayload(payload);
+  const evidence = evidenceSummaryFromPayload(payload)?.hosted ?? null;
+  const host = hostMetadata.host ?? "";
+  const hosted = expectedHostSuffix ? host.endsWith(expectedHostSuffix) : Boolean(host);
+  const commit = hostMetadata.hfSpaceCommit ?? "";
+  const passed = hosted && commit.length >= 7;
+  return {
+    name: "hosted Space metadata",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? `Export came from ${host} at Space commit ${commit}.`
+      : "Export is missing hosted Space host or commit metadata.",
+    evidence: { hostMetadata, expectedHostSuffix, browserEvidence: evidence },
+  };
+}
+
+function checkRealMic(payload) {
+  if (!requireRealMic) return skipped("real microphone rows", "Real microphone requirement disabled.");
+  const evidence = evidenceSummaryFromPayload(payload)?.realMic ?? null;
+  const rows = completedRows(payload).filter((row) => row.kind === "mic");
+  const exactRows = rows.filter((row) => row.sttWer === 0).length;
+  const identityPasses = rows.filter((row) => row.llmQualityPass === true).length;
+  const inputRows = rows.filter(hasRealMicInputStats).length;
+  const trackSettingsRows = rows.filter(hasInputTrackSettings).length;
+  const medianWer = median(rows.map((row) => row.sttWer));
+  const medianSpeechEndToFirstAudioMs = median(rows.map((row) => row.speechEndToFirstAudioMs));
+  const passed =
+    rows.length >= minRealMicRows &&
+    inputRows >= minRealMicRows &&
+    identityPasses >= minRealMicRows &&
+    Number.isFinite(medianWer) &&
+    medianWer <= realMicMaxWer &&
+    Number.isFinite(medianSpeechEndToFirstAudioMs);
+  return {
+    name: "real microphone rows",
+    required: true,
+    status: passed ? "pass" : "missing",
+    message: passed
+      ? `${rows.length} completed real-mic row(s), median WER ${formatPercent(
+          medianWer,
+        )}, speech end to first audio ${formatMs(medianSpeechEndToFirstAudioMs)}.`
+      : `Need ${minRealMicRows} completed real-mic row(s) with mic input stats, identity pass, median WER <= ${formatPercent(
+          realMicMaxWer,
+        )}, and finite speech-end-to-audio latency.`,
+    evidence: {
+      rows: rows.length,
+      exactRows,
+      identityPasses,
+      inputRows,
+      trackSettingsRows,
+      medianWer,
+      medianSpeechEndToFirstAudioMs,
+      rowSummaries: rows.slice(0, 8).map((row) => ({
+        id: row.id,
+        sttWer: row.sttWer,
+        transcript: row.transcript,
+        llmQualityPass: row.llmQualityPass,
+        speechEndToFirstAudioMs: row.speechEndToFirstAudioMs,
+        micInputChunks: row.micInputChunks,
+        micInputPeak: row.micInputPeak,
+        inputSampleRate: row.inputSampleRate ?? row.stack?.environment?.inputSampleRate ?? null,
+        inputTrackSettings: row.inputTrackSettings ?? row.stack?.environment?.inputTrackSettings ?? null,
+      })),
+      browserEvidence: evidence,
+    },
+  };
+}
+
+function checkHardwareWebgpu(payload) {
+  if (!requireHardwareWebgpu) return skipped("hardware WebGPU rows", "Hardware WebGPU requirement disabled.");
+  const evidence = evidenceSummaryFromPayload(payload)?.hardwareWebgpu ?? null;
+  const rows = completedRows(payload).filter((row) => row.stack?.device === "webgpu");
+  const hardwareRows = rows.filter((row) => {
+    const environment = row.stack?.environment ?? {};
+    return (
+      environment.webgpuAvailable === true &&
+      environment.webgpuSoftwareAdapter !== true &&
+      !isSoftwareWebGpuAdapter(environment.webgpuAdapter)
+    );
+  });
+  const passed = hardwareRows.length > 0;
+  return {
+    name: "hardware WebGPU rows",
+    required: true,
+    status: passed ? "pass" : "missing",
+    message: passed
+      ? `${hardwareRows.length} completed row(s) used hardware WebGPU.`
+      : "No completed benchmark rows prove hardware WebGPU execution.",
+    evidence: {
+      webgpuRows: rows.length,
+      hardwareRows: hardwareRows.length,
+      adapters: uniqueAdapters(rows),
+      rowKinds: rows.map((row) => row.kind),
+      browserEvidence: evidence,
+    },
+  };
+}
+
+function generatedAtFromPayload(payload) {
+  return payload?.generatedAt ?? payload?.browserExport?.generatedAt ?? null;
+}
+
+function schemaVersionFromPayload(payload) {
+  return payload?.schemaVersion ?? payload?.browserExport?.schemaVersion ?? null;
+}
+
+function exportIdFromPayload(payload) {
+  return payload?.exportId ?? payload?.browserExport?.exportId ?? null;
+}
+
+function evidenceGuideFromPayload(payload) {
+  return payload?.evidenceGuide ?? payload?.browserExport?.evidenceGuide ?? null;
+}
+
+function summaryFromPayload(payload) {
+  return payload?.summary ?? payload?.browserExport?.summary ?? payload?.benchmarkSummary ?? null;
+}
+
+function hostMetadataFromPayload(payload) {
+  return (
+    payload?.hostMetadata ??
+    payload?.browserExport?.hostMetadata ??
+    payload?.runtime?.hostMetadata ??
+    payload?.browserExport?.runtime?.hostMetadata ??
+    {}
+  );
+}
+
+function runtimeFromPayload(payload) {
+  return payload?.runtime ?? payload?.browserExport?.runtime ?? null;
+}
+
+function evidenceSummaryFromPayload(payload) {
+  return payload?.evidence ?? payload?.browserExport?.evidence ?? null;
+}
+
+function rowsFromPayload(payload) {
+  if (Array.isArray(payload?.results)) return payload.results;
+  if (Array.isArray(payload?.benchmarkResults)) return payload.benchmarkResults;
+  if (Array.isArray(payload?.browserExport?.results)) return payload.browserExport.results;
+  return [];
+}
+
+function completedRows(payload) {
+  return rowsFromPayload(payload).filter((row) => !row.error);
+}
+
+function hasRealMicInputStats(row) {
+  return (
+    Number.isFinite(row.micInputChunks) &&
+    row.micInputChunks > 0 &&
+    Number.isFinite(row.micInputPeak) &&
+    row.micInputPeak > 0 &&
+    Number.isFinite(row.inputSampleRate ?? row.stack?.environment?.inputSampleRate)
+  );
+}
+
+function hasInputTrackSettings(row) {
+  const settings = row.inputTrackSettings ?? row.stack?.environment?.inputTrackSettings;
+  return Boolean(settings && typeof settings === "object" && Object.keys(settings).length > 0);
+}
+
+function uniqueAdapters(rows) {
+  const seen = new Set();
+  const adapters = [];
+  for (const row of rows) {
+    const adapter = row.stack?.environment?.webgpuAdapter ?? null;
+    const label = formatAdapter(adapter);
+    if (seen.has(label)) continue;
+    seen.add(label);
+    adapters.push({
+      label,
+      softwareAdapter: row.stack?.environment?.webgpuSoftwareAdapter ?? null,
+      adapter,
+    });
+  }
+  return adapters;
+}
+
+function isSoftwareWebGpuAdapter(adapter) {
+  const text = [adapter?.vendor, adapter?.architecture, adapter?.device, adapter?.description]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  return /\b(swiftshader|llvmpipe|software rasterizer|software adapter|warp)\b/.test(text);
+}
+
+function formatAdapter(adapter) {
+  if (!adapter) return "unknown adapter";
+  return (
+    [adapter.vendor, adapter.architecture, adapter.device, adapter.description]
+      .filter(Boolean)
+      .join(" / ") || "unknown adapter"
+  );
+}
+
+function skipped(name, message) {
+  return { name, required: false, status: "skip", message, evidence: {} };
+}
+
+function summaryEvidenceMessage(evidence) {
+  const parts = [];
+  if (evidence.realMic) {
+    parts.push(
+      `real mic ${evidence.realMic.rows ?? 0}/${evidence.realMic.requiredRows ?? minRealMicRows}`,
+    );
+  }
+  if (evidence.hardwareWebgpu) {
+    parts.push(`hardware WebGPU rows ${evidence.hardwareWebgpu.hardwareRows ?? 0}`);
+  }
+  if (evidence.hosted) {
+    parts.push(evidence.hosted.passed ? `hosted ${evidence.hosted.hfSpaceCommit ?? ""}` : "hosted missing");
+  }
+  return parts.length > 0 ? `Browser summary: ${parts.join(", ")}.` : "Browser evidence summary is present.";
+}
+
+function median(values) {
+  const finite = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (finite.length === 0) return null;
+  const middle = Math.floor(finite.length / 2);
+  if (finite.length % 2 === 1) return finite[middle];
+  return (finite[middle - 1] + finite[middle]) / 2;
+}
+
+function formatMs(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value < 1000) return `${Math.round(value)} ms`;
+  return `${(value / 1000).toFixed(2)} s`;
+}
+
+function formatPercent(value) {
+  if (!Number.isFinite(value)) return "-";
+  return `${Math.round(value * 100)}%`;
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/audit-validation.mjs

@@ -0,0 +1,439 @@
+#!/usr/bin/env node
+import { readFile, writeFile, access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const paths = {
+  clientSide: resolve(process.env.BROWSER_SPEAK_CLIENT_SIDE_JSON ?? `${tmpdir()}/browser-speak-client-side-smoke.json`),
+  loopback: resolve(process.env.BROWSER_SPEAK_LOOPBACK_JSON ?? `${tmpdir()}/browser-speak-loopback-series.json`),
+  fakeMic: resolve(process.env.BROWSER_SPEAK_FAKE_MIC_JSON ?? `${tmpdir()}/browser-speak-fake-mic-results.json`),
+  realMic: resolve(process.env.BROWSER_SPEAK_REAL_MIC_JSON ?? `${tmpdir()}/browser-speak-real-mic-series.json`),
+  webgpu: resolve(process.env.BROWSER_SPEAK_WEBGPU_JSON ?? `${tmpdir()}/browser-speak-webgpu-results.json`),
+  ui: resolve(process.env.BROWSER_SPEAK_UI_JSON ?? `${tmpdir()}/browser-speak-ui-smoke.json`),
+  evidenceExport: resolve(
+    process.env.BROWSER_SPEAK_EVIDENCE_EXPORT_JSON ?? `${tmpdir()}/browser-speak-evidence-export-smoke.json`,
+  ),
+};
+const resultPath = resolve(process.env.BROWSER_SPEAK_AUDIT_JSON ?? `${tmpdir()}/browser-speak-validation-audit.json`);
+const soft = process.env.BROWSER_SPEAK_AUDIT_SOFT === "true";
+const requireRealMic = process.env.BROWSER_SPEAK_AUDIT_REQUIRE_REAL_MIC !== "false";
+const requireHardwareWebgpu = process.env.BROWSER_SPEAK_AUDIT_REQUIRE_HARDWARE_WEBGPU !== "false";
+const realMicMaxWer = Number(process.env.BROWSER_SPEAK_AUDIT_REAL_MIC_MAX_WER ?? 0.25);
+const loopbackMaxMedianWer = Number(process.env.BROWSER_SPEAK_AUDIT_LOOPBACK_MAX_MEDIAN_WER ?? 0);
+let currentSourceFingerprint = null;
+
+async function main() {
+  currentSourceFingerprint = await sourceFingerprint();
+  const artifacts = Object.fromEntries(
+    await Promise.all(Object.entries(paths).map(async ([key, path]) => [key, await readJson(path)])),
+  );
+  const checks = [
+    await checkStaticFiles(),
+    checkUi(artifacts.ui),
+    checkEvidenceExport(artifacts.evidenceExport),
+    checkClientSide(artifacts.clientSide),
+    checkLoopback(artifacts.loopback),
+    checkFirstTtsChunkSafety(artifacts),
+    checkFakeMic(artifacts.fakeMic),
+    checkRealMic(artifacts.realMic),
+    checkHardwareWebgpu(artifacts.webgpu),
+  ];
+  const requiredChecks = checks.filter((check) => check.required);
+  const passed = requiredChecks.every((check) => check.status === "pass");
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: currentSourceFingerprint,
+    passed,
+    paths,
+    checks,
+    nextActions: nextActions(checks),
+  };
+  await mkdir(dirname(resultPath), { recursive: true });
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote validation audit JSON: ${resultPath}`);
+  for (const check of checks) {
+    console.log(`${check.required ? "required" : "supporting"} ${check.status}: ${check.name} - ${check.message}`);
+  }
+  if (!passed && !soft) process.exitCode = 1;
+}
+
+async function checkStaticFiles() {
+  const files = [
+    "index.html",
+    "styles.css",
+    "app.js",
+    "workers/asr-worker.js",
+    "workers/llm-worker.js",
+    "workers/tts-worker.js",
+  ];
+  const missing = [];
+  for (const file of files) {
+    if (!(await exists(file))) missing.push(file);
+  }
+  return {
+    name: "demo files",
+    required: true,
+    status: missing.length === 0 ? "pass" : "fail",
+    message: missing.length === 0 ? "Static demo files are present." : `Missing files: ${missing.join(", ")}.`,
+    evidence: { files, missing },
+  };
+}
+
+function checkUi(artifact) {
+  if (!artifact.ok) return missing("UI smoke", true, artifact, "UI smoke JSON is missing or unreadable.");
+  const freshness = sourceFreshness(artifact);
+  if (!freshness.ok) return stale("UI smoke", true, artifact, freshness.message);
+  const passed = artifact.value?.passed === true;
+  return {
+    name: "UI smoke",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed ? "Desktop/mobile UI smoke passed." : "Desktop/mobile UI smoke has not passed.",
+    evidence: pick(artifact.value, ["passed", "config", "errors"]),
+  };
+}
+
+function checkEvidenceExport(artifact) {
+  if (!artifact.ok) return missing("evidence export smoke", true, artifact, "Evidence export smoke JSON is missing.");
+  const freshness = sourceFreshness(artifact);
+  if (!freshness.ok) return stale("evidence export smoke", true, artifact, freshness.message);
+  const summary = artifact.value?.summary ?? {};
+  const passed =
+    artifact.value?.passed === true &&
+    summary.restoredRows >= 1 &&
+    summary.exportedRows >= 1 &&
+    /^browser-speak-evidence-.*\.json$/.test(summary.downloadName ?? "") &&
+    summary.downloadHrefScheme === "blob" &&
+    summary.clearedRows === 0 &&
+    summary.persistedAfterClear === null;
+  return {
+    name: "evidence export smoke",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? "Autosaved rows restore, evidence JSON download is requested, and Clear removes saved rows."
+      : "Evidence export, autosave restore, or Clear behavior did not pass.",
+    evidence: pick(artifact.value, ["passed", "summary", "error", "config"]),
+  };
+}
+
+function checkClientSide(artifact) {
+  if (!artifact.ok) return missing("client-side/no-server smoke", true, artifact, "Client-side smoke JSON is missing.");
+  const freshness = sourceFreshness(artifact);
+  if (!freshness.ok) return stale("client-side/no-server smoke", true, artifact, freshness.message);
+  const summary = artifact.value?.summary ?? {};
+  const passed =
+    artifact.value?.passed === true &&
+    summary.benchmarkRequests === 0 &&
+    summary.serverInferenceSuspects === 0 &&
+    summary.benchmarkErrors === 0 &&
+    Array.isArray(summary.missingTasks) &&
+    summary.missingTasks.length === 0;
+  return {
+    name: "client-side/no-server smoke",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? "Benchmark phase had no network requests, server-inference suspects, row errors, or missing tasks."
+      : "Client-side smoke did not prove the no-server benchmark phase.",
+    evidence: pick(artifact.value, ["passed", "summary", "error", "config"]),
+  };
+}
+
+function checkLoopback(artifact) {
+  if (!artifact.ok) return missing("loopback stability", true, artifact, "Loopback series JSON is missing.");
+  const freshness = sourceFreshness(artifact);
+  if (!freshness.ok) return stale("loopback stability", true, artifact, freshness.message);
+  const summary = artifact.value?.summary ?? {};
+  const passed =
+    artifact.value?.passed === true &&
+    summary.completedRuns >= 3 &&
+    summary.errorRuns === 0 &&
+    summary.exactTranscriptRuns >= Math.ceil(summary.completedRuns / 2) &&
+    summary.identityPasses >= summary.exactTranscriptRuns &&
+    Number.isFinite(summary.medianWer) &&
+    summary.medianWer <= loopbackMaxMedianWer &&
+    Number.isFinite(summary.medianSpeechEndToFirstAudioMs);
+  return {
+    name: "loopback stability",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? `Synthetic loopback completed 3 rows with median WER ${formatPercent(
+          summary.medianWer,
+        )} and ${summary.exactTranscriptRuns}/${summary.completedRuns} exact transcripts.`
+      : "Loopback stability evidence is missing or below threshold.",
+    evidence: pick(artifact.value, ["passed", "summary", "config", "error"]),
+  };
+}
+
+function checkFirstTtsChunkSafety(artifacts) {
+  const rows = [
+    ...rowsFromArtifact(artifacts.clientSide, "client-side smoke"),
+    ...rowsFromArtifact(artifacts.loopback, "loopback series"),
+    ...rowsFromArtifact(artifacts.fakeMic, "fake microphone"),
+    ...rowsFromArtifact(artifacts.realMic, "real microphone"),
+  ].filter(({ row }) => !row.error && row.firstTtsText);
+  if (rows.length === 0) {
+    return {
+      name: "first TTS chunk safety",
+      required: true,
+      status: "fail",
+      message: "No completed benchmark rows with first TTS chunk text were available.",
+      evidence: {},
+    };
+  }
+  const unsafe = rows.filter(({ row }) => unsafeFirstTtsChunk(row));
+  return {
+    name: "first TTS chunk safety",
+    required: true,
+    status: unsafe.length === 0 ? "pass" : "fail",
+    message:
+      unsafe.length === 0
+        ? `${rows.length} first TTS chunk(s) ended at a safe boundary.`
+        : `${unsafe.length}/${rows.length} first TTS chunk(s) appear to split a word.`,
+    evidence: {
+      checkedRows: rows.length,
+      unsafe: unsafe.slice(0, 8).map(({ source, row }) => ({
+        source,
+        kind: row.kind,
+        firstTtsText: row.firstTtsText,
+        output: row.output,
+        firstTtsBoundaryKind: row.firstTtsBoundaryKind ?? null,
+        firstTtsWordBoundarySafe: row.firstTtsWordBoundarySafe ?? null,
+      })),
+    },
+  };
+}
+
+function checkFakeMic(artifact) {
+  if (!artifact.ok) return missing("fake microphone regression", false, artifact, "Fake mic JSON is missing.");
+  const freshness = sourceFreshness(artifact);
+  const summary = artifact.value?.summary?.current ?? artifact.value?.summary?.all ?? {};
+  const passed =
+    freshness.ok &&
+    summary.micRuns >= 3 &&
+    summary.micMedianWer === 0 &&
+    Number.isFinite(summary.micMedianSpeechEndToFirstAudioMs);
+  return {
+    name: "fake microphone regression",
+    required: false,
+    status: passed ? "pass" : "warn",
+    message: passed
+      ? "Fake mic browser-capture regression has 3 rows and 0% median WER."
+      : freshness.ok
+        ? "Fake mic regression is unavailable or below the expected threshold."
+        : freshness.message,
+    evidence: { summary, freshness },
+  };
+}
+
+function checkRealMic(artifact) {
+  if (!requireRealMic) return skipped("real microphone validation", "Real mic requirement disabled by environment.");
+  if (!artifact.ok) return missing("real microphone validation", true, artifact, "Real human microphone JSON is missing.");
+  if (artifact.value?.dryRun) {
+    return {
+      name: "real microphone validation",
+      required: true,
+      status: "missing",
+      message: "Only a real-mic dry-run artifact exists; no human speech rows were collected.",
+      evidence: pick(artifact.value, ["dryRun", "config", "preflight"]),
+    };
+  }
+  const freshness = sourceFreshness(artifact);
+  if (!freshness.ok) return stale("real microphone validation", true, artifact, freshness.message);
+  const summary = artifact.value?.summary ?? {};
+  const config = artifact.value?.config ?? {};
+  const expected = artifact.value?.config?.count ?? 3;
+  const extraChromeArgs = Array.isArray(config.extraChromeArgs) ? config.extraChromeArgs : [];
+  const fakeCaptureArgs = extraChromeArgs.filter(isFakeCaptureArg);
+  const fakeCaptureAllowed = config.allowFakeCapture === true;
+  const passed =
+    artifact.value?.passed === true &&
+    fakeCaptureArgs.length === 0 &&
+    !fakeCaptureAllowed &&
+    summary.completedRows >= expected &&
+    summary.errorRows === 0 &&
+    summary.identityPasses >= expected &&
+    Number.isFinite(summary.medianSpeechEndToFirstAudioMs) &&
+    Number.isFinite(summary.medianWer) &&
+    summary.medianWer <= realMicMaxWer;
+  return {
+    name: "real microphone validation",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: realMicMessage(passed, fakeCaptureArgs, fakeCaptureAllowed),
+    evidence: { ...pick(artifact.value, ["passed", "summary", "config", "error"]), fakeCaptureArgs },
+  };
+}
+
+function checkHardwareWebgpu(artifact) {
+  if (!requireHardwareWebgpu) return skipped("hardware WebGPU benchmark", "Hardware WebGPU requirement disabled by environment.");
+  if (!artifact.ok) return missing("hardware WebGPU benchmark", true, artifact, "WebGPU benchmark JSON is missing.");
+  const freshness = sourceFreshness(artifact);
+  if (!freshness.ok) return stale("hardware WebGPU benchmark", true, artifact, freshness.message);
+  const webgpu = artifact.value?.webgpu ?? {};
+  const candidates = artifact.value?.candidates ?? [];
+  const completeCandidates = candidates.filter((candidate) => candidate.status === "complete");
+  const passed =
+    artifact.value?.skipped !== true &&
+    webgpu.available === true &&
+    webgpu.softwareAdapter !== true &&
+    completeCandidates.length > 0;
+  return {
+    name: "hardware WebGPU benchmark",
+    required: true,
+    status: passed ? "pass" : "missing",
+    message: passed
+      ? "Hardware WebGPU benchmark completed at least one candidate."
+      : artifact.value?.reason ?? "Hardware WebGPU benchmark has not completed on a real adapter.",
+    evidence: pick(artifact.value, ["skipped", "reason", "webgpu", "candidates", "summary"]),
+  };
+}
+
+function skipped(name, message) {
+  return { name, required: false, status: "skip", message, evidence: {} };
+}
+
+function missing(name, required, artifact, message) {
+  return {
+    name,
+    required,
+    status: "missing",
+    message,
+    evidence: { path: artifact.path, error: artifact.error },
+  };
+}
+
+function stale(name, required, artifact, message) {
+  return {
+    name,
+    required,
+    status: "stale",
+    message,
+    evidence: {
+      path: artifact.path,
+      artifactHash: artifact.value?.sourceFingerprint?.hash ?? null,
+      currentHash: currentSourceFingerprint?.hash ?? null,
+    },
+  };
+}
+
+function nextActions(checks) {
+  const missingNames = checks
+    .filter((check) => check.required && check.status !== "pass")
+    .map((check) => check.name);
+  const actions = [];
+  if (missingNames.includes("real microphone validation") || missingNames.includes("hardware WebGPU benchmark")) {
+    actions.push(
+      "Run node tools/run-hosted-evidence-capture.mjs from a desktop Chrome session with a real microphone and hardware WebGPU to collect hosted browser evidence.",
+    );
+  }
+  return checks
+    .filter((check) => check.required && check.status !== "pass")
+    .map((check) => {
+      if (check.name === "real microphone validation") return "Run node tools/run-real-mic-series.mjs on a machine with a real microphone.";
+      if (check.name === "hardware WebGPU benchmark") return "Run node tools/run-webgpu-benchmark.mjs in a Chrome session exposing a hardware WebGPU adapter.";
+      if (check.name === "client-side/no-server smoke") return "Run node tools/run-client-side-smoke.mjs and inspect /tmp/browser-speak-client-side-smoke.json.";
+      if (check.name === "evidence export smoke") return "Run node tools/run-evidence-export-smoke.mjs and inspect /tmp/browser-speak-evidence-export-smoke.json.";
+      if (check.name === "loopback stability") return "Run node tools/run-loopback-series.mjs and inspect /tmp/browser-speak-loopback-series.json.";
+      if (check.name === "first TTS chunk safety") return "Run the client-side smoke and inspect firstTtsText / firstTtsWordBoundarySafe in benchmark rows.";
+      if (check.name === "UI smoke") return "Run node tools/run-ui-smoke.mjs.";
+      return `Resolve failed check: ${check.name}.`;
+    })
+    .reduce((unique, action) => {
+      if (!unique.includes(action)) unique.push(action);
+      return unique;
+    }, actions);
+}
+
+async function readJson(path) {
+  try {
+    return { ok: true, path, value: JSON.parse(await readFile(path, "utf8")) };
+  } catch (error) {
+    return { ok: false, path, error: error.message };
+  }
+}
+
+async function exists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function pick(value, keys) {
+  if (!value || typeof value !== "object") return {};
+  return Object.fromEntries(keys.filter((key) => key in value).map((key) => [key, value[key]]));
+}
+
+function realMicMessage(passed, fakeCaptureArgs, fakeCaptureAllowed) {
+  if (passed) return "Real human microphone rows meet count, WER, latency, and identity gates.";
+  if (fakeCaptureArgs.length > 0) {
+    return `Real microphone evidence used fake-capture Chrome args: ${fakeCaptureArgs.join(", ")}.`;
+  }
+  if (fakeCaptureAllowed) return "Real microphone evidence was collected with fake capture explicitly allowed.";
+  return "Real human microphone rows are missing or below threshold.";
+}
+
+function sourceFreshness(artifact) {
+  const artifactHash = artifact.value?.sourceFingerprint?.hash;
+  if (!artifactHash) {
+    return { ok: false, message: "Artifact is missing source fingerprint metadata; rerun the harness." };
+  }
+  if (artifactHash !== currentSourceFingerprint?.hash) {
+    return { ok: false, message: "Artifact source fingerprint is stale; rerun the harness." };
+  }
+  return { ok: true, message: "Artifact source fingerprint matches current files." };
+}
+
+function rowsFromArtifact(artifact, source) {
+  if (!artifact.ok || !artifact.value) return [];
+  const rows = [];
+  for (const key of ["benchmarkResults", "rows", "results"]) {
+    if (Array.isArray(artifact.value[key])) {
+      rows.push(...artifact.value[key].map((row) => ({ source, row })));
+    }
+  }
+  return rows;
+}
+
+function unsafeFirstTtsChunk(row) {
+  return row.firstTtsWordBoundarySafe === false || firstTtsLooksMidWord(row);
+}
+
+function firstTtsLooksMidWord(row) {
+  const chunk = String(row.firstTtsText ?? "").trim();
+  const output = String(row.output ?? "").trim();
+  if (!chunk || !output.startsWith(chunk)) return false;
+  const before = chunk.at(-1) ?? "";
+  const after = output[chunk.length] ?? "";
+  return isWordLikeChar(before) && isWordLikeChar(after);
+}
+
+function isFakeCaptureArg(arg) {
+  return (
+    arg === "--use-fake-device-for-media-stream" ||
+    arg.startsWith("--use-file-for-fake-audio-capture=") ||
+    arg.startsWith("--use-file-for-fake-video-capture=")
+  );
+}
+
+function isWordLikeChar(char) {
+  return /[A-Za-z0-9']/.test(char);
+}
+
+function formatPercent(value) {
+  if (!Number.isFinite(value)) return "-";
+  return `${Math.round(value * 100)}%`;
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-client-side-smoke.mjs

@@ -0,0 +1,645 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const resultPath = resolve(
+  process.env.BROWSER_SPEAK_CLIENT_SIDE_JSON ?? `${tmpdir()}/browser-speak-client-side-smoke.json`,
+);
+const profileDir = resolve(
+  process.env.BROWSER_SPEAK_CLIENT_SIDE_PROFILE_DIR ?? `${tmpdir()}/browser-speak-client-side-profile`,
+);
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const pageUnresponsiveTimeoutMs = Number(process.env.BROWSER_SPEAK_PAGE_UNRESPONSIVE_TIMEOUT_MS ?? 120000);
+const loadTimeoutMs = Number(process.env.BROWSER_SPEAK_LOAD_TIMEOUT_MS ?? 600000);
+const taskTimeoutMs = Number(process.env.BROWSER_SPEAK_TASK_TIMEOUT_MS ?? 180000);
+const voicePreloadTimeoutMs = Number(
+  process.env.BROWSER_SPEAK_VOICE_PRELOAD_TIMEOUT_MS ?? Math.max(180000, taskTimeoutMs),
+);
+const reuseProfile = process.env.BROWSER_SPEAK_CLIENT_SIDE_REUSE_PROFILE === "true";
+const ttsWarmup = process.env.BROWSER_SPEAK_TTS_WARMUP === "true";
+const headless = process.env.BROWSER_SPEAK_HEADLESS !== "false";
+const tasks = parseList(process.env.BROWSER_SPEAK_CLIENT_SIDE_TASKS ?? "tts,identity,loopback");
+const stack = {
+  device: process.env.BROWSER_SPEAK_DEVICE ?? "wasm",
+  llm: process.env.BROWSER_SPEAK_LLM ?? "HuggingFaceTB/SmolLM2-135M-Instruct",
+  asr: process.env.BROWSER_SPEAK_ASR ?? "onnx-community/moonshine-base-ONNX",
+  voice: process.env.BROWSER_SPEAK_VOICE ?? "F2",
+  ttsSteps: Number(process.env.BROWSER_SPEAK_TTS_STEPS ?? 2),
+  vadSilenceMs: Number(process.env.BROWSER_SPEAK_VAD_SILENCE_MS ?? 480),
+  partialAsr: process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false",
+  ttsWarmup,
+};
+
+async function main() {
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  if (!reuseProfile) await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9346, profileDir);
+  const recorder = new NetworkRecorder(url);
+  let client = null;
+  try {
+    client = await connectToPage(9346, browser);
+    client.on("Network.requestWillBeSent", (event) => recorder.requestWillBeSent(event));
+    client.on("Network.responseReceived", (event) => recorder.responseReceived(event));
+    client.on("Network.loadingFailed", (event) => recorder.loadingFailed(event));
+    await client.call("Network.enable");
+    await waitForBenchApi(client);
+
+    recorder.markStage("load");
+    await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(stack)})`, {
+      label: "model load",
+      timeoutMs: loadTimeoutMs,
+    });
+    await runPageTask(
+      client,
+      `Promise.all(${JSON.stringify(["F1", "F2", "M1", "M2"])}.map((voice) => window.browserSpeakBench.preloadVoice({ voice, timeoutMs: ${JSON.stringify(voicePreloadTimeoutMs)} })))`,
+      { label: "voice preload", timeoutMs: voicePreloadTimeoutMs },
+    );
+    await runPageTask(client, "window.browserSpeakBench.clearResults()", {
+      label: "clear restored benchmark rows",
+      timeoutMs: 30000,
+    });
+    await sleep(1000);
+
+    recorder.markStage("benchmark");
+    for (const task of tasks) {
+      await runBenchmarkTask(client, task);
+    }
+    await sleep(1500);
+    const snapshot = await runPageTask(client, "window.browserSpeakBench.exportResults()", {
+      label: "export results",
+      timeoutMs: 30000,
+    });
+
+    const requests = recorder.requests();
+    const benchmarkRequests = requests.filter((request) => request.stage === "benchmark");
+    const suspects = benchmarkRequests.flatMap((request) =>
+      classifyRequest(request).map((reason) => ({ reason, request })),
+    );
+    const benchmarkErrors = snapshot.results.filter((result) => result.error);
+    const missingTasks = missingTaskRows(snapshot.results, tasks);
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      sourceFingerprint: await sourceFingerprint(),
+      url,
+      passed: suspects.length === 0 && benchmarkErrors.length === 0 && missingTasks.length === 0,
+      config: {
+        stack,
+        tasks,
+        loadTimeoutMs,
+        taskTimeoutMs,
+        voicePreloadTimeoutMs,
+        protocolTimeoutMs,
+        pollTimeoutMs,
+        pageUnresponsiveTimeoutMs,
+        reuseProfile,
+        headless,
+        chrome,
+        extraChromeArgs: parseChromeArgs(),
+      },
+      summary: {
+        totalRequests: requests.length,
+        loadRequests: requests.filter((request) => request.stage === "load").length,
+        benchmarkRequests: benchmarkRequests.length,
+        benchmarkHosts: summarizeHosts(benchmarkRequests),
+        benchmarkMethods: summarizeMethods(benchmarkRequests),
+        serverInferenceSuspects: suspects.length,
+        benchmarkErrors: benchmarkErrors.length,
+        missingTasks,
+      },
+      suspects,
+      benchmarkErrors,
+      requests,
+      browserExport: snapshot,
+      browserExportMetadata: exportMetadata(snapshot),
+      hostMetadata: snapshot.hostMetadata ?? null,
+      benchmarkResults: snapshot.results,
+      benchmarkSummary: snapshot.summary,
+    };
+    await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+    console.log(`Wrote client-side smoke JSON: ${resultPath}`);
+    console.log(
+      `Benchmark network requests: ${benchmarkRequests.length}, server-inference suspects: ${suspects.length}.`,
+    );
+    for (const suspect of suspects.slice(0, 8)) {
+      console.log(`${suspect.reason}: ${suspect.request.method} ${suspect.request.url}`);
+    }
+    for (const errorRow of benchmarkErrors.slice(0, 8)) {
+      console.log(`${errorRow.kind} benchmark error: ${errorRow.error}`);
+    }
+    for (const missingTask of missingTasks) {
+      console.log(`Missing benchmark row for task: ${missingTask}`);
+    }
+    if (!payload.passed) process.exitCode = 1;
+    await client.closeBrowser();
+  } catch (error) {
+    await writeFailurePayload(error, recorder, browser).catch((writeError) => {
+      console.error(`Could not write client-side smoke failure JSON: ${writeError.message}`);
+    });
+    if (client) await client.closeBrowser().catch(() => {});
+    throw error;
+  } finally {
+    await stopBrowser(browser, reuseProfile ? null : profileDir);
+  }
+}
+
+async function writeFailurePayload(error, recorder, browser = null) {
+  const requests = recorder.requests();
+  const benchmarkRequests = requests.filter((request) => request.stage === "benchmark");
+  const suspects = benchmarkRequests.flatMap((request) =>
+    classifyRequest(request).map((reason) => ({ reason, request })),
+  );
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    url,
+    passed: false,
+    error: error.stack ?? error.message ?? String(error),
+    browserLog: browser?.browserLog ?? "",
+    config: {
+      stack,
+      tasks,
+      loadTimeoutMs,
+      taskTimeoutMs,
+      voicePreloadTimeoutMs,
+      protocolTimeoutMs,
+      pollTimeoutMs,
+      pageUnresponsiveTimeoutMs,
+      reuseProfile,
+      headless,
+      chrome,
+      extraChromeArgs: parseChromeArgs(),
+    },
+    summary: {
+      totalRequests: requests.length,
+      loadRequests: requests.filter((request) => request.stage === "load").length,
+      benchmarkRequests: benchmarkRequests.length,
+      benchmarkHosts: summarizeHosts(benchmarkRequests),
+      benchmarkMethods: summarizeMethods(benchmarkRequests),
+      serverInferenceSuspects: suspects.length,
+      benchmarkErrors: null,
+      missingTasks: [],
+    },
+    suspects,
+    requests,
+  };
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote client-side smoke failure JSON: ${resultPath}`);
+}
+
+async function runBenchmarkTask(client, task) {
+  const normalized = task.toLowerCase();
+  const loopbackOptions = {
+    timeoutMs: 180000,
+    ...(process.env.BROWSER_SPEAK_LOOPBACK_TEXT ? { text: process.env.BROWSER_SPEAK_LOOPBACK_TEXT } : {}),
+    ...(Number.isFinite(Number(process.env.BROWSER_SPEAK_LOOPBACK_SPEED))
+      ? { speed: Number(process.env.BROWSER_SPEAK_LOOPBACK_SPEED) }
+      : {}),
+  };
+  const expression = {
+    tts: "window.browserSpeakBench.runTts({ timeoutMs: 90000 })",
+    identity: "window.browserSpeakBench.runIdentity({ timeoutMs: 180000 })",
+    chat: "window.browserSpeakBench.runChat({ timeoutMs: 180000 })",
+    loopback: `window.browserSpeakBench.runLoopback(${JSON.stringify(loopbackOptions)})`,
+    barge: "window.browserSpeakBench.runBargeIn({ timeoutMs: 90000 })",
+    "barge-in": "window.browserSpeakBench.runBargeIn({ timeoutMs: 90000 })",
+  }[normalized];
+  if (!expression) throw new Error(`Unknown client-side smoke task: ${task}`);
+  await runPageTask(client, expression, {
+    label: `${normalized} benchmark`,
+    timeoutMs: normalized === "loopback" ? Math.max(taskTimeoutMs, 240000) : taskTimeoutMs,
+  });
+}
+
+function exportMetadata(snapshot) {
+  if (!snapshot || typeof snapshot !== "object") return null;
+  return {
+    schemaVersion: snapshot.schemaVersion ?? null,
+    exportId: snapshot.exportId ?? null,
+    generatedAt: snapshot.generatedAt ?? null,
+    hostMetadata: snapshot.hostMetadata ?? null,
+    runtime: snapshot.runtime ?? null,
+    evidence: snapshot.evidence ?? null,
+    evidenceGuide: snapshot.evidenceGuide ?? null,
+    summary: snapshot.summary ?? null,
+    resultCount: Array.isArray(snapshot.results) ? snapshot.results.length : null,
+  };
+}
+
+function missingTaskRows(results, requestedTasks) {
+  const aliases = new Map([
+    ["barge", "barge-in"],
+    ["barge-in", "barge-in"],
+  ]);
+  const kinds = new Set(results.map((result) => result.kind));
+  return requestedTasks
+    .map((task) => task.toLowerCase())
+    .map((task) => aliases.get(task) ?? task)
+    .filter((kind, index, requestedKinds) => requestedKinds.indexOf(kind) === index)
+    .filter((kind) => !kinds.has(kind));
+}
+
+function classifyRequest(request) {
+  const reasons = [];
+  const parsed = new URL(request.url);
+  const host = parsed.hostname.toLowerCase();
+  const path = parsed.pathname.toLowerCase();
+  const method = request.method.toUpperCase();
+  if (!["GET", "HEAD"].includes(method)) reasons.push(`non-asset HTTP method ${method}`);
+  if (isForbiddenHost(host)) reasons.push(`forbidden inference host ${host}`);
+  if (isInferencePath(path)) reasons.push(`inference-like path ${parsed.pathname}`);
+  if (!isAllowedHost(host)) reasons.push(`unexpected host ${host}`);
+  return reasons;
+}
+
+function isAllowedHost(host) {
+  if (["localhost", "127.0.0.1", "::1"].includes(host)) return true;
+  if (host === "cdn.jsdelivr.net") return true;
+  if (host === "huggingface.co" || host.endsWith(".huggingface.co")) return true;
+  if (host === "hf.co" || host.endsWith(".hf.co")) return true;
+  if (host === "xethub.hf.co" || host.endsWith(".xethub.hf.co")) return true;
+  return false;
+}
+
+function isForbiddenHost(host) {
+  return /(^|\.)api-inference\.huggingface\.co$/.test(host) || /(^|\.)router\.hf\.co$/.test(host);
+}
+
+function isInferencePath(path) {
+  return /\/(chat\/completions|completions|generate|predictions|queue\/(join|data)|run\/predict|api\/predict|v1\/)/.test(
+    path,
+  );
+}
+
+function summarizeHosts(requests) {
+  return summarize(requests.map((request) => new URL(request.url).hostname.toLowerCase()));
+}
+
+function summarizeMethods(requests) {
+  return summarize(requests.map((request) => request.method.toUpperCase()));
+}
+
+function summarize(values) {
+  const counts = new Map();
+  for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
+  return Object.fromEntries([...counts.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+
+class NetworkRecorder {
+  constructor(pageUrl) {
+    this.pageOrigin = new URL(pageUrl).origin;
+    this.stage = "startup";
+    this.byId = new Map();
+  }
+
+  markStage(stage) {
+    this.stage = stage;
+  }
+
+  requestWillBeSent(event) {
+    const request = event.request;
+    if (!request?.url || shouldIgnoreUrl(request.url)) return;
+    this.byId.set(event.requestId, {
+      stage: this.stage,
+      requestId: event.requestId,
+      url: request.url,
+      method: request.method ?? "GET",
+      resourceType: event.type ?? "",
+      initiatorType: event.initiator?.type ?? "",
+      hasPostData: Boolean(request.hasPostData),
+      status: null,
+      failed: false,
+      failureText: "",
+    });
+  }
+
+  responseReceived(event) {
+    const item = this.byId.get(event.requestId);
+    if (!item) return;
+    item.status = event.response?.status ?? null;
+    item.mimeType = event.response?.mimeType ?? "";
+    item.fromDiskCache = Boolean(event.response?.fromDiskCache);
+    item.fromServiceWorker = Boolean(event.response?.fromServiceWorker);
+  }
+
+  loadingFailed(event) {
+    const item = this.byId.get(event.requestId);
+    if (!item) return;
+    item.failed = true;
+    item.failureText = event.errorText ?? "";
+  }
+
+  requests() {
+    return [...this.byId.values()].sort((a, b) => a.requestId.localeCompare(b.requestId));
+  }
+}
+
+function shouldIgnoreUrl(rawUrl) {
+  return /^(data|blob|devtools):/i.test(rawUrl);
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+async function waitForBenchApi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      if (await client.evaluate("Boolean(window.browserSpeakBench)")) return;
+    } catch {
+      // The target may still be navigating.
+    }
+    await sleep(100);
+  }
+  throw new Error("window.browserSpeakBench was not installed.");
+}
+
+async function runPageTask(client, expression, { label = "page task", timeoutMs = 30000 } = {}) {
+  const taskId = `task_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  await client.evaluate(`(() => {
+    const taskId = ${JSON.stringify(taskId)};
+    window.__browserSpeakHarnessTasks ||= {};
+    window.__browserSpeakHarnessTasks[taskId] = { done: false, label: ${JSON.stringify(label)} };
+    Promise.resolve(${expression})
+      .then((value) => {
+        window.__browserSpeakHarnessTasks[taskId] = { done: true, value };
+      })
+      .catch((error) => {
+        window.__browserSpeakHarnessTasks[taskId] = {
+          done: true,
+          error: error?.stack || error?.message || String(error),
+        };
+      });
+    return true;
+  })()`);
+  const deadline = Date.now() + timeoutMs;
+  let lastEvents = [];
+  let lastPollError = "";
+  let pollErrorSince = 0;
+  while (Date.now() < deadline) {
+    let task = null;
+    try {
+      task = await client.evaluate(
+        `window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}] ?? null`,
+        pollTimeoutMs,
+      );
+      lastPollError = "";
+      pollErrorSince = 0;
+    } catch (error) {
+      const message = error.message ?? String(error);
+      pollErrorSince ||= Date.now();
+      if (message !== lastPollError) {
+        console.log(`${label}: waiting for page response (${message})`);
+        lastPollError = message;
+      }
+      if (Date.now() - pollErrorSince > pageUnresponsiveTimeoutMs) {
+        throw new Error(
+          `${label} page stayed unresponsive for ${(pageUnresponsiveTimeoutMs / 1000).toFixed(0)} seconds; last poll error: ${message}`,
+        );
+      }
+      await sleep(500);
+      continue;
+    }
+    if (task?.done) {
+      await client
+        .evaluate(`delete window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}]`, pollTimeoutMs)
+        .catch(() => {});
+      if (task.error) throw new Error(`${label} failed: ${task.error}`);
+      return task.value;
+    }
+    const snapshot = await client
+      .evaluate(`(() => {
+        const state = window.browserSpeakBench?.state?.();
+        return state ? {
+          modelsLoaded: state.modelsLoaded,
+          modelsLoading: state.modelsLoading,
+          activeBenchmark: state.activeBenchmark?.kind ?? null,
+          events: state.events?.slice(0, 3) ?? [],
+        } : null;
+      })()`, pollTimeoutMs)
+      .catch(() => null);
+    const events = snapshot?.events ?? [];
+    if (events.join("\\n") !== lastEvents.join("\\n")) {
+      lastEvents = events;
+      if (events[0]) console.log(`${label}: ${events[0]}`);
+    }
+    await sleep(500);
+  }
+  throw new Error(`${label} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage",
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  if (!profileDir) return;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+      method,
+    }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page" && target.url === url);
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.listeners = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  on(method, handler) {
+    if (!this.listeners.has(method)) this.listeners.set(method, new Set());
+    this.listeners.get(method).add(handler);
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (message.id && this.pending.has(message.id)) {
+      const { resolve: onResolve, reject } = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      if (message.error) reject(new Error(message.error.message));
+      else onResolve(message.result);
+      return;
+    }
+    if (message.method && this.listeners.has(message.method)) {
+      for (const handler of this.listeners.get(message.method)) handler(message.params ?? {});
+    }
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call(
+      "Runtime.evaluate",
+      {
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+      },
+      timeoutMs,
+    );
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  async closeBrowser() {
+    await this.call("Browser.close", {}, 5000).catch(() => {});
+    try {
+      this.socket.close();
+    } catch {
+      // Ignore close races.
+    }
+  }
+}
+
+function formatException(exceptionDetails) {
+  const exception = exceptionDetails.exception;
+  return exception?.description ?? exception?.value ?? exceptionDetails.text ?? "Evaluation failed.";
+}
+
+function parseList(value) {
+  return String(value ?? "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseChromeArgs() {
+  const raw = process.env.BROWSER_SPEAK_CHROME_ARGS ?? "";
+  return (
+    raw
+      .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+      ?.map((arg) => arg.replace(/^["']|["']$/g, "")) ?? []
+  );
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-evidence-export-smoke.mjs

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const resultPath = resolve(
+  process.env.BROWSER_SPEAK_EVIDENCE_EXPORT_JSON ?? `${tmpdir()}/browser-speak-evidence-export-smoke.json`,
+);
+const profileDir = resolve(
+  process.env.BROWSER_SPEAK_EVIDENCE_EXPORT_PROFILE_DIR ??
+    `${tmpdir()}/browser-speak-evidence-export-profile`,
+);
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const headless = process.env.BROWSER_SPEAK_HEADLESS !== "false";
+
+async function main() {
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9349, profileDir);
+  let client = null;
+  try {
+    client = await connectToPage(9349, browser);
+    await client.call("Page.enable");
+    await client.call("Runtime.enable");
+    await waitForBenchApi(client);
+
+    const initialExport = await waitForHostMetadata(client);
+    const pageScope = await client.evaluate("location.origin + location.pathname", pollTimeoutMs);
+    const scope = `${pageScope}#${initialExport.hostMetadata?.hfSpaceCommit || "local"}`;
+    const seed = seedStoragePayload(scope, initialExport.hostMetadata);
+    await client.evaluate(
+      `localStorage.setItem("browser-speak:benchmark-results:v1", ${JSON.stringify(
+        JSON.stringify(seed),
+      )})`,
+      pollTimeoutMs,
+    );
+    await client.call("Page.reload", { ignoreCache: true });
+    await waitForBenchApi(client);
+    const restoredRows = await waitForValue(
+      client,
+      "window.browserSpeakBench.state().results.length",
+      (value) => value === seed.results.length,
+      10000,
+    );
+
+    await client.evaluate(
+      `(() => {
+        window.__browserSpeakDownloadClicks = [];
+        HTMLAnchorElement.prototype.__browserSpeakOriginalClick ??= HTMLAnchorElement.prototype.click;
+        HTMLAnchorElement.prototype.click = function patchedClick() {
+          window.__browserSpeakDownloadClicks.push({
+            download: this.download,
+            href: this.href,
+          });
+          return true;
+        };
+        return true;
+      })()`,
+      pollTimeoutMs,
+    );
+    await client.evaluate(
+      `window.browserSpeakBench.downloadResults({
+        prefix: "browser-speak-evidence",
+        message: "Evidence JSON download smoke."
+      })`,
+      pollTimeoutMs,
+    );
+    const clicks = await client.evaluate("window.__browserSpeakDownloadClicks", pollTimeoutMs);
+    const exportPayload = await client.evaluate("window.browserSpeakBench.exportResults()", pollTimeoutMs);
+    const exportSelfDescription = validateExportSelfDescription(exportPayload);
+
+    await client.evaluate("window.browserSpeakBench.clearResults()", pollTimeoutMs);
+    const clearedRows = await client.evaluate("window.browserSpeakBench.state().results.length", pollTimeoutMs);
+    const persistedAfterClear = await client.evaluate(
+      'localStorage.getItem("browser-speak:benchmark-results:v1")',
+      pollTimeoutMs,
+    );
+
+    const download = Array.isArray(clicks) ? clicks.find((click) => /^browser-speak-evidence-.*\.json$/.test(click.download)) : null;
+    const passed =
+      restoredRows === seed.results.length &&
+      exportPayload?.results?.length === seed.results.length &&
+      exportSelfDescription.passed &&
+      Boolean(download) &&
+      String(download?.href ?? "").startsWith("blob:") &&
+      clearedRows === 0 &&
+      persistedAfterClear === null;
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      sourceFingerprint: await sourceFingerprint(),
+      url,
+      passed,
+      config: {
+        chrome,
+        headless,
+        protocolTimeoutMs,
+        pollTimeoutMs,
+        profileDir,
+        extraChromeArgs: parseChromeArgs(),
+      },
+      summary: {
+        restoredRows,
+        exportedRows: exportPayload?.results?.length ?? null,
+        downloadName: download?.download ?? null,
+        downloadHrefScheme: String(download?.href ?? "").split(":")[0] || null,
+        schemaVersion: exportPayload?.schemaVersion ?? null,
+        exportId: exportPayload?.exportId ?? null,
+        evidenceGuidePresent: Boolean(exportPayload?.evidenceGuide),
+        networkSummaryPresent: Boolean(exportPayload?.network),
+        workerNetworkCapturedEvents: exportPayload?.network?.capturedEvents ?? null,
+        benchmarkWorkerNetworkRequests: exportPayload?.network?.benchmarkRequests ?? null,
+        benchmarkWorkerNetworkSuspects: exportPayload?.network?.benchmarkServerInferenceSuspects ?? null,
+        selfDescription: exportSelfDescription,
+        clearedRows,
+        persistedAfterClear,
+      },
+      clicks,
+      exportMetadata: {
+        generatedAt: exportPayload?.generatedAt ?? null,
+        schemaVersion: exportPayload?.schemaVersion ?? null,
+        exportId: exportPayload?.exportId ?? null,
+        evidenceGuide: exportPayload?.evidenceGuide ?? null,
+        hostMetadata: exportPayload?.hostMetadata ?? null,
+        evidence: exportPayload?.evidence ?? null,
+        resultCount: exportPayload?.results?.length ?? null,
+      },
+    };
+    await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+    console.log(`Wrote evidence export smoke JSON: ${resultPath}`);
+    console.log(
+      passed
+        ? `Evidence export smoke passed: restored ${restoredRows} row(s), download ${download.download}, clear removed saved rows.`
+        : "Evidence export smoke failed.",
+    );
+    if (!passed) process.exitCode = 1;
+    await client.closeBrowser();
+  } catch (error) {
+    await writeFailurePayload(error, browser).catch(() => {});
+    if (client) await client.closeBrowser().catch(() => {});
+    throw error;
+  } finally {
+    await stopBrowser(browser, profileDir);
+  }
+}
+
+function seedStoragePayload(scope, hostMetadata = {}) {
+  return {
+    version: 1,
+    scope,
+    savedAt: new Date().toISOString(),
+    hostMetadata: {
+      page: hostMetadata.page ?? url,
+      host: hostMetadata.host ?? new URL(url).host,
+      hfSpaceCommit: hostMetadata.hfSpaceCommit ?? "",
+      etag: hostMetadata.etag ?? "",
+      fetchedAt: hostMetadata.fetchedAt ?? new Date().toISOString(),
+    },
+    results: [
+      {
+        id: 1,
+        kind: "identity",
+        startedAt: new Date().toISOString(),
+        stack: {
+          device: "wasm",
+          llm: "HuggingFaceTB/SmolLM2-135M-Instruct",
+          voice: "F2",
+          ttsSteps: 2,
+          environment: {},
+        },
+        prompt: "What app is this?",
+        output: "This browser demo runs speech recognition, a local LLM, and Supertonic TTS client-side.",
+        llmQualityPass: true,
+        llmQualityScore: 4,
+        llmQualityTotal: 4,
+        error: "",
+      },
+    ],
+  };
+}
+
+function validateExportSelfDescription(exportPayload) {
+  const guide = exportPayload?.evidenceGuide ?? {};
+  const realMic = guide.requirements?.realMic ?? {};
+  const hardwareWebgpu = guide.requirements?.hardwareWebgpu ?? {};
+  const errors = [];
+  if (!String(exportPayload?.schemaVersion ?? "").startsWith("browser-speak-benchmarks/")) {
+    errors.push("missing schemaVersion");
+  }
+  if (!String(exportPayload?.exportId ?? "").startsWith("browser-speak-")) {
+    errors.push("missing exportId");
+  }
+  if (!String(guide.auditCommand ?? "").includes("audit-browser-evidence.mjs")) {
+    errors.push("missing audit command");
+  }
+  if (realMic.requiredRows !== 3 || realMic.prompt !== "What app is this?") {
+    errors.push("missing real-mic requirements");
+  }
+  if (hardwareWebgpu.requiredRows !== 1) {
+    errors.push("missing hardware-WebGPU requirements");
+  }
+  if (!exportPayload?.network || typeof exportPayload.network.benchmarkServerInferenceSuspects !== "number") {
+    errors.push("missing worker-network summary");
+  }
+  return {
+    passed: errors.length === 0,
+    errors,
+  };
+}
+
+async function writeFailurePayload(error, browser = null) {
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint().catch(() => null),
+    url,
+    passed: false,
+    error: error.stack ?? error.message ?? String(error),
+    browserLog: browser?.browserLog ?? "",
+    config: {
+      chrome,
+      headless,
+      protocolTimeoutMs,
+      pollTimeoutMs,
+      profileDir,
+      extraChromeArgs: parseChromeArgs(),
+    },
+  };
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote evidence export smoke failure JSON: ${resultPath}`);
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-dev-shm-usage",
+      "--no-default-browser-check",
+      "--no-first-run",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+      url,
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function connectToPage(port, browser) {
+  const deadline = Date.now() + 15000;
+  let lastError = "";
+  while (Date.now() < deadline) {
+    try {
+      const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+      const page = targets.find((target) => target.type === "page" && target.webSocketDebuggerUrl);
+      if (page) return new CdpClient(page.webSocketDebuggerUrl, browser);
+    } catch (error) {
+      lastError = error.message;
+    }
+    await sleep(100);
+  }
+  throw new Error(`Could not connect to Chrome DevTools. ${lastError}`.trim());
+}
+
+class CdpClient {
+  constructor(wsUrl, browser) {
+    this.ws = new WebSocket(wsUrl);
+    this.browser = browser;
+    this.nextId = 0;
+    this.pending = new Map();
+    this.ready = new Promise((resolve, reject) => {
+      this.ws.addEventListener("open", resolve, { once: true });
+      this.ws.addEventListener("error", () => reject(new Error("WebSocket connection failed")), { once: true });
+    });
+    this.ws.addEventListener("message", (event) => {
+      const message = JSON.parse(event.data);
+      if (!message.id || !this.pending.has(message.id)) return;
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      clearTimeout(pending.timeout);
+      if (message.error) pending.reject(new Error(message.error.message));
+      else pending.resolve(message.result);
+    });
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.ready;
+    const id = ++this.nextId;
+    this.ws.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timeout });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call(
+      "Runtime.evaluate",
+      {
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+      },
+      timeoutMs,
+    );
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.exception?.description ?? result.exceptionDetails.text);
+    }
+    return result.result.value;
+  }
+
+  async closeBrowser() {
+    await this.call("Browser.close", {}, 5000).catch(() => {});
+    this.ws.close();
+  }
+}
+
+async function waitForBenchApi(client) {
+  await waitForValue(
+    client,
+    "Boolean(window.browserSpeakBench?.downloadResults && window.browserSpeakBench?.clearResults)",
+    Boolean,
+    15000,
+  );
+}
+
+async function waitForHostMetadata(client) {
+  const needsHostedCommit = await client.evaluate('location.hostname.endsWith(".hf.space")', pollTimeoutMs);
+  return waitForValue(
+    client,
+    "window.browserSpeakBench.exportResults()",
+    (payload) => {
+      const metadata = payload?.hostMetadata ?? {};
+      return Boolean(metadata.fetchedAt) && (!needsHostedCommit || String(metadata.hfSpaceCommit ?? "").length >= 7);
+    },
+    15000,
+  );
+}
+
+async function waitForValue(client, expression, predicate, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const value = await client.evaluate(expression, pollTimeoutMs).catch(() => undefined);
+    if (predicate(value)) return value;
+    await sleep(100);
+  }
+  throw new Error(`Timed out waiting for ${expression}`);
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      return;
+    } catch (error) {
+      if (attempt === 9) throw error;
+      await sleep(200);
+    }
+  }
+}
+
+function parseChromeArgs() {
+  return (process.env.BROWSER_SPEAK_CHROME_ARGS ?? "")
+    .split(/\s+/)
+    .map((arg) => arg.trim())
+    .filter(Boolean);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-fake-mic-benchmark.mjs

@@ -0,0 +1,485 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const prompt = process.env.BROWSER_SPEAK_PROMPT ?? "What app is this?";
+const fixturePath = resolve(process.env.BROWSER_SPEAK_FAKE_MIC_WAV ?? `${tmpdir()}/browser-speak-what-app-is-this.wav`);
+const resultPath = resolve(process.env.BROWSER_SPEAK_FAKE_MIC_JSON ?? `${tmpdir()}/browser-speak-fake-mic-results.json`);
+const profileDir = resolve(process.env.BROWSER_SPEAK_PROFILE_DIR ?? `${tmpdir()}/browser-speak-benchmark-profile`);
+const reuseFixture = process.env.BROWSER_SPEAK_REUSE_FAKE_MIC_WAV === "true";
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const fakeMicTurnTimeoutMs = Number(process.env.BROWSER_SPEAK_FAKE_MIC_TURN_TIMEOUT_MS ?? 80000);
+const fakeMicRowTimeoutMs = Number(
+  process.env.BROWSER_SPEAK_FAKE_MIC_ROW_TIMEOUT_MS ?? fakeMicTurnTimeoutMs + 30000,
+);
+const stack = {
+  device: process.env.BROWSER_SPEAK_DEVICE ?? "wasm",
+  llm: process.env.BROWSER_SPEAK_LLM ?? "HuggingFaceTB/SmolLM2-135M-Instruct",
+  asr: process.env.BROWSER_SPEAK_ASR ?? "onnx-community/moonshine-base-ONNX",
+  voice: process.env.BROWSER_SPEAK_VOICE ?? "F2",
+  ttsSteps: Number(process.env.BROWSER_SPEAK_TTS_STEPS ?? 2),
+  vadSilenceMs: Number(process.env.BROWSER_SPEAK_VAD_SILENCE_MS ?? 480),
+  partialAsr: process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false",
+};
+
+async function main() {
+  await ensureServer();
+  await mkdir(dirname(fixturePath), { recursive: true });
+  await mkdir(dirname(resultPath), { recursive: true });
+
+  await rm(profileDir, { recursive: true, force: true });
+  if (reuseFixture && existsSync(fixturePath)) {
+    console.log(`Reusing fake microphone fixture: ${fixturePath}`);
+  } else {
+    const fixtureBrowser = launchBrowser(9341, profileDir);
+    try {
+      const client = await connectToPage(9341, fixtureBrowser);
+      await waitForBenchApi(client);
+      await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(stack)})`, {
+        label: "fixture model load",
+        timeoutMs: 240000,
+      });
+      const fixture = await runPageTask(
+        client,
+        `window.browserSpeakBench.synthesizeAudio(${JSON.stringify({ text: prompt, voice: stack.voice, steps: 2, speed: 1.05 })})`,
+        {
+          label: "fixture synthesis",
+          timeoutMs: 90000,
+        },
+      );
+      await writeFile(fixturePath, wavBuffer(fixture.audio, fixture.sampleRate));
+      await client.closeBrowser();
+      console.log(`Wrote fake microphone fixture: ${fixturePath}`);
+    } finally {
+      await stopBrowser(fixtureBrowser, profileDir, { cleanupProfile: false });
+    }
+  }
+
+  const fakeMicBrowser = launchBrowser(9342, profileDir, [
+    "--use-fake-ui-for-media-stream",
+    "--use-fake-device-for-media-stream",
+    `--use-file-for-fake-audio-capture=${fixturePath}`,
+  ]);
+
+  let client = null;
+  try {
+    client = await connectToPage(9342, fakeMicBrowser);
+    await waitForBenchApi(client);
+    await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(stack)})`, {
+      label: "fake-mic model load",
+      timeoutMs: 240000,
+    });
+    await runPageTask(client, "window.browserSpeakBench.clearResults()", { label: "clear results" });
+    for (let i = 1; i <= 3; i += 1) {
+      console.log(`Running fake microphone scripted row ${i}/3`);
+      const snapshot = await runPageTask(
+        client,
+        `window.browserSpeakBench.runMic(${JSON.stringify({
+          timeoutMs: fakeMicTurnTimeoutMs,
+          stopMicAfterTranscript: true,
+          requireExactTranscript: true,
+        })})`,
+        {
+          label: `fake microphone row ${i}`,
+          timeoutMs: fakeMicRowTimeoutMs,
+        },
+      );
+      const latest = snapshot.results[0];
+      if (!latest || latest.kind !== "mic" || latest.error) {
+        await writeFailurePayload(client, latest?.error || `Missing fake microphone row ${i}.`);
+        throw new Error(latest?.error || `Missing fake microphone row ${i}.`);
+      }
+      await runPageTask(client, "window.browserSpeakBench.stopMic()", { label: "stop microphone" });
+    }
+    const exportPayload = await runPageTask(client, "window.browserSpeakBench.exportResults()", {
+      label: "export results",
+    });
+    exportPayload.sourceFingerprint = await sourceFingerprint();
+    await writeFile(resultPath, `${JSON.stringify(exportPayload, null, 2)}\n`);
+    const current = exportPayload.summary.current ?? exportPayload.summary.all;
+    const micRows = exportPayload.results.filter((result) => result.kind === "mic" && !result.error);
+    console.log(`Wrote fake microphone benchmark JSON: ${resultPath}`);
+    console.log(`Scripted mic rows: ${current.micRuns}/${current.micTargetRuns}`);
+    console.log(`Median mic ASR: ${formatMs(median(micRows.map((result) => result.asrMs)))}`);
+    console.log(`Median mic WER: ${formatPercent(current.micMedianWer)}`);
+    console.log(`Median mic first token: ${formatMs(median(micRows.map((result) => result.firstTokenMs)))}`);
+    console.log(`Median mic speech-end-to-audio: ${formatMs(current.micMedianSpeechEndToFirstAudioMs)}`);
+    console.log(`Median mic speech-end-to-audio-done: ${formatMs(current.micMedianSpeechEndToAudioEndMs)}`);
+    await client.closeBrowser();
+  } catch (error) {
+    if (client) await writeFailurePayload(client, error.message).catch(() => {});
+    throw error;
+  } finally {
+    await stopBrowser(fakeMicBrowser, profileDir);
+  }
+}
+
+async function writeFailurePayload(client, error) {
+  const snapshot = await client
+    .evaluate("window.browserSpeakBench?.state?.() ?? null", pollTimeoutMs)
+    .catch(() => null);
+  const fingerprint = await sourceFingerprint().catch(() => null);
+  await writeFile(
+    resultPath,
+    `${JSON.stringify(
+      snapshot ? { error, sourceFingerprint: fingerprint, snapshot } : { error, sourceFingerprint: fingerprint },
+      null,
+      2,
+    )}\n`,
+  );
+  console.log(`Wrote fake microphone failure JSON: ${resultPath}`);
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+async function waitForBenchApi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      if (await client.evaluate("Boolean(window.browserSpeakBench)")) return;
+    } catch {
+      // The target may still be navigating and can destroy the execution context.
+    }
+    await sleep(100);
+  }
+  throw new Error("window.browserSpeakBench was not installed.");
+}
+
+async function runPageTask(client, expression, { label = "page task", timeoutMs = 30000 } = {}) {
+  const taskId = `task_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  await client.evaluate(`(() => {
+    const taskId = ${JSON.stringify(taskId)};
+    window.__browserSpeakHarnessTasks ||= {};
+    window.__browserSpeakHarnessTasks[taskId] = { done: false, label: ${JSON.stringify(label)} };
+    Promise.resolve(${expression})
+      .then((value) => {
+        window.__browserSpeakHarnessTasks[taskId] = { done: true, value };
+      })
+      .catch((error) => {
+        window.__browserSpeakHarnessTasks[taskId] = {
+          done: true,
+          error: error?.stack || error?.message || String(error),
+        };
+      });
+    return true;
+  })()`);
+  const deadline = Date.now() + timeoutMs;
+  let lastEvents = [];
+  let lastPollError = "";
+  while (Date.now() < deadline) {
+    let task = null;
+    try {
+      task = await client.evaluate(
+        `window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}] ?? null`,
+        pollTimeoutMs,
+      );
+      lastPollError = "";
+    } catch (error) {
+      const message = error.message ?? String(error);
+      if (message !== lastPollError) {
+        console.log(`${label}: waiting for page response (${message})`);
+        lastPollError = message;
+      }
+      await sleep(500);
+      continue;
+    }
+    if (task?.done) {
+      await client
+        .evaluate(`delete window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}]`, pollTimeoutMs)
+        .catch(() => {});
+      if (task.error) throw new Error(`${label} failed: ${task.error}`);
+      return task.value;
+    }
+    const snapshot = await client
+      .evaluate(`(() => {
+        const state = window.browserSpeakBench?.state?.();
+        return state ? {
+          modelsLoaded: state.modelsLoaded,
+          modelsLoading: state.modelsLoading,
+          activeBenchmark: state.activeBenchmark?.kind ?? null,
+          events: state.events?.slice(0, 3) ?? [],
+        } : null;
+      })()`, pollTimeoutMs)
+      .catch(() => null);
+    const events = snapshot?.events ?? [];
+    if (events.join("\\n") !== lastEvents.join("\\n")) {
+      lastEvents = events;
+      if (events[0]) console.log(`${label}: ${events[0]}`);
+    }
+    await sleep(500);
+  }
+  throw new Error(`${label} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`);
+}
+
+function launchBrowser(port, profileDir, extraArgs = []) {
+  const child = spawn(
+    chrome,
+    [
+      "--headless=new",
+      "--no-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage",
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...extraArgs,
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir, { cleanupProfile = true } = {}) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  if (!cleanupProfile) return;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+      method,
+    }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page" && target.url === url);
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (!message.id || !this.pending.has(message.id)) return;
+    const { resolve: onResolve, reject } = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else onResolve(message.result);
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+    }, timeoutMs);
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  async evaluateAsync(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call("Runtime.evaluate", {
+      expression,
+      awaitPromise: true,
+      returnByValue: true,
+    }, timeoutMs);
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  closeBrowser() {
+    try {
+      this.socket.send(JSON.stringify({ id: this.nextId++, method: "Browser.close", params: {} }));
+    } catch {
+      // The surrounding process cleanup handles already-closed targets.
+    }
+    try {
+      this.socket.close();
+    } catch {
+      // Ignore close races.
+    }
+  }
+}
+
+function formatException(exceptionDetails) {
+  const exception = exceptionDetails.exception;
+  return exception?.description ?? exception?.value ?? exceptionDetails.text ?? "Evaluation failed.";
+}
+
+function wavBuffer(samples, sourceSampleRate) {
+  const targetRate = 48000;
+  const lead = new Float32Array(Math.round(targetRate * 2.0));
+  const speech = normalizeSpeech(resample(samples, sourceSampleRate, targetRate));
+  const trail = new Float32Array(Math.round(targetRate * 2.0));
+  const combined = new Float32Array(lead.length + speech.length + trail.length);
+  combined.set(lead, 0);
+  combined.set(speech, lead.length);
+  combined.set(trail, lead.length + speech.length);
+
+  const dataBytes = combined.length * 2;
+  const buffer = Buffer.alloc(44 + dataBytes);
+  buffer.write("RIFF", 0);
+  buffer.writeUInt32LE(36 + dataBytes, 4);
+  buffer.write("WAVE", 8);
+  buffer.write("fmt ", 12);
+  buffer.writeUInt32LE(16, 16);
+  buffer.writeUInt16LE(1, 20);
+  buffer.writeUInt16LE(1, 22);
+  buffer.writeUInt32LE(targetRate, 24);
+  buffer.writeUInt32LE(targetRate * 2, 28);
+  buffer.writeUInt16LE(2, 32);
+  buffer.writeUInt16LE(16, 34);
+  buffer.write("data", 36);
+  buffer.writeUInt32LE(dataBytes, 40);
+  for (let i = 0; i < combined.length; i += 1) {
+    const value = Math.max(-1, Math.min(1, combined[i]));
+    buffer.writeInt16LE(Math.round(value * 32767), 44 + i * 2);
+  }
+  return buffer;
+}
+
+function normalizeSpeech(samples) {
+  let peak = 0;
+  for (const sample of samples) {
+    peak = Math.max(peak, Math.abs(sample));
+  }
+  if (peak < 0.01) return samples;
+  const gain = Math.min(3, 0.85 / peak);
+  const output = new Float32Array(samples.length);
+  for (let i = 0; i < samples.length; i += 1) {
+    output[i] = samples[i] * gain;
+  }
+  return output;
+}
+
+function resample(samples, sourceRate, targetRate) {
+  if (sourceRate === targetRate) return Float32Array.from(samples);
+  const output = new Float32Array(Math.ceil((samples.length * targetRate) / sourceRate));
+  for (let i = 0; i < output.length; i += 1) {
+    const position = (i * sourceRate) / targetRate;
+    const left = Math.floor(position);
+    const right = Math.min(samples.length - 1, left + 1);
+    const weight = position - left;
+    output[i] = samples[left] * (1 - weight) + samples[right] * weight;
+  }
+  return output;
+}
+
+function formatMs(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value < 1000) return `${Math.round(value)} ms`;
+  return `${(value / 1000).toFixed(2)} s`;
+}
+
+function formatPercent(value) {
+  if (!Number.isFinite(value)) return "-";
+  return `${Math.round(value * 100)}%`;
+}
+
+function median(values) {
+  const finite = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (finite.length === 0) return null;
+  const middle = Math.floor(finite.length / 2);
+  if (finite.length % 2 === 1) return finite[middle];
+  return (finite[middle - 1] + finite[middle]) / 2;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+await main();

tools/run-final-validation.mjs

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const resultPath = resolve(process.env.BROWSER_SPEAK_FINAL_JSON ?? `${tmpdir()}/browser-speak-final-validation.json`);
+const auditPath = resolve(process.env.BROWSER_SPEAK_AUDIT_JSON ?? `${tmpdir()}/browser-speak-validation-audit.json`);
+const soft = process.env.BROWSER_SPEAK_FINAL_SOFT === "true";
+const skipLocal = process.env.BROWSER_SPEAK_FINAL_SKIP_LOCAL === "true";
+const skipUi = skipLocal || process.env.BROWSER_SPEAK_FINAL_SKIP_UI === "true";
+const skipEvidenceExport = skipLocal || process.env.BROWSER_SPEAK_FINAL_SKIP_EVIDENCE_EXPORT === "true";
+const skipClientSide = skipLocal || process.env.BROWSER_SPEAK_FINAL_SKIP_CLIENT_SIDE === "true";
+const skipLoopback = skipLocal || process.env.BROWSER_SPEAK_FINAL_SKIP_LOOPBACK === "true";
+const skipWebgpu = process.env.BROWSER_SPEAK_FINAL_SKIP_WEBGPU === "true";
+const realMicMode = parseRealMicMode(process.env.BROWSER_SPEAK_FINAL_REAL_MIC ?? "skip");
+
+const envDefaults = {
+  BROWSER_SPEAK_CLIENT_SIDE_REUSE_PROFILE: "true",
+  BROWSER_SPEAK_LOCAL_REUSE_PROFILE: "true",
+  BROWSER_SPEAK_LOAD_TIMEOUT_MS: "900000",
+  BROWSER_SPEAK_TASK_TIMEOUT_MS: "240000",
+  BROWSER_SPEAK_VOICE_PRELOAD_TIMEOUT_MS: "240000",
+};
+
+const steps = [
+  {
+    name: "UI smoke",
+    script: "run-ui-smoke.mjs",
+    artifactEnv: "BROWSER_SPEAK_UI_JSON",
+    defaultArtifact: `${tmpdir()}/browser-speak-ui-smoke.json`,
+    skipped: skipUi,
+    skipReason: "disabled by BROWSER_SPEAK_FINAL_SKIP_UI or BROWSER_SPEAK_FINAL_SKIP_LOCAL",
+  },
+  {
+    name: "evidence export smoke",
+    script: "run-evidence-export-smoke.mjs",
+    artifactEnv: "BROWSER_SPEAK_EVIDENCE_EXPORT_JSON",
+    defaultArtifact: `${tmpdir()}/browser-speak-evidence-export-smoke.json`,
+    skipped: skipEvidenceExport,
+    skipReason: "disabled by BROWSER_SPEAK_FINAL_SKIP_EVIDENCE_EXPORT or BROWSER_SPEAK_FINAL_SKIP_LOCAL",
+  },
+  {
+    name: "client-side/no-server smoke",
+    script: "run-client-side-smoke.mjs",
+    artifactEnv: "BROWSER_SPEAK_CLIENT_SIDE_JSON",
+    defaultArtifact: `${tmpdir()}/browser-speak-client-side-smoke.json`,
+    skipped: skipClientSide,
+    skipReason: "disabled by BROWSER_SPEAK_FINAL_SKIP_CLIENT_SIDE or BROWSER_SPEAK_FINAL_SKIP_LOCAL",
+  },
+  {
+    name: "loopback stability",
+    script: "run-loopback-series.mjs",
+    artifactEnv: "BROWSER_SPEAK_LOOPBACK_JSON",
+    defaultArtifact: `${tmpdir()}/browser-speak-loopback-series.json`,
+    skipped: skipLoopback,
+    skipReason: "disabled by BROWSER_SPEAK_FINAL_SKIP_LOOPBACK or BROWSER_SPEAK_FINAL_SKIP_LOCAL",
+  },
+  {
+    name: "hardware WebGPU benchmark",
+    script: "run-webgpu-benchmark.mjs",
+    artifactEnv: "BROWSER_SPEAK_WEBGPU_JSON",
+    defaultArtifact: `${tmpdir()}/browser-speak-webgpu-results.json`,
+    skipped: skipWebgpu,
+    skipReason: "disabled by BROWSER_SPEAK_FINAL_SKIP_WEBGPU",
+  },
+  {
+    name: realMicMode === "dry-run" ? "real microphone preflight" : "real microphone validation",
+    script: "run-real-mic-series.mjs",
+    artifactEnv: "BROWSER_SPEAK_REAL_MIC_JSON",
+    defaultArtifact:
+      realMicMode === "dry-run"
+        ? `${tmpdir()}/browser-speak-real-mic-series-dry-run.json`
+        : `${tmpdir()}/browser-speak-real-mic-series.json`,
+    skipped: realMicMode === "skip",
+    skipReason: "set BROWSER_SPEAK_FINAL_REAL_MIC=true to collect rows, or dry-run for preflight only",
+    env: realMicMode === "dry-run" ? { BROWSER_SPEAK_REAL_MIC_DRY_RUN: "true" } : {},
+  },
+  {
+    name: "validation audit",
+    script: "audit-validation.mjs",
+    artifactEnv: "BROWSER_SPEAK_AUDIT_JSON",
+    defaultArtifact: `${tmpdir()}/browser-speak-validation-audit.json`,
+    env: soft ? { BROWSER_SPEAK_AUDIT_SOFT: "true" } : {},
+  },
+];
+
+const commandResults = [];
+
+async function main() {
+  await mkdir(dirname(resultPath), { recursive: true });
+  await writeSummary({ status: "running" });
+
+  for (const step of steps) {
+    const result = await runStep(step);
+    commandResults.push(result);
+    await writeSummary({ status: "running" });
+  }
+
+  const audit = await readJson(auditPath);
+  const commandFailures = commandResults.filter((result) => result.commandStatus === "fail");
+  const auditPassed = audit?.passed === true;
+  await writeSummary({
+    status: "complete",
+    audit,
+    commandFailures,
+    auditPassed,
+  });
+
+  console.log(`Wrote final validation JSON: ${resultPath}`);
+  printFinalSummary(audit, commandFailures);
+  if (commandFailures.length > 0 || (!soft && !auditPassed)) process.exitCode = 1;
+}
+
+async function runStep(step) {
+  const artifactPath = resolve(process.env[step.artifactEnv] ?? step.defaultArtifact);
+  const command = `${process.execPath} tools/${step.script}`;
+  if (step.skipped) {
+    console.log(`Skipping ${step.name}: ${step.skipReason}.`);
+    return {
+      name: step.name,
+      status: "skip",
+      commandStatus: "skip",
+      evidenceStatus: "skip",
+      command,
+      artifactPath,
+      reason: step.skipReason,
+      durationMs: 0,
+    };
+  }
+
+  console.log(`Running ${step.name}: ${command}`);
+  const startedAt = Date.now();
+  const exitCode = await runChild(process.execPath, [resolve(scriptDir, step.script)], envWithDefaults(step.env));
+  const durationMs = Date.now() - startedAt;
+  const commandStatus = exitCode === 0 ? "pass" : "fail";
+  const evidence = await evidenceForStep(step, artifactPath);
+  console.log(formatStepResult(step.name, commandStatus, evidence?.status, durationMs));
+  return {
+    name: step.name,
+    status: evidence?.status ?? commandStatus,
+    commandStatus,
+    evidenceStatus: evidence?.status ?? null,
+    command,
+    artifactPath,
+    exitCode,
+    durationMs,
+    evidence,
+  };
+}
+
+function runChild(command, args, env) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, { env, stdio: "inherit" });
+    child.on("error", (error) => {
+      console.error(`${command} failed to start: ${error.message}`);
+      resolvePromise(1);
+    });
+    child.on("exit", (code) => resolvePromise(code ?? 1));
+  });
+}
+
+function envWithDefaults(overrides = {}) {
+  const env = { ...process.env };
+  for (const [key, value] of Object.entries(envDefaults)) {
+    if (!(key in env)) env[key] = value;
+  }
+  return { ...env, ...overrides };
+}
+
+async function writeSummary({ status, audit = null, commandFailures = [], auditPassed = null } = {}) {
+  const currentAudit = audit ?? (await readJson(auditPath));
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    status,
+    passed: currentAudit?.passed === true,
+    completed: status === "complete" && commandFailures.length === 0,
+    soft,
+    config: {
+      resultPath,
+      auditPath,
+      skipLocal,
+      skipUi,
+      skipEvidenceExport,
+      skipClientSide,
+      skipLoopback,
+      skipWebgpu,
+      realMicMode,
+      envDefaults,
+    },
+    commands: commandResults,
+    audit: summarizeAudit(currentAudit),
+  };
+  if (auditPassed !== null) payload.auditPassed = auditPassed;
+  if (commandFailures.length > 0) payload.commandFailures = commandFailures;
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function summarizeAudit(audit) {
+  if (!audit || typeof audit !== "object") return null;
+  const checks = Array.isArray(audit.checks) ? audit.checks : [];
+  return {
+    generatedAt: audit.generatedAt ?? null,
+    passed: audit.passed === true,
+    required: checks.filter((check) => check.required).map(summarizeCheck),
+    supporting: checks.filter((check) => !check.required).map(summarizeCheck),
+    nextActions: Array.isArray(audit.nextActions) ? audit.nextActions : [],
+  };
+}
+
+function summarizeCheck(check) {
+  return {
+    name: check.name,
+    status: check.status,
+    message: check.message,
+  };
+}
+
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function evidenceForStep(step, artifactPath) {
+  const artifact = await readJson(artifactPath);
+  if (!artifact) return { status: "missing", message: "Artifact JSON was not readable after the step." };
+  if (step.script === "audit-validation.mjs") {
+    return {
+      status: artifact.passed === true ? "pass" : "fail",
+      message: artifact.passed === true ? "Final audit passed." : "Final audit did not pass all required evidence gates.",
+    };
+  }
+  if (step.script === "run-webgpu-benchmark.mjs") {
+    if (artifact.skipped) {
+      return {
+        status: "missing",
+        message: artifact.reason ?? "WebGPU benchmark was skipped.",
+      };
+    }
+    const completed = Array.isArray(artifact.candidates)
+      ? artifact.candidates.filter((candidate) => candidate.status === "complete").length
+      : 0;
+    return {
+      status: artifact.webgpu?.available === true && artifact.webgpu?.softwareAdapter !== true && completed > 0 ? "pass" : "missing",
+      message: completed > 0 ? `${completed} hardware WebGPU candidate(s) completed.` : "No hardware WebGPU candidate completed.",
+    };
+  }
+  if (step.script === "run-real-mic-series.mjs") {
+    if (artifact.dryRun) return { status: "preflight", message: "Real-mic dry run completed; no human speech rows collected." };
+    return {
+      status: artifact.passed === true ? "pass" : "fail",
+      message: artifact.passed === true ? "Real microphone rows passed." : "Real microphone rows are missing or below threshold.",
+    };
+  }
+  if ("passed" in artifact) {
+    return {
+      status: artifact.passed === true ? "pass" : "fail",
+      message: artifact.passed === true ? "Step artifact reports passed." : "Step artifact reports failure.",
+    };
+  }
+  return { status: "unknown", message: "Step artifact did not expose a passed flag." };
+}
+
+function parseRealMicMode(value) {
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "real", "run"].includes(normalized)) return "real";
+  if (["dry-run", "dryrun", "preflight"].includes(normalized)) return "dry-run";
+  return "skip";
+}
+
+function printFinalSummary(audit, commandFailures) {
+  if (commandFailures.length > 0) {
+    console.log(`Command failures: ${commandFailures.map((result) => result.name).join(", ")}`);
+  }
+  if (!audit) {
+    console.log("Validation audit JSON was not available.");
+    return;
+  }
+  const required = Array.isArray(audit.checks) ? audit.checks.filter((check) => check.required) : [];
+  console.log(`Final audit: ${audit.passed ? "pass" : "fail"}`);
+  for (const check of required) {
+    console.log(`${check.status}: ${check.name} - ${check.message}`);
+  }
+  if (!audit.passed && soft) console.log("Soft mode is enabled, so missing external gates do not fail this runner.");
+}
+
+function formatStepResult(name, commandStatus, evidenceStatus, durationMs) {
+  const evidenceSuffix = evidenceStatus && evidenceStatus !== commandStatus ? `, evidence ${evidenceStatus}` : "";
+  return `${name}: command ${commandStatus}${evidenceSuffix} (${formatDuration(durationMs)})`;
+}
+
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms} ms`;
+  return `${(ms / 1000).toFixed(1)} s`;
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-hosted-evidence-capture.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const hostedUrl = normalizeUrl(
+  process.env.BROWSER_SPEAK_HOSTED_URL ??
+    process.env.BROWSER_SPEAK_URL ??
+    "https://mike0021-browser-speak.static.hf.space/",
+);
+const rawRealMicPath = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_REAL_MIC_JSON ??
+    process.env.BROWSER_SPEAK_REAL_MIC_JSON ??
+    `${tmpdir()}/browser-speak-hosted-real-mic-series.json`,
+);
+const evidencePath = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_JSON ??
+    `${tmpdir()}/browser-speak-hosted-browser-evidence.json`,
+);
+const auditPath = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_AUDIT_JSON ??
+    `${tmpdir()}/browser-speak-hosted-browser-evidence-audit.json`,
+);
+const summaryPath = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_SUMMARY_JSON ??
+    `${tmpdir()}/browser-speak-evidence-summary.json`,
+);
+const reportPath = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_REPORT_JSON ??
+    `${tmpdir()}/browser-speak-hosted-evidence-capture.json`,
+);
+const dryRun =
+  process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_DRY_RUN === "true" ||
+  process.env.BROWSER_SPEAK_REAL_MIC_DRY_RUN === "true";
+const skipAudit = process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_SKIP_AUDIT === "true" || dryRun;
+const skipSummary = process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_SKIP_SUMMARY === "true" || dryRun;
+
+async function main() {
+  await mkdir(dirname(reportPath), { recursive: true });
+  await mkdir(dirname(rawRealMicPath), { recursive: true });
+  await mkdir(dirname(evidencePath), { recursive: true });
+  await mkdir(dirname(auditPath), { recursive: true });
+  await mkdir(dirname(summaryPath), { recursive: true });
+
+  const steps = [];
+  const realMicEnv = {
+    ...process.env,
+    BROWSER_SPEAK_URL: hostedUrl,
+    BROWSER_SPEAK_DEVICE: process.env.BROWSER_SPEAK_DEVICE ?? "auto",
+    BROWSER_SPEAK_REAL_MIC_JSON: rawRealMicPath,
+    BROWSER_SPEAK_HEADLESS: process.env.BROWSER_SPEAK_HEADLESS ?? "false",
+  };
+  if (dryRun) realMicEnv.BROWSER_SPEAK_REAL_MIC_DRY_RUN = "true";
+
+  console.log(`Hosted evidence URL: ${hostedUrl}`);
+  console.log(`Real-mic artifact: ${rawRealMicPath}`);
+  console.log(`Enriched browser evidence: ${evidencePath}`);
+  if (dryRun) console.log("Dry run enabled; audit and summary steps will be skipped.");
+
+  steps.push(
+    await runStep("hosted real-mic series", process.execPath, ["tools/run-real-mic-series.mjs"], {
+      env: realMicEnv,
+      inherit: true,
+    }),
+  );
+
+  const enrich = await enrichRealMicArtifact(rawRealMicPath, evidencePath).catch((error) => ({
+    label: "enrich browser evidence",
+    status: "fail",
+    error: error.message,
+  }));
+  steps.push(enrich);
+
+  if (!skipAudit && enrich.status === "pass") {
+    steps.push(
+      await runStep("browser evidence audit", process.execPath, ["tools/audit-browser-evidence.mjs", evidencePath], {
+        env: {
+          ...process.env,
+          BROWSER_SPEAK_BROWSER_AUDIT_JSON: auditPath,
+        },
+        inherit: true,
+      }),
+    );
+  }
+
+  if (!skipSummary) {
+    steps.push(
+      await runStep("evidence summary", process.execPath, ["tools/summarize-evidence.mjs"], {
+        env: {
+          ...process.env,
+          BROWSER_SPEAK_REAL_MIC_JSON: rawRealMicPath,
+          BROWSER_SPEAK_BROWSER_AUDIT_JSON: auditPath,
+          BROWSER_SPEAK_EVIDENCE_SUMMARY_JSON: summaryPath,
+        },
+        inherit: true,
+      }),
+    );
+  }
+
+  const stepsPassed = steps.every((step) => step.status === "pass");
+  const passed = !dryRun && stepsPassed;
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    passed,
+    stepsPassed,
+    dryRun,
+    hostedUrl,
+    artifacts: {
+      rawRealMicJson: rawRealMicPath,
+      browserEvidenceJson: evidencePath,
+      browserEvidenceAuditJson: skipAudit ? null : auditPath,
+      evidenceSummaryJson: skipSummary ? null : summaryPath,
+    },
+    steps,
+    nextActions: nextActions(steps, dryRun),
+  };
+  await writeFile(reportPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote hosted evidence capture report: ${reportPath}`);
+  if (!stepsPassed || (!dryRun && !passed)) process.exitCode = 1;
+}
+
+async function enrichRealMicArtifact(inputPath, outputPath) {
+  const startedAt = Date.now();
+  const payload = JSON.parse(await readFile(inputPath, "utf8"));
+  const rows = Array.isArray(payload.results) ? payload.results : [];
+  const firstEnvironment = rows.map((row) => row.stack?.environment).find((environment) => environment && typeof environment === "object") ?? null;
+  const hostMetadata =
+    payload.hostMetadata ??
+    payload.browserExport?.hostMetadata ??
+    payload.runtime?.hostMetadata ??
+    firstEnvironment?.hostMetadata ??
+    {};
+  const runtime = payload.runtime ?? payload.browserExport?.runtime ?? firstEnvironment ?? null;
+  const benchmarkSummary = payload.exportSummary ?? payload.browserExport?.summary ?? payload.summary ?? null;
+  const enriched = {
+    ...payload,
+    hostMetadata,
+    runtime,
+    benchmarkSummary,
+    browserExport: payload.browserExport ?? {
+      generatedAt: payload.generatedAt ?? new Date().toISOString(),
+      hostMetadata,
+      runtime,
+      summary: benchmarkSummary,
+      results: rows,
+    },
+  };
+  await writeFile(outputPath, `${JSON.stringify(enriched, null, 2)}\n`);
+  return {
+    label: "enrich browser evidence",
+    status: "pass",
+    durationMs: Date.now() - startedAt,
+    inputPath,
+    outputPath,
+    rowCount: rows.length,
+    host: hostMetadata.host ?? "",
+    hfSpaceCommit: hostMetadata.hfSpaceCommit ?? "",
+  };
+}
+
+function runStep(label, command, args, { env = process.env, inherit = false } = {}) {
+  console.log(`Running ${label}.`);
+  const startedAt = Date.now();
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, {
+      env,
+      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    if (!inherit) {
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+    }
+    child.on("error", (error) => {
+      resolvePromise({
+        label,
+        command: [command, ...args],
+        status: "fail",
+        error: error.message,
+        durationMs: Date.now() - startedAt,
+      });
+    });
+    child.on("exit", (exitCode) => {
+      resolvePromise({
+        label,
+        command: [command, ...args],
+        status: exitCode === 0 ? "pass" : "fail",
+        exitCode,
+        durationMs: Date.now() - startedAt,
+        stdout: inherit ? undefined : stdout,
+        stderr: inherit ? undefined : stderr,
+      });
+    });
+  });
+}
+
+function nextActions(steps, isDryRun) {
+  if (isDryRun) {
+    return [
+      "Run node tools/run-hosted-evidence-capture.mjs from a desktop browser session with a real microphone.",
+      "Keep BROWSER_SPEAK_DEVICE=auto on a machine with hardware WebGPU so the mic rows also prove hardware execution.",
+    ];
+  }
+  const failed = steps.filter((step) => step.status !== "pass").map((step) => step.label);
+  if (failed.length === 0) return ["Use the browser evidence audit JSON in the final validation review."];
+  const actions = [];
+  if (failed.includes("hosted real-mic series")) {
+    actions.push("Rerun from a desktop session with microphone permission granted and no fake-capture Chrome flags.");
+  }
+  if (failed.includes("browser evidence audit")) {
+    actions.push("Check whether the captured rows include three real-mic passes and at least one hardware WebGPU row.");
+  }
+  if (failed.includes("enrich browser evidence")) {
+    actions.push("Inspect the raw real-mic artifact; enrichment requires a JSON file with benchmark rows.");
+  }
+  return actions;
+}
+
+function normalizeUrl(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+main().catch(async (error) => {
+  await mkdir(dirname(reportPath), { recursive: true }).catch(() => {});
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint().catch(() => null),
+    passed: false,
+    dryRun,
+    hostedUrl,
+    error: error.stack ?? error.message ?? String(error),
+  };
+  if (!existsSync(reportPath)) await writeFile(reportPath, `${JSON.stringify(payload, null, 2)}\n`).catch(() => {});
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-hosted-smoke.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const spaceId = process.env.BROWSER_SPEAK_SPACE_ID ?? "Mike0021/browser-speak";
+const hostedUrl = normalizeUrl(
+  process.env.BROWSER_SPEAK_HOSTED_URL ?? "https://mike0021-browser-speak.static.hf.space/",
+);
+const resultPath = resolve(process.env.BROWSER_SPEAK_HOSTED_SMOKE_JSON ?? `${tmpdir()}/browser-speak-hosted-smoke.json`);
+const uiJson = resolve(process.env.BROWSER_SPEAK_HOSTED_UI_JSON ?? `${tmpdir()}/browser-speak-hosted-ui-smoke.json`);
+const uiScreenshotDir = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_UI_SCREENSHOT_DIR ?? `${tmpdir()}/browser-speak-hosted-ui-smoke`,
+);
+const clientSideJson = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_CLIENT_SIDE_JSON ?? `${tmpdir()}/browser-speak-hosted-client-side-smoke.json`,
+);
+const evidenceExportJson = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_EVIDENCE_EXPORT_JSON ??
+    `${tmpdir()}/browser-speak-hosted-evidence-export-smoke.json`,
+);
+const clientSideProfileDir = resolve(
+  process.env.BROWSER_SPEAK_HOSTED_CLIENT_SIDE_PROFILE_DIR ??
+    `${tmpdir()}/browser-speak-hosted-client-side-profile`,
+);
+const skipUi = process.env.BROWSER_SPEAK_HOSTED_SKIP_UI === "true";
+const skipEvidenceExport = process.env.BROWSER_SPEAK_HOSTED_SKIP_EVIDENCE_EXPORT === "true";
+const skipClientSide = process.env.BROWSER_SPEAK_HOSTED_SKIP_CLIENT_SIDE === "true";
+const skipHfInfo = process.env.BROWSER_SPEAK_HOSTED_SKIP_HF_INFO === "true";
+
+async function main() {
+  await mkdir(dirname(resultPath), { recursive: true });
+
+  const steps = [];
+  const hfInfo = skipHfInfo
+    ? null
+    : await runJsonCommand("hf", ["spaces", "info", spaceId], {
+        label: "HF Space info",
+      }).catch((error) => ({ error: error.message }));
+  const hubApiInfo = skipHfInfo ? null : await fetchHubApiInfo().catch((error) => ({ error: error.message }));
+  const hostHead = await fetchHostHead().catch((error) => ({ ok: false, error: error.message }));
+
+  if (!skipUi) {
+    steps.push(
+      await runStep("hosted UI smoke", process.execPath, ["tools/run-ui-smoke.mjs"], {
+        BROWSER_SPEAK_URL: hostedUrl,
+        BROWSER_SPEAK_UI_JSON: uiJson,
+        BROWSER_SPEAK_UI_SCREENSHOT_DIR: uiScreenshotDir,
+      }),
+    );
+  }
+
+  if (!skipEvidenceExport) {
+    steps.push(
+      await runStep("hosted evidence export smoke", process.execPath, ["tools/run-evidence-export-smoke.mjs"], {
+        BROWSER_SPEAK_URL: hostedUrl,
+        BROWSER_SPEAK_EVIDENCE_EXPORT_JSON: evidenceExportJson,
+      }),
+    );
+  }
+
+  if (!skipClientSide) {
+    steps.push(
+      await runStep("hosted client-side/no-server smoke", process.execPath, ["tools/run-client-side-smoke.mjs"], {
+        BROWSER_SPEAK_URL: hostedUrl,
+        BROWSER_SPEAK_CLIENT_SIDE_JSON: clientSideJson,
+        BROWSER_SPEAK_CLIENT_SIDE_PROFILE_DIR: clientSideProfileDir,
+      }),
+    );
+  }
+
+  const ui = skipUi ? null : await readJsonIfExists(uiJson);
+  const evidenceExport = skipEvidenceExport ? null : await readJsonIfExists(evidenceExportJson);
+  const clientSide = skipClientSide ? null : await readJsonIfExists(clientSideJson);
+  const spaceShas = [hfInfo?.sha, hubApiInfo?.sha].filter(Boolean);
+  const commitMatch =
+    spaceShas.length > 0 && hostHead?.hfSpaceCommit
+      ? spaceShas.every((sha) => sha === hostHead.hfSpaceCommit)
+      : hfInfo?.error && hubApiInfo?.error
+        ? false
+        : null;
+  const cardData = hubApiInfo?.cardData ?? hfInfo?.card_data ?? null;
+  const spaceConfigParsed =
+    hubApiInfo?.error || skipHfInfo ? null : cardData?.sdk === "static" && Boolean(cardData?.app_file);
+  const noServerSmoke =
+    clientSide == null
+      ? null
+      : Boolean(
+          clientSide.passed &&
+            Array.isArray(clientSide.suspects) &&
+            clientSide.suspects.length === 0 &&
+            Array.isArray(clientSide.benchmarkErrors) &&
+            clientSide.benchmarkErrors.length === 0,
+        );
+  const passed =
+    hostHead?.ok !== false &&
+    commitMatch !== false &&
+    steps.every((step) => step.status === "pass") &&
+    (ui == null || ui.passed !== false) &&
+    (clientSide == null || noServerSmoke === true);
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    passed,
+    spaceId,
+    hostedUrl,
+    hfInfo,
+    hubApiInfo,
+    hostHead,
+    commitMatch,
+    spaceConfigParsed,
+    noServerSmoke,
+    artifacts: {
+      uiJson: skipUi ? null : uiJson,
+      uiScreenshotDir: skipUi ? null : uiScreenshotDir,
+      evidenceExportJson: skipEvidenceExport ? null : evidenceExportJson,
+      clientSideJson: skipClientSide ? null : clientSideJson,
+    },
+    steps,
+    uiSummary: ui ? summarizeUiSmoke(ui) : null,
+    evidenceExportSummary: evidenceExport ? summarizeEvidenceExportSmoke(evidenceExport) : null,
+    clientSideSummary: clientSide ? summarizeClientSideSmoke(clientSide) : null,
+  };
+
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote hosted smoke JSON: ${resultPath}`);
+  if (hfInfo?.sha) console.log(`HF Space SHA: ${hfInfo.sha}`);
+  if (hubApiInfo?.sha) console.log(`Hub API SHA: ${hubApiInfo.sha}`);
+  if (spaceConfigParsed != null) console.log(`Hub card config: ${spaceConfigParsed ? "parsed" : "missing"}`);
+  if (hostHead?.hfSpaceCommit) console.log(`Static host commit: ${hostHead.hfSpaceCommit}`);
+  if (commitMatch != null) console.log(`Commit match: ${commitMatch ? "yes" : "no"}`);
+  if (noServerSmoke != null) console.log(`No-server smoke: ${noServerSmoke ? "pass" : "fail"}`);
+  if (!passed) process.exitCode = 1;
+}
+
+async function fetchHubApiInfo() {
+  const response = await fetch(`https://huggingface.co/api/spaces/${spaceId}`, { cache: "no-store" });
+  if (!response.ok) throw new Error(`Hub API returned HTTP ${response.status}`);
+  const payload = await response.json();
+  return {
+    id: payload.id ?? spaceId,
+    sha: payload.sha ?? "",
+    sdk: payload.sdk ?? "",
+    cardData: payload.cardData ?? null,
+    runtime: payload.runtime ?? null,
+    host: payload.host ?? "",
+    lastModified: payload.lastModified ?? null,
+  };
+}
+
+async function fetchHostHead() {
+  const response = await fetch(hostedUrl, { method: "HEAD", cache: "no-store" });
+  return {
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    url: response.url,
+    hfSpaceCommit: response.headers.get("x-repo-commit") ?? "",
+    etag: response.headers.get("etag") ?? "",
+    contentType: response.headers.get("content-type") ?? "",
+    cacheControl: response.headers.get("cache-control") ?? "",
+  };
+}
+
+async function runStep(label, command, args, env = {}) {
+  console.log(`Running ${label}.`);
+  const startedAt = Date.now();
+  const result = await runCommand(command, args, {
+    env: {
+      ...process.env,
+      ...env,
+    },
+    inherit: true,
+  });
+  return {
+    label,
+    command: [command, ...args],
+    status: result.exitCode === 0 ? "pass" : "fail",
+    exitCode: result.exitCode,
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+async function runJsonCommand(command, args, { label }) {
+  const result = await runCommand(command, args, { inherit: false });
+  if (result.exitCode !== 0) {
+    throw new Error(`${label} failed with exit ${result.exitCode}: ${result.stderr || result.stdout}`);
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch (error) {
+    throw new Error(`${label} did not return JSON: ${error.message}`);
+  }
+}
+
+function runCommand(command, args, { env = process.env, inherit = false } = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      env,
+      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    if (!inherit) {
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+    }
+    child.on("error", reject);
+    child.on("exit", (exitCode) => resolvePromise({ exitCode, stdout, stderr }));
+  });
+}
+
+async function readJsonIfExists(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function summarizeUiSmoke(ui) {
+  return {
+    passed: ui.passed,
+    url: ui.url,
+    viewports: ui.viewports?.map((viewport) => ({
+      name: viewport.name,
+      passed: viewport.passed,
+      overflowCount: viewport.overflow?.length ?? 0,
+    })),
+  };
+}
+
+function summarizeClientSideSmoke(clientSide) {
+  return {
+    passed: clientSide.passed,
+    url: clientSide.url,
+    totalRequestCount: clientSide.summary?.totalRequests ?? clientSide.requests?.length ?? 0,
+    benchmarkRequestCount: clientSide.summary?.benchmarkRequests ?? null,
+    serverInferenceSuspectCount: clientSide.summary?.serverInferenceSuspects ?? clientSide.suspects?.length ?? 0,
+    suspectCount: clientSide.suspects?.length ?? 0,
+    benchmarkErrorCount: clientSide.benchmarkErrors?.length ?? 0,
+    resultKinds: clientSide.benchmarkResults?.map((result) => result.kind) ?? [],
+    browserExport: clientSide.browserExport ?? null,
+    hostMetadata: clientSide.hostMetadata ?? clientSide.browserExport?.hostMetadata ?? null,
+  };
+}
+
+function summarizeEvidenceExportSmoke(evidenceExport) {
+  return {
+    passed: evidenceExport.passed,
+    url: evidenceExport.url,
+    summary: evidenceExport.summary ?? null,
+  };
+}
+
+function normalizeUrl(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-local-candidate-benchmark.mjs

@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const resultPath = resolve(process.env.BROWSER_SPEAK_LOCAL_JSON ?? `${tmpdir()}/browser-speak-local-candidates.json`);
+const profileDir = resolve(process.env.BROWSER_SPEAK_LOCAL_PROFILE_DIR ?? `${tmpdir()}/browser-speak-local-profile`);
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const pageUnresponsiveTimeoutMs = Number(process.env.BROWSER_SPEAK_PAGE_UNRESPONSIVE_TIMEOUT_MS ?? 120000);
+const loadTimeoutMs = Number(process.env.BROWSER_SPEAK_LOAD_TIMEOUT_MS ?? 360000);
+const taskTimeoutMs = Number(process.env.BROWSER_SPEAK_TASK_TIMEOUT_MS ?? 180000);
+const ttsWarmup = process.env.BROWSER_SPEAK_TTS_WARMUP === "true";
+const reuseProfile = process.env.BROWSER_SPEAK_LOCAL_REUSE_PROFILE === "true";
+const headless = process.env.BROWSER_SPEAK_HEADLESS !== "false";
+const dryRun = process.env.BROWSER_SPEAK_LOCAL_DRY_RUN === "true";
+const localTasks = parseList(process.env.BROWSER_SPEAK_LOCAL_TASKS ?? "tts,loopback");
+const stacks = buildStacks().slice(0, maxStacks());
+
+async function main() {
+  const config = benchmarkConfig();
+  if (dryRun) {
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      dryRun: true,
+      url,
+      config,
+      candidates: stacks.map((stack) => ({ stack, status: "planned" })),
+    };
+    await mkdir(dirname(resultPath), { recursive: true });
+    await writeJson(payload);
+    console.log(`Wrote local candidate dry-run JSON: ${resultPath}`);
+    console.log(`Planned ${stacks.length} stack(s): ${stacks.map(stackLabel).join("; ")}`);
+    return;
+  }
+
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  if (!reuseProfile) await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9344, profileDir);
+  const candidates = stacks.map((stack) => ({ stack, status: "pending" }));
+  try {
+    const client = await connectToPage(9344, browser);
+    await waitForBenchApi(client);
+    await runPageTask(client, "window.browserSpeakBench.clearResults()", { label: "clear results" });
+
+    for (const candidate of candidates) {
+      const label = stackLabel(candidate.stack);
+      const startedAt = Date.now();
+      let pageUsable = true;
+      console.log(`Running local candidate: ${label}`);
+      try {
+        const before = await runPageTask(client, "window.browserSpeakBench.state()", {
+          label: `${label} preflight`,
+        });
+        await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(candidate.stack)})`, {
+          label: `${label} model load`,
+          timeoutMs: loadTimeoutMs,
+        });
+        for (const task of localTasks) {
+          await runTask(client, task, label);
+        }
+        const snapshot = await runPageTask(client, "window.browserSpeakBench.state()", {
+          label: `${label} state`,
+        });
+        const addedCount = Math.max(0, snapshot.results.length - before.results.length);
+        const rows = snapshot.results.slice(0, addedCount);
+        const errors = rows.filter((row) => row.error);
+        candidate.status = errors.length === 0 ? "complete" : "partial";
+        candidate.durationMs = Date.now() - startedAt;
+        candidate.rowCount = rows.length;
+        candidate.errorCount = errors.length;
+        candidate.metrics = metricsForRows(rows);
+        candidate.summary = snapshot.summary.current ?? snapshot.summary.all;
+        if (errors.length > 0) candidate.errors = errors.map((row) => `${row.kind}: ${row.error}`);
+      } catch (error) {
+        candidate.status = "failed";
+        candidate.durationMs = Date.now() - startedAt;
+        candidate.error = error.message;
+        pageUsable = !isPageUnresponsiveError(error);
+        console.error(`${label} failed: ${error.message}`);
+      } finally {
+        if (pageUsable) {
+          await runPageTask(client, "window.browserSpeakBench.stop()", {
+            label: `${label} stop`,
+            timeoutMs: 20000,
+          }).catch(() => {});
+          const state = await runPageTask(client, "window.browserSpeakBench.state()", {
+            label: `${label} loaded state`,
+            timeoutMs: 20000,
+          }).catch(() => null);
+          if (state?.modelsLoaded || state?.modelsLoading) {
+            await runPageTask(client, "window.browserSpeakBench.unload()", {
+              label: `${label} unload`,
+              timeoutMs: 60000,
+            }).catch((error) => {
+              candidate.unloadError = error.message;
+            });
+          }
+        } else {
+          candidate.unloadError = "Skipped page cleanup because the renderer was unresponsive.";
+        }
+        await writeJson(await exportPayload(client, candidates));
+      }
+      if (!pageUsable) break;
+    }
+
+    const payload = await exportPayload(client, candidates);
+    await writeJson(payload);
+    console.log(`Wrote local candidate benchmark JSON: ${resultPath}`);
+    summarizeCandidates(payload.candidates);
+    await client.closeBrowser();
+  } finally {
+    await stopBrowser(browser, reuseProfile ? null : profileDir);
+  }
+}
+
+async function runTask(client, task, label) {
+  const normalized = task.toLowerCase();
+  const loopbackOptions = {
+    timeoutMs: 180000,
+    ...(process.env.BROWSER_SPEAK_LOOPBACK_TEXT ? { text: process.env.BROWSER_SPEAK_LOOPBACK_TEXT } : {}),
+    ...(Number.isFinite(Number(process.env.BROWSER_SPEAK_LOOPBACK_SPEED))
+      ? { speed: Number(process.env.BROWSER_SPEAK_LOOPBACK_SPEED) }
+      : {}),
+  };
+  const expression = {
+    tts: "window.browserSpeakBench.runTts({ timeoutMs: 90000 })",
+    identity: "window.browserSpeakBench.runIdentity({ timeoutMs: 180000 })",
+    chat: "window.browserSpeakBench.runChat({ timeoutMs: 180000 })",
+    loopback: `window.browserSpeakBench.runLoopback(${JSON.stringify(loopbackOptions)})`,
+    barge: "window.browserSpeakBench.runBargeIn({ timeoutMs: 90000 })",
+    "barge-in": "window.browserSpeakBench.runBargeIn({ timeoutMs: 90000 })",
+    suite: "window.browserSpeakBench.runSuite()",
+  }[normalized];
+  if (!expression) throw new Error(`Unknown local benchmark task: ${task}`);
+  await runPageTask(client, expression, {
+    label: `${label} ${normalized}`,
+    timeoutMs: normalized === "suite" ? Math.max(taskTimeoutMs, 420000) : taskTimeoutMs,
+  });
+}
+
+async function exportPayload(client, candidates) {
+  const exportResult = await runPageTask(client, "window.browserSpeakBench.exportResults()", {
+    label: "export results",
+    timeoutMs: 30000,
+  }).catch(() => ({ summary: null, results: [] }));
+  return {
+    generatedAt: new Date().toISOString(),
+    url,
+    config: benchmarkConfig(),
+    candidates,
+    summary: exportResult.summary,
+    results: exportResult.results,
+  };
+}
+
+function benchmarkConfig() {
+  return {
+    tasks: localTasks,
+    stackCount: stacks.length,
+    loadTimeoutMs,
+    taskTimeoutMs,
+    protocolTimeoutMs,
+    pollTimeoutMs,
+    pageUnresponsiveTimeoutMs,
+    ttsWarmup,
+    reuseProfile,
+    headless,
+    chrome,
+    profileDir,
+    extraChromeArgs: parseChromeArgs(),
+  };
+}
+
+function isPageUnresponsiveError(error) {
+  return /page stayed unresponsive|Runtime\.evaluate timed out/i.test(error?.message ?? String(error));
+}
+
+async function writeJson(payload) {
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function buildStacks() {
+  if (process.env.BROWSER_SPEAK_LOCAL_STACKS) {
+    const parsed = JSON.parse(process.env.BROWSER_SPEAK_LOCAL_STACKS);
+    if (!Array.isArray(parsed)) throw new Error("BROWSER_SPEAK_LOCAL_STACKS must be a JSON array.");
+    return parsed.map((stack, index) => normalizeLocalStack(stack, index));
+  }
+  const llms = parseList(process.env.BROWSER_SPEAK_LOCAL_LLMS ?? "HuggingFaceTB/SmolLM2-135M-Instruct");
+  const asrs = parseList(
+    process.env.BROWSER_SPEAK_LOCAL_ASRS ??
+      "onnx-community/moonshine-base-ONNX,onnx-community/moonshine-tiny-ONNX,onnx-community/whisper-tiny.en",
+  );
+  const voices = parseList(process.env.BROWSER_SPEAK_LOCAL_VOICES ?? "F2");
+  const steps = parseList(process.env.BROWSER_SPEAK_LOCAL_TTS_STEPS ?? "2").map((value) => Number(value));
+  const vadSilenceValues = parseList(process.env.BROWSER_SPEAK_LOCAL_VAD_SILENCE_MS ?? "480").map((value) =>
+    Number(value),
+  );
+  const partialAsr = process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false";
+  const stacks = [];
+  for (const llm of llms) {
+    for (const asr of asrs) {
+      for (const voice of voices) {
+        for (const ttsSteps of steps) {
+          for (const vadSilenceMs of vadSilenceValues) {
+            stacks.push({
+              device: "wasm",
+              llm,
+              asr,
+              voice,
+              ttsSteps,
+              vadSilenceMs,
+              partialAsr,
+              ttsWarmup,
+            });
+          }
+        }
+      }
+    }
+  }
+  return stacks;
+}
+
+function normalizeLocalStack(stack, index) {
+  return {
+    device: "wasm",
+    name: stack.name ?? `stack-${index + 1}`,
+    llm: stack.llm ?? parseList(process.env.BROWSER_SPEAK_LOCAL_LLMS ?? "HuggingFaceTB/SmolLM2-135M-Instruct")[0],
+    asr: stack.asr ?? parseList(process.env.BROWSER_SPEAK_LOCAL_ASRS ?? "onnx-community/moonshine-base-ONNX")[0],
+    voice: stack.voice ?? parseList(process.env.BROWSER_SPEAK_LOCAL_VOICES ?? "F2")[0],
+    ttsSteps: Number(stack.ttsSteps ?? parseList(process.env.BROWSER_SPEAK_LOCAL_TTS_STEPS ?? "2")[0]),
+    vadSilenceMs: Number(stack.vadSilenceMs ?? parseList(process.env.BROWSER_SPEAK_LOCAL_VAD_SILENCE_MS ?? "480")[0]),
+    partialAsr: stack.partialAsr ?? (process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false"),
+    ttsWarmup: stack.ttsWarmup ?? ttsWarmup,
+    ...(stack.ttsChunking ? { ttsChunking: stack.ttsChunking } : {}),
+  };
+}
+
+function maxStacks() {
+  if (!process.env.BROWSER_SPEAK_LOCAL_MAX_STACKS) return Number.POSITIVE_INFINITY;
+  const value = Number(process.env.BROWSER_SPEAK_LOCAL_MAX_STACKS);
+  return Number.isFinite(value) ? Math.max(0, value) : Number.POSITIVE_INFINITY;
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+async function waitForBenchApi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      if (await client.evaluate("Boolean(window.browserSpeakBench)")) return;
+    } catch {
+      // The target may still be navigating and can destroy the execution context.
+    }
+    await sleep(100);
+  }
+  throw new Error("window.browserSpeakBench was not installed.");
+}
+
+async function runPageTask(client, expression, { label = "page task", timeoutMs = 30000 } = {}) {
+  const taskId = `task_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  await client.evaluate(`(() => {
+    const taskId = ${JSON.stringify(taskId)};
+    window.__browserSpeakHarnessTasks ||= {};
+    window.__browserSpeakHarnessTasks[taskId] = { done: false, label: ${JSON.stringify(label)} };
+    Promise.resolve(${expression})
+      .then((value) => {
+        window.__browserSpeakHarnessTasks[taskId] = { done: true, value };
+      })
+      .catch((error) => {
+        window.__browserSpeakHarnessTasks[taskId] = {
+          done: true,
+          error: error?.stack || error?.message || String(error),
+        };
+      });
+    return true;
+  })()`);
+  const deadline = Date.now() + timeoutMs;
+  let lastEvents = [];
+  let lastPollError = "";
+  let pollErrorSince = 0;
+  while (Date.now() < deadline) {
+    let task = null;
+    try {
+      task = await client.evaluate(
+        `window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}] ?? null`,
+        pollTimeoutMs,
+      );
+      lastPollError = "";
+      pollErrorSince = 0;
+    } catch (error) {
+      const message = error.message ?? String(error);
+      pollErrorSince ||= Date.now();
+      if (message !== lastPollError) {
+        console.log(`${label}: waiting for page response (${message})`);
+        lastPollError = message;
+      }
+      if (Date.now() - pollErrorSince > pageUnresponsiveTimeoutMs) {
+        throw new Error(
+          `${label} page stayed unresponsive for ${(pageUnresponsiveTimeoutMs / 1000).toFixed(0)} seconds; last poll error: ${message}`,
+        );
+      }
+      await sleep(500);
+      continue;
+    }
+    if (task?.done) {
+      await client
+        .evaluate(`delete window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}]`, pollTimeoutMs)
+        .catch(() => {});
+      if (task.error) throw new Error(`${label} failed: ${task.error}`);
+      return task.value;
+    }
+    const snapshot = await client
+      .evaluate(`(() => {
+        const state = window.browserSpeakBench?.state?.();
+        return state ? {
+          modelsLoaded: state.modelsLoaded,
+          modelsLoading: state.modelsLoading,
+          activeBenchmark: state.activeBenchmark?.kind ?? null,
+          suiteRunning: state.suiteRunning,
+          events: state.events?.slice(0, 3) ?? [],
+        } : null;
+      })()`, pollTimeoutMs)
+      .catch(() => null);
+    const events = snapshot?.events ?? [];
+    if (events.join("\\n") !== lastEvents.join("\\n")) {
+      lastEvents = events;
+      if (events[0]) console.log(`${label}: ${events[0]}`);
+    }
+    await sleep(500);
+  }
+  throw new Error(`${label} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage",
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  if (!profileDir) return;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+      method,
+    }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page" && target.url === url);
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (!message.id || !this.pending.has(message.id)) return;
+    const { resolve: onResolve, reject } = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else onResolve(message.result);
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+    }, timeoutMs);
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  closeBrowser() {
+    try {
+      this.socket.send(JSON.stringify({ id: this.nextId++, method: "Browser.close", params: {} }));
+    } catch {
+      // The surrounding process cleanup handles already-closed targets.
+    }
+    try {
+      this.socket.close();
+    } catch {
+      // Ignore close races.
+    }
+  }
+}
+
+function formatException(exceptionDetails) {
+  const exception = exceptionDetails.exception;
+  return exception?.description ?? exception?.value ?? exceptionDetails.text ?? "Evaluation failed.";
+}
+
+function parseList(value) {
+  return String(value ?? "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseChromeArgs() {
+  const raw = process.env.BROWSER_SPEAK_CHROME_ARGS ?? "";
+  return (
+    raw
+      .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+      ?.map((arg) => arg.replace(/^["']|["']$/g, "")) ?? []
+  );
+}
+
+function stackLabel(stack) {
+  return [
+    shortModel(stack.llm),
+    shortModel(stack.asr),
+    stack.voice,
+    `${stack.ttsSteps} steps`,
+    `${stack.vadSilenceMs}ms`,
+    stack.ttsChunking ? `chunk ${stack.ttsChunking.firstTargetChars ?? "?"}/${stack.ttsChunking.targetChars ?? "?"}` : "",
+  ]
+    .filter(Boolean)
+    .join(" / ");
+}
+
+function shortModel(modelId = "") {
+  return modelId.split("/").at(-1)?.replace(/-ONNX$/, "") ?? modelId;
+}
+
+function summarizeCandidates(candidates) {
+  for (const candidate of candidates) {
+    const metrics = candidate.metrics ?? {};
+    const parts = [];
+    if (Number.isFinite(metrics.ttsMedianFirstAudioMs)) {
+      parts.push(`tts first audio ${formatMs(metrics.ttsMedianFirstAudioMs)}`);
+    }
+    if (Number.isFinite(metrics.modelLoadMs)) {
+      parts.push(`load ${formatMs(metrics.modelLoadMs)}`);
+    }
+    if (Number.isFinite(metrics.loopbackMedianSpeechEndToFirstAudioMs)) {
+      parts.push(`loopback end-to-audio ${formatMs(metrics.loopbackMedianSpeechEndToFirstAudioMs)}`);
+    }
+    if (Number.isFinite(metrics.identityMedianFirstAudioMs)) {
+      parts.push(`identity first audio ${formatMs(metrics.identityMedianFirstAudioMs)}`);
+    }
+    const suffix = parts.length > 0 ? `, ${parts.join(", ")}` : "";
+    const error = candidate.error ? ` (${candidate.error})` : "";
+    console.log(`${stackLabel(candidate.stack)}: ${candidate.status}, ${candidate.rowCount ?? 0} rows${suffix}${error}`);
+  }
+}
+
+function metricsForRows(rows) {
+  const completed = rows.filter((row) => !row.error);
+  const byKind = (kind) => completed.filter((row) => row.kind === kind);
+  const ttsRows = byKind("tts");
+  const identityRows = byKind("identity");
+  const chatRows = byKind("chat");
+  const loopbackRows = byKind("loopback");
+  return {
+    modelLoadMs: rows.find((row) => Number.isFinite(row.stack?.modelLoadMs))?.stack.modelLoadMs ?? null,
+    ttsRuns: ttsRows.length,
+    ttsMedianFirstAudioMs: median(ttsRows.map((row) => row.firstAudioMs)),
+    ttsMedianSynthesisMs: median(ttsRows.map((row) => row.firstTtsSynthesisMs)),
+    ttsMedianAudioEndMs: median(ttsRows.map((row) => row.audioEndMs)),
+    identityRuns: identityRows.length,
+    identityMedianFirstTokenMs: median(identityRows.map((row) => row.firstTokenMs)),
+    identityMedianFirstAudioMs: median(identityRows.map((row) => row.firstAudioMs)),
+    identityPasses: identityRows.filter((row) => row.llmQualityPass).length,
+    chatRuns: chatRows.length,
+    chatMedianFirstTokenMs: median(chatRows.map((row) => row.firstTokenMs)),
+    chatMedianFirstAudioMs: median(chatRows.map((row) => row.firstAudioMs)),
+    loopbackRuns: loopbackRows.length,
+    loopbackMedianWer: median(loopbackRows.map((row) => row.sttWer)),
+    loopbackMedianSpeechEndToFirstAudioMs: median(
+      loopbackRows.map((row) => row.speechEndToFirstAudioMs),
+    ),
+    loopbackMedianSpeechEndToAudioEndMs: median(
+      loopbackRows.map((row) => row.speechEndToAudioEndMs),
+    ),
+  };
+}
+
+function median(values) {
+  const finite = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (finite.length === 0) return null;
+  const middle = Math.floor(finite.length / 2);
+  if (finite.length % 2 === 1) return finite[middle];
+  return (finite[middle - 1] + finite[middle]) / 2;
+}
+
+function formatMs(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value < 1000) return `${Math.round(value)} ms`;
+  return `${(value / 1000).toFixed(2)} s`;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+await main();

tools/run-loopback-series.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const resultPath = resolve(process.env.BROWSER_SPEAK_LOOPBACK_JSON ?? `${tmpdir()}/browser-speak-loopback-series.json`);
+const rawPath = resolve(
+  process.env.BROWSER_SPEAK_LOOPBACK_RAW_JSON ?? `${tmpdir()}/browser-speak-loopback-series-raw.json`,
+);
+const count = Math.max(1, Number(process.env.BROWSER_SPEAK_LOOPBACK_COUNT ?? 3));
+const speed = Number(process.env.BROWSER_SPEAK_LOOPBACK_SPEED ?? 1.0);
+const text = process.env.BROWSER_SPEAK_LOOPBACK_TEXT ?? "Identify this browser demo.";
+const stack = {
+  device: process.env.BROWSER_SPEAK_DEVICE ?? "wasm",
+  llm: process.env.BROWSER_SPEAK_LLM ?? "HuggingFaceTB/SmolLM2-135M-Instruct",
+  asr: process.env.BROWSER_SPEAK_ASR ?? "onnx-community/moonshine-base-ONNX",
+  voice: process.env.BROWSER_SPEAK_VOICE ?? "F2",
+  ttsSteps: Number(process.env.BROWSER_SPEAK_TTS_STEPS ?? 2),
+  vadSilenceMs: Number(process.env.BROWSER_SPEAK_VAD_SILENCE_MS ?? 480),
+  partialAsr: process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false",
+};
+
+async function main() {
+  await mkdir(dirname(resultPath), { recursive: true });
+  await mkdir(dirname(rawPath), { recursive: true });
+  const env = {
+    ...process.env,
+    BROWSER_SPEAK_LOCAL_JSON: rawPath,
+    BROWSER_SPEAK_LOCAL_STACKS: JSON.stringify([stack]),
+    BROWSER_SPEAK_LOCAL_MAX_STACKS: "1",
+    BROWSER_SPEAK_LOCAL_PROFILE_DIR:
+      process.env.BROWSER_SPEAK_LOCAL_PROFILE_DIR ?? `${tmpdir()}/browser-speak-loopback-series-profile`,
+    BROWSER_SPEAK_LOCAL_TASKS: Array.from({ length: count }, () => "loopback").join(","),
+    BROWSER_SPEAK_LOAD_TIMEOUT_MS: process.env.BROWSER_SPEAK_LOAD_TIMEOUT_MS ?? "900000",
+    BROWSER_SPEAK_TASK_TIMEOUT_MS: process.env.BROWSER_SPEAK_TASK_TIMEOUT_MS ?? "240000",
+    BROWSER_SPEAK_LOOPBACK_SPEED: String(speed),
+    BROWSER_SPEAK_LOOPBACK_TEXT: text,
+  };
+  const exitCode = await runChild(process.execPath, [resolve(scriptDir, "run-local-candidate-benchmark.mjs")], env);
+  const raw = await readJson(rawPath).catch(() => null);
+  const payload = await summarize(raw, exitCode);
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote loopback series JSON: ${resultPath}`);
+  printSummary(payload);
+  if (!payload.passed) process.exitCode = exitCode || 1;
+}
+
+function runChild(command, args, env) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, { env, stdio: "inherit" });
+    child.on("exit", (code) => resolvePromise(code ?? 1));
+  });
+}
+
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function summarize(raw, exitCode) {
+  const rows = raw?.results?.filter((row) => row.kind === "loopback") ?? [];
+  const completed = rows.filter((row) => !row.error);
+  const errors = rows.filter((row) => row.error);
+  const transcripts = completed.map((row) => row.transcript ?? "");
+  return {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    passed: exitCode === 0 && rows.length >= count && errors.length === 0,
+    rawPath,
+    config: {
+      count,
+      text,
+      speed,
+      stack,
+      taskTimeoutMs: Number(process.env.BROWSER_SPEAK_TASK_TIMEOUT_MS ?? 240000),
+      url: process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/",
+    },
+    summary: {
+      requestedRuns: count,
+      producedRuns: rows.length,
+      completedRuns: completed.length,
+      errorRuns: errors.length,
+      exactTranscriptRuns: completed.filter((row) => row.sttWer === 0).length,
+      medianWer: median(completed.map((row) => row.sttWer)),
+      medianCer: median(completed.map((row) => row.sttCer)),
+      medianAsrMs: median(completed.map((row) => row.asrMs)),
+      medianFirstTokenMs: median(completed.map((row) => row.firstTokenMs)),
+      medianFirstAudioMs: median(completed.map((row) => row.firstAudioMs)),
+      medianSpeechEndToFirstAudioMs: median(completed.map((row) => row.speechEndToFirstAudioMs)),
+      medianSpeechEndToAudioEndMs: median(completed.map((row) => row.speechEndToAudioEndMs)),
+      identityPasses: completed.filter((row) => row.llmQualityPass).length,
+      transcripts,
+      errors: errors.map((row) => `${row.id ?? "?"}: ${row.error}`),
+    },
+    rows,
+    rawSummary: raw?.summary ?? null,
+    rawCandidates: raw?.candidates ?? [],
+  };
+}
+
+function median(values) {
+  const finite = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (finite.length === 0) return null;
+  const middle = Math.floor(finite.length / 2);
+  if (finite.length % 2 === 1) return finite[middle];
+  return (finite[middle - 1] + finite[middle]) / 2;
+}
+
+function printSummary(payload) {
+  const summary = payload.summary;
+  console.log(
+    [
+      `${summary.completedRuns}/${summary.requestedRuns} completed`,
+      `${summary.exactTranscriptRuns}/${summary.completedRuns} exact transcripts`,
+      `median WER ${formatPercent(summary.medianWer)}`,
+      `median speech-end-to-audio ${formatMs(summary.medianSpeechEndToFirstAudioMs)}`,
+    ].join(", "),
+  );
+  if (summary.transcripts.length > 0) {
+    console.log(`Transcripts: ${summary.transcripts.map((text) => JSON.stringify(text)).join(", ")}`);
+  }
+  for (const error of summary.errors) console.log(`Loopback error: ${error}`);
+}
+
+function formatMs(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value < 1000) return `${Math.round(value)} ms`;
+  return `${(value / 1000).toFixed(2)} s`;
+}
+
+function formatPercent(value) {
+  if (!Number.isFinite(value)) return "-";
+  return `${Math.round(value * 100)}%`;
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-real-mic-series.mjs

@@ -0,0 +1,517 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const dryRun = process.env.BROWSER_SPEAK_REAL_MIC_DRY_RUN === "true";
+const resultPath = resolve(
+  process.env.BROWSER_SPEAK_REAL_MIC_JSON ??
+    `${tmpdir()}/browser-speak-real-mic-series${dryRun ? "-dry-run" : ""}.json`,
+);
+const profileDir = resolve(process.env.BROWSER_SPEAK_REAL_MIC_PROFILE_DIR ?? `${tmpdir()}/browser-speak-real-mic-profile`);
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const loadTimeoutMs = Number(process.env.BROWSER_SPEAK_LOAD_TIMEOUT_MS ?? 900000);
+const rowTimeoutMs = Number(process.env.BROWSER_SPEAK_REAL_MIC_ROW_TIMEOUT_MS ?? 150000);
+const count = Math.max(1, Number(process.env.BROWSER_SPEAK_REAL_MIC_COUNT ?? 3));
+const headless = process.env.BROWSER_SPEAK_HEADLESS === "true";
+const reuseProfile = process.env.BROWSER_SPEAK_REAL_MIC_REUSE_PROFILE === "true";
+const autoAcceptMic = process.env.BROWSER_SPEAK_REAL_MIC_AUTO_ACCEPT !== "false";
+const allowFakeCapture = process.env.BROWSER_SPEAK_REAL_MIC_ALLOW_FAKE_CAPTURE === "true";
+const keepBrowserOpen = process.env.BROWSER_SPEAK_KEEP_BROWSER_OPEN === "true";
+const requireExactTranscript = process.env.BROWSER_SPEAK_REAL_MIC_REQUIRE_EXACT === "true";
+const ttsWarmup = process.env.BROWSER_SPEAK_TTS_WARMUP !== "false";
+const stack = {
+  device: process.env.BROWSER_SPEAK_DEVICE ?? "wasm",
+  llm: process.env.BROWSER_SPEAK_LLM ?? "HuggingFaceTB/SmolLM2-135M-Instruct",
+  asr: process.env.BROWSER_SPEAK_ASR ?? "onnx-community/moonshine-base-ONNX",
+  voice: process.env.BROWSER_SPEAK_VOICE ?? "F2",
+  ttsSteps: Number(process.env.BROWSER_SPEAK_TTS_STEPS ?? 2),
+  vadSilenceMs: Number(process.env.BROWSER_SPEAK_VAD_SILENCE_MS ?? 480),
+  partialAsr: process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false",
+  ttsWarmup,
+};
+
+async function main() {
+  if (dryRun) {
+    await mkdir(dirname(resultPath), { recursive: true });
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      sourceFingerprint: await sourceFingerprint(),
+      dryRun: true,
+      url,
+      config: runConfig(),
+      preflight: realMicPreflight(),
+      plannedRows: count,
+      prompt: "What app is this?",
+    };
+    await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+    console.log(`Wrote real microphone dry-run JSON: ${resultPath}`);
+    console.log(`Planned ${count} real microphone row(s).`);
+    for (const warning of payload.preflight.warnings) console.log(`Preflight warning: ${warning}`);
+    return;
+  }
+  const preflight = realMicPreflight();
+  if (!preflight.ok) throw new Error(preflight.warnings.join(" "));
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  if (!reuseProfile) await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9347, profileDir);
+  let client = null;
+  try {
+    client = await connectToPage(9347, browser);
+    await waitForBenchApi(client);
+    await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(stack)})`, {
+      label: "real-mic model load",
+      timeoutMs: loadTimeoutMs,
+    });
+    await runPageTask(client, "window.browserSpeakBench.clearResults()", { label: "clear results" });
+
+    console.log(`Real microphone validation: say "What app is this?" for each of ${count} row(s).`);
+    console.log("Keep the browser window focused and allow microphone access if Chrome asks.");
+    for (let i = 1; i <= count; i += 1) {
+      console.log(`Real microphone row ${i}/${count}: say "What app is this?"`);
+      await runPageTask(
+        client,
+        `window.browserSpeakBench.runMic(${JSON.stringify({
+          timeoutMs: Math.max(1000, rowTimeoutMs - 5000),
+          requireExactTranscript,
+        })})`,
+        {
+          label: `real microphone row ${i}`,
+          timeoutMs: rowTimeoutMs,
+        },
+      );
+    }
+    await runPageTask(client, "window.browserSpeakBench.stopMic()", { label: "stop microphone", timeoutMs: 30000 });
+
+    const exportPayload = await runPageTask(client, "window.browserSpeakBench.exportResults()", {
+      label: "export results",
+      timeoutMs: 30000,
+    });
+    const rows = exportPayload.results.filter((row) => row.kind === "mic").slice(0, count);
+    const errors = rows.filter((row) => row.error);
+    const exactRows = rows.filter((row) => row.sttWer === 0).length;
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      sourceFingerprint: await sourceFingerprint(),
+      url,
+      passed: rows.length >= count && errors.length === 0 && (!requireExactTranscript || exactRows >= count),
+      config: {
+        ...runConfig(),
+      },
+      hostMetadata: exportPayload.hostMetadata ?? null,
+      runtime: exportPayload.runtime ?? null,
+      evidence: exportPayload.evidence ?? null,
+      summary: summarizeRows(rows),
+      exportSummary: exportPayload.summary,
+      browserExport: exportPayload,
+      results: exportPayload.results,
+    };
+    await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+    console.log(`Wrote real microphone benchmark JSON: ${resultPath}`);
+    console.log(
+      [
+        `${rows.length}/${count} rows`,
+        `${exactRows}/${rows.length} exact transcripts`,
+        `median WER ${formatPercent(payload.summary.medianWer)}`,
+        `median speech-end-to-audio ${formatMs(payload.summary.medianSpeechEndToFirstAudioMs)}`,
+      ].join(", "),
+    );
+    if (!payload.passed) process.exitCode = 1;
+    if (!keepBrowserOpen) await client.closeBrowser();
+  } catch (error) {
+    await writeFailurePayload(client, browser, error).catch(() => {});
+    if (client && !keepBrowserOpen) await client.closeBrowser().catch(() => {});
+    throw error;
+  } finally {
+    if (!keepBrowserOpen) await stopBrowser(browser, reuseProfile ? null : profileDir);
+  }
+}
+
+async function writeFailurePayload(client, browser, error) {
+  const snapshot = client
+    ? await client.evaluate("window.browserSpeakBench?.state?.() ?? null", pollTimeoutMs).catch(() => null)
+    : null;
+  await writeFile(
+    resultPath,
+    `${JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        sourceFingerprint: await sourceFingerprint(),
+        passed: false,
+        error: error.stack ?? error.message ?? String(error),
+        browserLog: browser?.browserLog ?? "",
+        config: {
+          ...runConfig(),
+        },
+        snapshot,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  console.log(`Wrote real microphone failure JSON: ${resultPath}`);
+}
+
+function runConfig() {
+  return {
+    stack,
+    count,
+    rowTimeoutMs,
+    requireExactTranscript,
+    headless,
+    dryRun,
+    reuseProfile,
+    autoAcceptMic,
+    allowFakeCapture,
+    keepBrowserOpen,
+    chrome,
+    profileDir,
+    extraChromeArgs: parseChromeArgs(),
+  };
+}
+
+function realMicPreflight() {
+  const warnings = [];
+  const fakeCaptureArgs = parseChromeArgs().filter(isFakeCaptureArg);
+  if (!headless && process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+    warnings.push(
+      "Visible Chrome needs DISPLAY or WAYLAND_DISPLAY on Linux. Run from a desktop session, set BROWSER_SPEAK_HEADLESS=true, or provide a display.",
+    );
+  }
+  if (!existsSync(chrome) && chrome.includes("/")) {
+    warnings.push(`Chrome binary was not found: ${chrome}`);
+  }
+  if (!allowFakeCapture && fakeCaptureArgs.length > 0) {
+    warnings.push(
+      `Real microphone validation cannot use fake-capture Chrome args: ${fakeCaptureArgs.join(
+        ", ",
+      )}. Set BROWSER_SPEAK_REAL_MIC_ALLOW_FAKE_CAPTURE=true only for harness debugging.`,
+    );
+  }
+  return {
+    ok: warnings.length === 0,
+    warnings,
+    fakeCaptureArgs,
+    platform: process.platform,
+    display: process.env.DISPLAY ?? "",
+    waylandDisplay: process.env.WAYLAND_DISPLAY ?? "",
+  };
+}
+
+function summarizeRows(rows) {
+  return {
+    rows: rows.length,
+    completedRows: rows.filter((row) => !row.error).length,
+    errorRows: rows.filter((row) => row.error).length,
+    exactTranscriptRows: rows.filter((row) => row.sttWer === 0).length,
+    medianWer: median(rows.map((row) => row.sttWer)),
+    medianCer: median(rows.map((row) => row.sttCer)),
+    medianAsrMs: median(rows.map((row) => row.asrMs)),
+    medianFirstTokenMs: median(rows.map((row) => row.firstTokenMs)),
+    medianFirstAudioMs: median(rows.map((row) => row.firstAudioMs)),
+    medianSpeechEndToFirstAudioMs: median(rows.map((row) => row.speechEndToFirstAudioMs)),
+    medianSpeechEndToAudioEndMs: median(rows.map((row) => row.speechEndToAudioEndMs)),
+    identityPasses: rows.filter((row) => row.llmQualityPass).length,
+    transcripts: rows.map((row) => row.transcript ?? ""),
+    errors: rows.filter((row) => row.error).map((row) => row.error),
+  };
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+async function waitForBenchApi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      if (await client.evaluate("Boolean(window.browserSpeakBench)")) return;
+    } catch {
+      // The target may still be navigating.
+    }
+    await sleep(100);
+  }
+  throw new Error("window.browserSpeakBench was not installed.");
+}
+
+async function runPageTask(client, expression, { label = "page task", timeoutMs = 30000 } = {}) {
+  const taskId = `task_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  await client.evaluate(`(() => {
+    const taskId = ${JSON.stringify(taskId)};
+    window.__browserSpeakHarnessTasks ||= {};
+    window.__browserSpeakHarnessTasks[taskId] = { done: false, label: ${JSON.stringify(label)} };
+    Promise.resolve(${expression})
+      .then((value) => {
+        window.__browserSpeakHarnessTasks[taskId] = { done: true, value };
+      })
+      .catch((error) => {
+        window.__browserSpeakHarnessTasks[taskId] = {
+          done: true,
+          error: error?.stack || error?.message || String(error),
+        };
+      });
+    return true;
+  })()`);
+  const deadline = Date.now() + timeoutMs;
+  let lastEvents = [];
+  let lastPollError = "";
+  while (Date.now() < deadline) {
+    let task = null;
+    try {
+      task = await client.evaluate(
+        `window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}] ?? null`,
+        pollTimeoutMs,
+      );
+      lastPollError = "";
+    } catch (error) {
+      const message = error.message ?? String(error);
+      if (message !== lastPollError) {
+        console.log(`${label}: waiting for page response (${message})`);
+        lastPollError = message;
+      }
+      await sleep(500);
+      continue;
+    }
+    if (task?.done) {
+      await client
+        .evaluate(`delete window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}]`, pollTimeoutMs)
+        .catch(() => {});
+      if (task.error) throw new Error(`${label} failed: ${task.error}`);
+      return task.value;
+    }
+    const snapshot = await client
+      .evaluate(`(() => {
+        const state = window.browserSpeakBench?.state?.();
+        return state ? {
+          modelsLoaded: state.modelsLoaded,
+          modelsLoading: state.modelsLoading,
+          micActive: state.micActive,
+          activeBenchmark: state.activeBenchmark?.kind ?? null,
+          micSeries: state.micSeries,
+          events: state.events?.slice(0, 3) ?? [],
+        } : null;
+      })()`, pollTimeoutMs)
+      .catch(() => null);
+    const events = snapshot?.events ?? [];
+    if (events.join("\n") !== lastEvents.join("\n")) {
+      lastEvents = events;
+      if (events[0]) console.log(`${label}: ${events[0]}`);
+    }
+    await sleep(500);
+  }
+  throw new Error(`${label} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-dev-shm-usage",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      ...(autoAcceptMic ? ["--use-fake-ui-for-media-stream"] : []),
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  if (!profileDir) return;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+      method,
+    }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page" && target.url === url);
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (!message.id || !this.pending.has(message.id)) return;
+    const { resolve: onResolve, reject } = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else onResolve(message.result);
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call(
+      "Runtime.evaluate",
+      {
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+      },
+      timeoutMs,
+    );
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  async closeBrowser() {
+    await this.call("Browser.close").catch(() => {});
+  }
+}
+
+function formatException(details) {
+  return details.exception?.description ?? details.text ?? "Evaluation failed.";
+}
+
+function parseChromeArgs() {
+  return (process.env.BROWSER_SPEAK_CHROME_ARGS ?? "")
+    .split(/\s+/)
+    .map((arg) => arg.trim())
+    .filter(Boolean);
+}
+
+function isFakeCaptureArg(arg) {
+  return (
+    arg === "--use-fake-device-for-media-stream" ||
+    arg.startsWith("--use-file-for-fake-audio-capture=") ||
+    arg.startsWith("--use-file-for-fake-video-capture=")
+  );
+}
+
+function median(values) {
+  const finite = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (finite.length === 0) return null;
+  const middle = Math.floor(finite.length / 2);
+  if (finite.length % 2 === 1) return finite[middle];
+  return (finite[middle - 1] + finite[middle]) / 2;
+}
+
+function formatMs(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value < 1000) return `${Math.round(value)} ms`;
+  return `${(value / 1000).toFixed(2)} s`;
+}
+
+function formatPercent(value) {
+  if (!Number.isFinite(value)) return "-";
+  return `${Math.round(value * 100)}%`;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-tts-sweep-benchmark.mjs

@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const resultPath = resolve(process.env.BROWSER_SPEAK_TTS_SWEEP_JSON ?? `${tmpdir()}/browser-speak-tts-sweep.json`);
+const profileDir = resolve(process.env.BROWSER_SPEAK_TTS_SWEEP_PROFILE_DIR ?? `${tmpdir()}/browser-speak-tts-sweep-profile`);
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const loadTimeoutMs = Number(process.env.BROWSER_SPEAK_LOAD_TIMEOUT_MS ?? 360000);
+const taskTimeoutMs = Number(process.env.BROWSER_SPEAK_TASK_TIMEOUT_MS ?? 120000);
+const headless = process.env.BROWSER_SPEAK_HEADLESS !== "false";
+const dryRun = process.env.BROWSER_SPEAK_TTS_SWEEP_DRY_RUN === "true";
+const voices = parseList(process.env.BROWSER_SPEAK_TTS_SWEEP_VOICES ?? "F1,F2,M1,M2");
+const steps = parseList(process.env.BROWSER_SPEAK_TTS_SWEEP_STEPS ?? "2,4,8").map((value) => Number(value));
+const stack = {
+  device: process.env.BROWSER_SPEAK_DEVICE ?? "wasm",
+  llm: process.env.BROWSER_SPEAK_LLM ?? "HuggingFaceTB/SmolLM2-135M-Instruct",
+  asr: process.env.BROWSER_SPEAK_ASR ?? "onnx-community/moonshine-base-ONNX",
+  voice: voices[0] ?? "F2",
+  ttsSteps: steps[0] ?? 2,
+  vadSilenceMs: Number(process.env.BROWSER_SPEAK_VAD_SILENCE_MS ?? 480),
+  partialAsr: process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false",
+};
+const candidates = buildCandidates();
+
+async function main() {
+  if (dryRun) {
+    await mkdir(dirname(resultPath), { recursive: true });
+    await writeJson({
+      generatedAt: new Date().toISOString(),
+      dryRun: true,
+      url,
+      config: benchmarkConfig(),
+      candidates: candidates.map((candidate) => ({ ...candidate, status: "planned" })),
+    });
+    console.log(`Wrote TTS sweep dry-run JSON: ${resultPath}`);
+    console.log(`Planned ${candidates.length} TTS candidate(s): ${candidates.map(candidateLabel).join("; ")}`);
+    return;
+  }
+
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9345, profileDir);
+  try {
+    const client = await connectToPage(9345, browser);
+    await waitForBenchApi(client);
+    await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(stack)})`, {
+      label: "model load",
+      timeoutMs: loadTimeoutMs,
+    });
+    await runPageTask(client, "window.browserSpeakBench.clearResults()", { label: "clear results" });
+
+    for (const candidate of candidates) {
+      console.log(`Running TTS sweep candidate: ${candidateLabel(candidate)}`);
+      try {
+        await runPageTask(client, `window.browserSpeakBench.setRuntimeOptions(${JSON.stringify(candidate)})`, {
+          label: `${candidateLabel(candidate)} options`,
+          timeoutMs: 20000,
+        });
+        await runPageTask(
+          client,
+          `window.browserSpeakBench.preloadVoice(${JSON.stringify({ voice: candidate.voice })})`,
+          {
+            label: `${candidateLabel(candidate)} voice preload`,
+            timeoutMs: 45000,
+          },
+        );
+        const before = await runPageTask(client, "window.browserSpeakBench.state()", {
+          label: `${candidateLabel(candidate)} preflight`,
+        });
+        const snapshot = await runPageTask(client, "window.browserSpeakBench.runTts({ timeoutMs: 90000 })", {
+          label: `${candidateLabel(candidate)} tts`,
+          timeoutMs: taskTimeoutMs,
+        });
+        const added = snapshot.results.slice(0, Math.max(0, snapshot.results.length - before.results.length));
+        const row = added.find((result) => result.kind === "tts");
+        candidate.status = row && !row.error ? "complete" : "failed";
+        candidate.rowId = row?.id ?? null;
+        candidate.error = row?.error || "";
+        candidate.metrics = row
+          ? {
+              firstAudioMs: row.firstAudioMs,
+              synthesisMs: row.firstTtsSynthesisMs,
+              audioEndMs: row.audioEndMs,
+              firstTtsRoundTripMs: row.firstTtsRoundTripMs,
+              firstTtsPlaybackDelayMs: row.firstTtsPlaybackDelayMs,
+              modelLoadMs: row.stack?.modelLoadMs ?? null,
+            }
+          : null;
+      } catch (error) {
+        candidate.status = "failed";
+        candidate.error = error.message;
+        console.error(`${candidateLabel(candidate)} failed: ${error.message}`);
+      } finally {
+        await writeJson(await exportPayload(client));
+      }
+    }
+
+    const payload = await exportPayload(client);
+    await writeJson(payload);
+    console.log(`Wrote TTS sweep benchmark JSON: ${resultPath}`);
+    summarizeCandidates(candidates);
+    client.closeBrowser();
+  } finally {
+    await stopBrowser(browser, profileDir);
+  }
+}
+
+async function exportPayload(client) {
+  const exportResult = await runPageTask(client, "window.browserSpeakBench.exportResults()", {
+    label: "export results",
+    timeoutMs: 30000,
+  }).catch(() => ({ summary: null, results: [] }));
+  return {
+    generatedAt: new Date().toISOString(),
+    url,
+    config: benchmarkConfig(),
+    candidates,
+    summary: exportResult.summary,
+    results: exportResult.results,
+  };
+}
+
+function benchmarkConfig() {
+  return {
+    stack,
+    voices,
+    steps,
+    candidateCount: candidates.length,
+    loadTimeoutMs,
+    taskTimeoutMs,
+    protocolTimeoutMs,
+    pollTimeoutMs,
+    headless,
+    chrome,
+    profileDir,
+    extraChromeArgs: parseChromeArgs(),
+  };
+}
+
+function buildCandidates() {
+  const list = [];
+  for (const voice of voices) {
+    for (const ttsSteps of steps) {
+      list.push({ voice, ttsSteps });
+    }
+  }
+  return list;
+}
+
+async function writeJson(payload) {
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+async function waitForBenchApi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      if (await client.evaluate("Boolean(window.browserSpeakBench?.setRuntimeOptions)")) return;
+    } catch {
+      // The target may still be navigating and can destroy the execution context.
+    }
+    await sleep(100);
+  }
+  throw new Error("window.browserSpeakBench.setRuntimeOptions was not installed.");
+}
+
+async function runPageTask(client, expression, { label = "page task", timeoutMs = 30000 } = {}) {
+  const taskId = `task_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  await client.evaluate(`(() => {
+    const taskId = ${JSON.stringify(taskId)};
+    window.__browserSpeakHarnessTasks ||= {};
+    window.__browserSpeakHarnessTasks[taskId] = { done: false, label: ${JSON.stringify(label)} };
+    Promise.resolve(${expression})
+      .then((value) => {
+        window.__browserSpeakHarnessTasks[taskId] = { done: true, value };
+      })
+      .catch((error) => {
+        window.__browserSpeakHarnessTasks[taskId] = {
+          done: true,
+          error: error?.stack || error?.message || String(error),
+        };
+      });
+    return true;
+  })()`);
+  const deadline = Date.now() + timeoutMs;
+  let lastEvents = [];
+  let lastPollError = "";
+  while (Date.now() < deadline) {
+    let task = null;
+    try {
+      task = await client.evaluate(
+        `window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}] ?? null`,
+        pollTimeoutMs,
+      );
+      lastPollError = "";
+    } catch (error) {
+      const message = error.message ?? String(error);
+      if (message !== lastPollError) {
+        console.log(`${label}: waiting for page response (${message})`);
+        lastPollError = message;
+      }
+      await sleep(500);
+      continue;
+    }
+    if (task?.done) {
+      await client
+        .evaluate(`delete window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}]`, pollTimeoutMs)
+        .catch(() => {});
+      if (task.error) throw new Error(`${label} failed: ${task.error}`);
+      return task.value;
+    }
+    const snapshot = await client
+      .evaluate(`(() => {
+        const state = window.browserSpeakBench?.state?.();
+        return state ? {
+          modelsLoaded: state.modelsLoaded,
+          modelsLoading: state.modelsLoading,
+          activeBenchmark: state.activeBenchmark?.kind ?? null,
+          events: state.events?.slice(0, 3) ?? [],
+        } : null;
+      })()`, pollTimeoutMs)
+      .catch(() => null);
+    const events = snapshot?.events ?? [];
+    if (events.join("\\n") !== lastEvents.join("\\n")) {
+      lastEvents = events;
+      if (events[0]) console.log(`${label}: ${events[0]}`);
+    }
+    await sleep(500);
+  }
+  throw new Error(`${label} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage",
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+      method,
+    }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page" && target.url === url);
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (!message.id || !this.pending.has(message.id)) return;
+    const { resolve: onResolve, reject } = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else onResolve(message.result);
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+    }, timeoutMs);
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  closeBrowser() {
+    try {
+      this.socket.send(JSON.stringify({ id: this.nextId++, method: "Browser.close", params: {} }));
+    } catch {
+      // The surrounding process cleanup handles already-closed targets.
+    }
+    try {
+      this.socket.close();
+    } catch {
+      // Ignore close races.
+    }
+  }
+}
+
+function formatException(exceptionDetails) {
+  const exception = exceptionDetails.exception;
+  return exception?.description ?? exception?.value ?? exceptionDetails.text ?? "Evaluation failed.";
+}
+
+function parseList(value) {
+  return String(value ?? "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseChromeArgs() {
+  const raw = process.env.BROWSER_SPEAK_CHROME_ARGS ?? "";
+  return (
+    raw
+      .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+      ?.map((arg) => arg.replace(/^["']|["']$/g, "")) ?? []
+  );
+}
+
+function candidateLabel(candidate) {
+  return `${candidate.voice} / ${candidate.ttsSteps} steps`;
+}
+
+function summarizeCandidates(items) {
+  for (const candidate of items) {
+    const metrics = candidate.metrics ?? {};
+    const suffix = Number.isFinite(metrics.firstAudioMs) ? `, first audio ${formatMs(metrics.firstAudioMs)}` : "";
+    const error = candidate.error ? ` (${candidate.error})` : "";
+    console.log(`${candidateLabel(candidate)}: ${candidate.status ?? "pending"}${suffix}${error}`);
+  }
+}
+
+function formatMs(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value < 1000) return `${Math.round(value)} ms`;
+  return `${(value / 1000).toFixed(2)} s`;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+await main();

tools/run-ui-smoke.mjs

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const resultPath = resolve(process.env.BROWSER_SPEAK_UI_JSON ?? `${tmpdir()}/browser-speak-ui-smoke.json`);
+const screenshotDir = resolve(process.env.BROWSER_SPEAK_UI_SCREENSHOT_DIR ?? `${tmpdir()}/browser-speak-ui-smoke`);
+const profileDir = resolve(process.env.BROWSER_SPEAK_UI_PROFILE_DIR ?? `${tmpdir()}/browser-speak-ui-profile`);
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+const headless = process.env.BROWSER_SPEAK_HEADLESS !== "false";
+const viewports = parseViewports(
+  process.env.BROWSER_SPEAK_UI_VIEWPORTS ?? "desktop:1440x1200,mobile:390x1100",
+);
+
+async function main() {
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  await mkdir(screenshotDir, { recursive: true });
+  await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9345, profileDir);
+  const results = [];
+  try {
+    const client = await connectToPage(9345, browser);
+    await client.call("Page.enable");
+    await client.call("Runtime.enable");
+
+    for (const viewport of viewports) {
+      console.log(`Checking UI viewport: ${viewport.name} ${viewport.width}x${viewport.height}`);
+      await client.call("Emulation.setDeviceMetricsOverride", {
+        width: viewport.width,
+        height: viewport.height,
+        deviceScaleFactor: viewport.deviceScaleFactor,
+        mobile: viewport.mobile,
+      });
+      await client.call("Page.navigate", { url });
+      await waitForUi(client);
+      const audit = await client.evaluate(`(${auditUi.toString()})()`, pollTimeoutMs);
+      const screenshotPath = resolve(screenshotDir, `${viewport.name}.png`);
+      const screenshot = await client.call("Page.captureScreenshot", {
+        format: "png",
+        captureBeyondViewport: false,
+      });
+      await writeFile(screenshotPath, Buffer.from(screenshot.data, "base64"));
+      const errors = auditErrors(audit);
+      results.push({
+        ...viewport,
+        screenshotPath,
+        ...audit,
+        status: errors.length === 0 ? "pass" : "fail",
+        errors,
+      });
+    }
+
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      sourceFingerprint: await sourceFingerprint(),
+      url,
+      config: {
+        chrome,
+        headless,
+        protocolTimeoutMs,
+        pollTimeoutMs,
+        screenshotDir,
+        viewports,
+        extraChromeArgs: parseChromeArgs(),
+      },
+      results,
+      passed: results.every((result) => result.status === "pass"),
+    };
+    await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+    console.log(`Wrote UI smoke JSON: ${resultPath}`);
+    console.log(`Wrote screenshots: ${screenshotDir}`);
+    for (const result of results) {
+      const suffix = result.errors.length > 0 ? ` (${result.errors.join("; ")})` : "";
+      console.log(`${result.name}: ${result.status}${suffix}`);
+    }
+    if (!payload.passed) process.exitCode = 1;
+    await client.closeBrowser();
+  } finally {
+    await stopBrowser(browser, profileDir);
+  }
+}
+
+function auditUi() {
+  const byId = (id) => document.getElementById(id);
+  const required = [
+    "loadButton",
+    "micButton",
+    "stopButton",
+    "deviceSelect",
+    "runtimeStatus",
+    "runtimeDeviceStatus",
+    "runtimeDeviceDetail",
+    "runtimeBuildStatus",
+    "micValidationCard",
+    "micValidationStatus",
+    "micValidationDetail",
+    "micValidationProgressBar",
+    "gpuValidationCard",
+    "gpuValidationStatus",
+    "gpuValidationDetail",
+    "gpuValidationProgressBar",
+    "gpuBenchmarkButton",
+    "evidenceCaptureButton",
+    "partialTranscript",
+    "finalTranscript",
+    "llmOutput",
+    "benchmarkSummary",
+    "resultsBody",
+  ];
+  const missing = required.filter((id) => !byId(id));
+  const runtime = {
+    state: byId("runtimeStatus")?.dataset.state ?? "",
+    label: byId("runtimeDeviceStatus")?.textContent?.trim() ?? "",
+    detail: byId("runtimeDeviceDetail")?.textContent?.trim() ?? "",
+    build: byId("runtimeBuildStatus")?.textContent?.trim() ?? "",
+  };
+  const micValidation = {
+    state: byId("micValidationCard")?.dataset.state ?? "",
+    status: byId("micValidationStatus")?.textContent?.trim() ?? "",
+    detail: byId("micValidationDetail")?.textContent?.trim() ?? "",
+    progress: byId("micValidationProgressBar")?.style.width ?? "",
+  };
+  const gpuValidation = {
+    state: byId("gpuValidationCard")?.dataset.state ?? "",
+    status: byId("gpuValidationStatus")?.textContent?.trim() ?? "",
+    detail: byId("gpuValidationDetail")?.textContent?.trim() ?? "",
+    progress: byId("gpuValidationProgressBar")?.style.width ?? "",
+  };
+  const selectors = [
+    "button",
+    "select",
+    ".status-tile",
+    ".runtime-status",
+    ".build-status",
+    ".mic-validation",
+    ".badge",
+    ".summary-item",
+    ".settings label",
+    ".metrics dl div",
+  ];
+  const inspected = Array.from(document.querySelectorAll(selectors.join(","))).filter(
+    (element) => !element.closest(".table-wrap"),
+  );
+  const overflows = inspected
+    .map((element) => {
+      const rect = element.getBoundingClientRect();
+      const style = getComputedStyle(element);
+      const text = element.textContent?.replace(/\s+/g, " ").trim() ?? "";
+      const allowsHorizontalScroll = ["auto", "scroll", "hidden", "clip"].includes(style.overflowX);
+      return {
+        selector: element.id ? `#${element.id}` : element.className ? `.${String(element.className).split(/\s+/)[0]}` : element.tagName.toLowerCase(),
+        text: text.slice(0, 80),
+        left: Math.round(rect.left),
+        right: Math.round(rect.right),
+        width: Math.round(rect.width),
+        scrollWidth: element.scrollWidth,
+        clientWidth: element.clientWidth,
+        offscreen: rect.left < -1 || rect.right > window.innerWidth + 1,
+        clippedText: element.scrollWidth > element.clientWidth + 3 && !allowsHorizontalScroll,
+      };
+    })
+    .filter((item) => item.offscreen || item.clippedText);
+  const tiles = Array.from(document.querySelectorAll(".status-tile")).map((tile) => ({
+    id: tile.id,
+    state: tile.dataset.state,
+    text: tile.textContent?.replace(/\s+/g, " ").trim() ?? "",
+  }));
+  const requiredApiMethods = [
+    "state",
+    "exportResults",
+    "downloadResults",
+    "clearResults",
+    "loadStack",
+    "unload",
+    "runSuite",
+    "runEvidenceCapture",
+    "runMic",
+    "runMicSeries",
+    "runWebGpuEvidence",
+    "webgpuInfo",
+  ];
+  return {
+    title: document.title,
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight,
+      documentWidth: document.documentElement.scrollWidth,
+      documentHeight: document.documentElement.scrollHeight,
+    },
+    automationApi: {
+      installed: Boolean(window.browserSpeakBench),
+      version: window.browserSpeakBench?.version ?? null,
+      missingMethods: requiredApiMethods.filter((method) => typeof window.browserSpeakBench?.[method] !== "function"),
+    },
+    controls: {
+      loadButtonDisabled: byId("loadButton")?.disabled ?? null,
+      micButtonDisabled: byId("micButton")?.disabled ?? null,
+      stopButtonDisabled: byId("stopButton")?.disabled ?? null,
+      gpuBenchmarkButtonDisabled: byId("gpuBenchmarkButton")?.disabled ?? null,
+      evidenceCaptureButtonDisabled: byId("evidenceCaptureButton")?.disabled ?? null,
+      deviceValue: byId("deviceSelect")?.value ?? "",
+    },
+    runtime,
+    micValidation,
+    gpuValidation,
+    tiles,
+    missing,
+    bodyHorizontalOverflow: document.documentElement.scrollWidth > window.innerWidth + 1,
+    visibleOverflow: overflows,
+    benchmarkEmptyText: byId("benchmarkSummary")?.textContent?.replace(/\s+/g, " ").trim() ?? "",
+  };
+}
+
+function auditErrors(audit) {
+  const errors = [];
+  if (audit.title !== "Local Voice LLM") errors.push(`unexpected title: ${audit.title}`);
+  if (!audit.automationApi.installed || audit.automationApi.version !== 1) errors.push("automation API missing");
+  if (audit.automationApi.missingMethods?.length > 0) {
+    errors.push(`automation API missing methods: ${audit.automationApi.missingMethods.join(", ")}`);
+  }
+  if (audit.missing.length > 0) errors.push(`missing elements: ${audit.missing.join(", ")}`);
+  if (audit.tiles.length !== 4) errors.push(`expected 4 status tiles, found ${audit.tiles.length}`);
+  if (audit.runtime.state === "checking" || !audit.runtime.label) errors.push("runtime status did not settle");
+  if (!audit.runtime.build || /pending/i.test(audit.runtime.build)) errors.push("runtime build status did not settle");
+  if (!/real-mic rows|models/i.test(audit.micValidation.status)) errors.push("real-mic validation status missing");
+  if (!/What app is this|Load a stack/i.test(audit.micValidation.detail)) errors.push("real-mic prompt detail missing");
+  if (!/WebGPU|adapter/i.test(audit.gpuValidation.status)) errors.push("hardware WebGPU validation status missing");
+  if (!/adapter|WebGPU|Hardware/i.test(audit.gpuValidation.detail)) errors.push("hardware WebGPU detail missing");
+  if (/Software WebGPU|No WebGPU/i.test(audit.gpuValidation.status) && audit.controls.gpuBenchmarkButtonDisabled !== true) {
+    errors.push("WebGPU evidence button should be disabled without hardware WebGPU");
+  }
+  if (audit.bodyHorizontalOverflow) errors.push("body has horizontal overflow");
+  if (audit.visibleOverflow.length > 0) {
+    errors.push(
+      `visible element overflow: ${audit.visibleOverflow
+        .slice(0, 4)
+        .map((item) => `${item.selector} ${item.text}`)
+        .join(" | ")}`,
+    );
+  }
+  if (!/No benchmark runs yet/.test(audit.benchmarkEmptyText)) errors.push("benchmark empty state missing");
+  return errors;
+}
+
+async function waitForUi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    const ready = await client
+      .evaluate(`(() => {
+        const runtime = document.getElementById("runtimeStatus");
+        const build = document.getElementById("runtimeBuildStatus");
+        return document.readyState === "complete" &&
+          Boolean(window.browserSpeakBench?.version) &&
+          runtime &&
+          runtime.dataset.state !== "checking" &&
+          build &&
+          !/pending/i.test(build.textContent || "");
+      })()`, pollTimeoutMs)
+      .catch(() => false);
+    if (ready) return;
+    await sleep(100);
+  }
+  throw new Error("UI did not become ready.");
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-dev-shm-usage",
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      "--enable-unsafe-webgpu",
+      "--ignore-gpu-blocklist",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?about%3Ablank`, { method }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page");
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (!message.id || !this.pending.has(message.id)) return;
+    const { resolve: onResolve, reject } = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else onResolve(message.result);
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call(
+      "Runtime.evaluate",
+      {
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+      },
+      timeoutMs,
+    );
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  async closeBrowser() {
+    await this.call("Browser.close", {}, 5000).catch(() => {});
+    try {
+      this.socket.close();
+    } catch {
+      // Ignore close races.
+    }
+  }
+}
+
+function formatException(exceptionDetails) {
+  const exception = exceptionDetails.exception;
+  return exception?.description ?? exception?.value ?? exceptionDetails.text ?? "Evaluation failed.";
+}
+
+function parseViewports(value) {
+  return String(value ?? "")
+    .split(",")
+    .map((entry) => {
+      const [namePart, sizePart] = entry.split(":");
+      const [width, height] = String(sizePart ?? "").split("x").map((part) => Number(part));
+      if (!namePart || !Number.isFinite(width) || !Number.isFinite(height)) {
+        throw new Error(`Invalid viewport entry: ${entry}`);
+      }
+      return {
+        name: namePart.trim(),
+        width,
+        height,
+        mobile: width < 600,
+        deviceScaleFactor: width < 600 ? 2 : 1,
+      };
+    });
+}
+
+function parseChromeArgs() {
+  const raw = process.env.BROWSER_SPEAK_CHROME_ARGS ?? "";
+  return (
+    raw
+      .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+      ?.map((arg) => arg.replace(/^["']|["']$/g, "")) ?? []
+  );
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

tools/run-webgpu-benchmark.mjs

@@ -0,0 +1,491 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const url = process.env.BROWSER_SPEAK_URL ?? "http://127.0.0.1:5174/";
+const chrome =
+  process.env.CHROME_BIN ??
+  (existsSync("/opt/google/chrome/chrome")
+    ? "/opt/google/chrome/chrome"
+    : existsSync("/usr/bin/google-chrome")
+      ? "/usr/bin/google-chrome"
+      : "chromium");
+const resultPath = resolve(process.env.BROWSER_SPEAK_WEBGPU_JSON ?? `${tmpdir()}/browser-speak-webgpu-results.json`);
+const profileDir = resolve(process.env.BROWSER_SPEAK_WEBGPU_PROFILE_DIR ?? `${tmpdir()}/browser-speak-webgpu-profile`);
+const llmCandidates = parseList(
+  process.env.BROWSER_SPEAK_WEBGPU_LLMS ??
+    "HuggingFaceTB/SmolLM2-135M-Instruct,onnx-community/granite-4.0-350m-ONNX-web,onnx-community/Qwen3-0.6B-ONNX",
+);
+const stackBase = {
+  device: "webgpu",
+  asr: process.env.BROWSER_SPEAK_ASR ?? "onnx-community/moonshine-base-ONNX",
+  voice: process.env.BROWSER_SPEAK_VOICE ?? "F2",
+  ttsSteps: Number(process.env.BROWSER_SPEAK_TTS_STEPS ?? 2),
+  vadSilenceMs: Number(process.env.BROWSER_SPEAK_VAD_SILENCE_MS ?? 480),
+  partialAsr: process.env.BROWSER_SPEAK_PARTIAL_ASR !== "false",
+};
+const loadTimeoutMs = Number(process.env.BROWSER_SPEAK_LOAD_TIMEOUT_MS ?? 600000);
+const suiteTimeoutMs = Number(process.env.BROWSER_SPEAK_SUITE_TIMEOUT_MS ?? 900000);
+const headless = process.env.BROWSER_SPEAK_HEADLESS !== "false";
+const allowSoftwareWebgpu = process.env.BROWSER_SPEAK_ALLOW_SOFTWARE_WEBGPU === "true";
+const protocolTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_TIMEOUT_MS ?? 60000);
+const pollTimeoutMs = Number(process.env.BROWSER_SPEAK_CDP_POLL_TIMEOUT_MS ?? 5000);
+
+async function main() {
+  await ensureServer();
+  await mkdir(dirname(resultPath), { recursive: true });
+  await rm(profileDir, { recursive: true, force: true });
+
+  const browser = launchBrowser(9343, profileDir);
+  const candidates = llmCandidates.map((llm) => ({ llm, status: "pending" }));
+  try {
+    const client = await connectToPage(9343, browser);
+    await waitForBenchApi(client);
+    const webgpu = await runPageTask(client, "window.browserSpeakBench.webgpuInfo()", {
+      label: "WebGPU probe",
+      timeoutMs: 30000,
+    });
+
+    const skipReason = webgpuSkipReason(webgpu);
+    if (skipReason) {
+      for (const candidate of candidates) {
+        candidate.status = "skipped";
+        candidate.reason = skipReason;
+      }
+      await writePayload({
+        skipped: true,
+        reason: skipReason,
+        webgpu,
+        config: benchmarkConfig(),
+        candidates,
+        results: [],
+        summary: null,
+      });
+      console.log(`Wrote WebGPU benchmark JSON: ${resultPath}`);
+      console.log(`Skipped WebGPU benchmark: ${skipReason}.`);
+      await client.closeBrowser();
+      return;
+    }
+
+    await runPageTask(client, "window.browserSpeakBench.clearResults()", { label: "clear results" });
+    console.log(`WebGPU adapter: ${formatAdapter(webgpu.adapter)}`);
+
+    for (const candidate of candidates) {
+      const stack = { ...stackBase, llm: candidate.llm };
+      const label = shortModelName(candidate.llm);
+      console.log(`Running WebGPU benchmark candidate: ${candidate.llm}`);
+      const startedAt = Date.now();
+      try {
+        const before = await runPageTask(client, "window.browserSpeakBench.state()", {
+          label: `${label} preflight`,
+        });
+        await runPageTask(client, `window.browserSpeakBench.loadStack(${JSON.stringify(stack)})`, {
+          label: `${label} model load`,
+          timeoutMs: loadTimeoutMs,
+        });
+        const snapshot = await runPageTask(client, "window.browserSpeakBench.runSuite()", {
+          label: `${label} suite`,
+          timeoutMs: suiteTimeoutMs,
+        });
+        const addedCount = Math.max(0, snapshot.results.length - before.results.length);
+        const rows = snapshot.results.slice(0, addedCount);
+        const errors = rows.filter((row) => row.error);
+        candidate.status = rows.length >= 5 && errors.length === 0 ? "complete" : "partial";
+        candidate.durationMs = Date.now() - startedAt;
+        candidate.rowCount = rows.length;
+        candidate.errorCount = errors.length;
+        candidate.summary = snapshot.summary.current ?? snapshot.summary.all;
+        candidate.stack = snapshot.stack;
+        if (errors.length > 0) candidate.errors = errors.map((row) => `${row.kind}: ${row.error}`);
+      } catch (error) {
+        candidate.status = "failed";
+        candidate.durationMs = Date.now() - startedAt;
+        candidate.error = error.message;
+        console.error(`${candidate.llm} failed: ${error.message}`);
+      } finally {
+        await runPageTask(client, "window.browserSpeakBench.stop()", {
+          label: `${label} stop`,
+          timeoutMs: 15000,
+        }).catch(() => {});
+        const state = await runPageTask(client, "window.browserSpeakBench.state()", {
+          label: `${label} state`,
+          timeoutMs: 15000,
+        }).catch(() => null);
+        if (state?.modelsLoaded || state?.modelsLoading) {
+          await runPageTask(client, "window.browserSpeakBench.unload()", {
+            label: `${label} unload`,
+            timeoutMs: 60000,
+          }).catch((error) => {
+            candidate.unloadError = error.message;
+          });
+        }
+        await writePayload(await exportPayload(client, webgpu, candidates));
+      }
+    }
+
+    const payload = await exportPayload(client, webgpu, candidates);
+    await writePayload(payload);
+    console.log(`Wrote WebGPU benchmark JSON: ${resultPath}`);
+    summarizeResults(payload);
+    await client.closeBrowser();
+  } finally {
+    await stopBrowser(browser, profileDir);
+  }
+}
+
+async function exportPayload(client, webgpu, candidates) {
+  const exportResult = await runPageTask(client, "window.browserSpeakBench.exportResults()", {
+    label: "export results",
+    timeoutMs: 30000,
+  }).catch(() => ({ summary: null, results: [] }));
+  return {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: await sourceFingerprint(),
+    url,
+    webgpu,
+    config: benchmarkConfig(),
+    candidates,
+    summary: exportResult.summary,
+    results: exportResult.results,
+  };
+}
+
+function benchmarkConfig() {
+  return {
+    stackBase,
+    loadTimeoutMs,
+    suiteTimeoutMs,
+    headless,
+    allowSoftwareWebgpu,
+    protocolTimeoutMs,
+    pollTimeoutMs,
+    chrome,
+    extraChromeArgs: parseChromeArgs(),
+  };
+}
+
+async function writePayload(payload) {
+  await writeFile(
+    resultPath,
+    `${JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        sourceFingerprint: await sourceFingerprint(),
+        url,
+        ...payload,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+async function ensureServer() {
+  const response = await fetch(url).catch((error) => {
+    throw new Error(`Could not reach ${url}: ${error.message}`);
+  });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+}
+
+async function waitForBenchApi(client) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      if (await client.evaluate("Boolean(window.browserSpeakBench?.webgpuInfo)")) return;
+    } catch {
+      // The target may still be navigating and can destroy the execution context.
+    }
+    await sleep(100);
+  }
+  throw new Error("window.browserSpeakBench.webgpuInfo was not installed.");
+}
+
+async function runPageTask(client, expression, { label = "page task", timeoutMs = 30000 } = {}) {
+  const taskId = `task_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  await client.evaluate(`(() => {
+    const taskId = ${JSON.stringify(taskId)};
+    window.__browserSpeakHarnessTasks ||= {};
+    window.__browserSpeakHarnessTasks[taskId] = { done: false, label: ${JSON.stringify(label)} };
+    Promise.resolve(${expression})
+      .then((value) => {
+        window.__browserSpeakHarnessTasks[taskId] = { done: true, value };
+      })
+      .catch((error) => {
+        window.__browserSpeakHarnessTasks[taskId] = {
+          done: true,
+          error: error?.stack || error?.message || String(error),
+        };
+      });
+    return true;
+  })()`);
+  const deadline = Date.now() + timeoutMs;
+  let lastEvents = [];
+  let lastPollError = "";
+  while (Date.now() < deadline) {
+    let task = null;
+    try {
+      task = await client.evaluate(
+        `window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}] ?? null`,
+        pollTimeoutMs,
+      );
+      lastPollError = "";
+    } catch (error) {
+      const message = error.message ?? String(error);
+      if (message !== lastPollError) {
+        console.log(`${label}: waiting for page response (${message})`);
+        lastPollError = message;
+      }
+      await sleep(500);
+      continue;
+    }
+    if (task?.done) {
+      await client
+        .evaluate(`delete window.__browserSpeakHarnessTasks?.[${JSON.stringify(taskId)}]`, pollTimeoutMs)
+        .catch(() => {});
+      if (task.error) throw new Error(`${label} failed: ${task.error}`);
+      return task.value;
+    }
+    const snapshot = await client
+      .evaluate(`(() => {
+        const state = window.browserSpeakBench?.state?.();
+        return state ? {
+          modelsLoaded: state.modelsLoaded,
+          modelsLoading: state.modelsLoading,
+          activeBenchmark: state.activeBenchmark?.kind ?? null,
+          suiteRunning: state.suiteRunning,
+          events: state.events?.slice(0, 3) ?? [],
+        } : null;
+      })()`, pollTimeoutMs)
+      .catch(() => null);
+    const events = snapshot?.events ?? [];
+    if (events.join("\\n") !== lastEvents.join("\\n")) {
+      lastEvents = events;
+      if (events[0]) console.log(`${label}: ${events[0]}`);
+    }
+    await sleep(500);
+  }
+  throw new Error(`${label} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`);
+}
+
+function launchBrowser(port, profileDir) {
+  const child = spawn(
+    chrome,
+    [
+      ...(headless ? ["--headless=new"] : []),
+      "--no-sandbox",
+      "--disable-dev-shm-usage",
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run",
+      "--autoplay-policy=no-user-gesture-required",
+      "--enable-unsafe-webgpu",
+      "--ignore-gpu-blocklist",
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profileDir}`,
+      ...parseChromeArgs(),
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  child.browserLog = "";
+  const appendLog = (chunk) => {
+    child.browserLog = `${child.browserLog}${chunk}`;
+    if (child.browserLog.length > 8000) child.browserLog = child.browserLog.slice(-8000);
+  };
+  child.stdout.on("data", appendLog);
+  child.stderr.on("data", appendLog);
+  return child;
+}
+
+async function stopBrowser(child, profileDir) {
+  if (child.exitCode == null) child.kill("SIGTERM");
+  await new Promise((resolve) => {
+    child.once("exit", resolve);
+    setTimeout(resolve, 3000);
+  });
+  if (child.exitCode == null) child.kill("SIGKILL");
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(profileDir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if (attempt === 4) {
+        console.warn(`Could not remove ${profileDir}: ${error.message}`);
+        return;
+      }
+      await sleep(500);
+    }
+  }
+}
+
+async function connectToPage(port, child) {
+  const deadline = Date.now() + 60000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    if (child.exitCode != null) {
+      throw new Error(`Chrome exited before DevTools became available.\n${child.browserLog}`);
+    }
+    try {
+      const version = await fetch(`http://127.0.0.1:${port}/json/version`).then((response) => response.json());
+      if (version.webSocketDebuggerUrl) {
+        const page = await createPageTarget(port);
+        return new CdpClient(page.webSocketDebuggerUrl);
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(250);
+  }
+  throw new Error(
+    `Could not connect to Chrome DevTools on port ${port}: ${lastError?.message ?? "unknown error"}\n${child.browserLog}`,
+  );
+}
+
+async function createPageTarget(port) {
+  for (const method of ["PUT", "GET"]) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+      method,
+    }).catch(() => null);
+    if (response?.ok) {
+      const target = await response.json();
+      if (target.webSocketDebuggerUrl) return target;
+    }
+  }
+  const targets = await fetch(`http://127.0.0.1:${port}/json`).then((response) => response.json());
+  const page = targets.find((target) => target.type === "page" && target.url === url);
+  if (page?.webSocketDebuggerUrl) return page;
+  throw new Error("Could not create or find a page target.");
+}
+
+class CdpClient {
+  constructor(webSocketUrl) {
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = new WebSocket(webSocketUrl);
+    this.opened = new Promise((resolve, reject) => {
+      this.socket.onopen = resolve;
+      this.socket.onerror = reject;
+      this.socket.onmessage = (event) => this.onMessage(event);
+    });
+  }
+
+  onMessage(event) {
+    const message = JSON.parse(event.data);
+    if (!message.id || !this.pending.has(message.id)) return;
+    const { resolve: onResolve, reject } = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else onResolve(message.result);
+  }
+
+  async call(method, params = {}, timeoutMs = protocolTimeoutMs) {
+    await this.opened;
+    const id = this.nextId++;
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${(timeoutMs / 1000).toFixed(0)} seconds.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolvePromise(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+    });
+  }
+
+  async evaluate(expression, timeoutMs = protocolTimeoutMs) {
+    const result = await this.call("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+    }, timeoutMs);
+    if (result.exceptionDetails) throw new Error(formatException(result.exceptionDetails));
+    return result.result.value;
+  }
+
+  closeBrowser() {
+    try {
+      this.socket.send(JSON.stringify({ id: this.nextId++, method: "Browser.close", params: {} }));
+    } catch {
+      // The surrounding process cleanup handles already-closed targets.
+    }
+    try {
+      this.socket.close();
+    } catch {
+      // Ignore close races.
+    }
+  }
+}
+
+function formatException(exceptionDetails) {
+  const exception = exceptionDetails.exception;
+  return exception?.description ?? exception?.value ?? exceptionDetails.text ?? "Evaluation failed.";
+}
+
+function parseList(value) {
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseChromeArgs() {
+  const raw = process.env.BROWSER_SPEAK_CHROME_ARGS ?? "";
+  return (
+    raw
+      .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+      ?.map((arg) => arg.replace(/^["']|["']$/g, "")) ?? []
+  );
+}
+
+function shortModelName(model) {
+  return model.split("/").at(-1) ?? model;
+}
+
+function formatAdapter(adapter) {
+  if (!adapter) return "unknown";
+  return [adapter.vendor, adapter.architecture, adapter.device, adapter.description].filter(Boolean).join(" / ") || "unknown";
+}
+
+function webgpuSkipReason(webgpu) {
+  if (!webgpu?.available) return "WebGPU unavailable";
+  if (allowSoftwareWebgpu) return "";
+  if (webgpu.softwareAdapter || isSoftwareAdapter(webgpu.adapter)) {
+    return `Software WebGPU adapter exposed (${formatAdapter(webgpu.adapter)})`;
+  }
+  return "";
+}
+
+function isSoftwareAdapter(adapter) {
+  const text = [adapter?.vendor, adapter?.architecture, adapter?.device, adapter?.description]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  return /\b(swiftshader|llvmpipe|software rasterizer|software adapter|warp)\b/.test(text);
+}
+
+function summarizeResults(payload) {
+  for (const candidate of payload.candidates) {
+    const suffix = candidate.error ? ` (${candidate.error})` : "";
+    console.log(`${candidate.llm}: ${candidate.status}, ${candidate.rowCount ?? 0} rows${suffix}`);
+  }
+  const byStack = payload.summary?.byStack ?? {};
+  const stackCount = Object.keys(byStack).length;
+  console.log(`Exported ${payload.results.length} rows across ${stackCount} stack summaries.`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+await main();

tools/source-fingerprint.mjs

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const SOURCE_FILES = [
+  "index.html",
+  "styles.css",
+  "app.js",
+  "workers/asr-worker.js",
+  "workers/llm-worker.js",
+  "workers/tts-worker.js",
+  "tools/run-ui-smoke.mjs",
+  "tools/run-evidence-export-smoke.mjs",
+  "tools/run-client-side-smoke.mjs",
+  "tools/run-hosted-smoke.mjs",
+  "tools/run-loopback-series.mjs",
+  "tools/run-fake-mic-benchmark.mjs",
+  "tools/run-local-candidate-benchmark.mjs",
+  "tools/run-real-mic-series.mjs",
+  "tools/run-hosted-evidence-capture.mjs",
+  "tools/run-webgpu-benchmark.mjs",
+  "tools/audit-browser-evidence.mjs",
+  "tools/audit-validation.mjs",
+  "tools/summarize-evidence.mjs",
+  "tools/source-fingerprint.mjs",
+];
+
+export async function sourceFingerprint() {
+  const fileFingerprints = [];
+  const aggregate = createHash("sha256");
+  for (const path of SOURCE_FILES) {
+    const bytes = await readFile(resolve(projectRoot, path));
+    const hash = createHash("sha256").update(bytes).digest("hex");
+    fileFingerprints.push({ path, sha256: hash, bytes: bytes.length });
+    aggregate.update(`${path}\0${hash}\0`);
+  }
+  return {
+    algorithm: "sha256",
+    hash: aggregate.digest("hex"),
+    files: fileFingerprints,
+  };
+}

tools/summarize-evidence.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { sourceFingerprint } from "./source-fingerprint.mjs";
+
+const paths = {
+  finalValidation: resolve(
+    process.env.BROWSER_SPEAK_FINAL_JSON ?? `${tmpdir()}/browser-speak-final-validation.json`,
+  ),
+  validationAudit: resolve(
+    process.env.BROWSER_SPEAK_AUDIT_JSON ?? `${tmpdir()}/browser-speak-validation-audit.json`,
+  ),
+  hostedSmoke: resolve(
+    process.env.BROWSER_SPEAK_HOSTED_SMOKE_JSON ?? `${tmpdir()}/browser-speak-hosted-smoke.json`,
+  ),
+  browserEvidenceAudit: resolve(
+    process.env.BROWSER_SPEAK_BROWSER_AUDIT_JSON ?? `${tmpdir()}/browser-speak-browser-evidence-audit.json`,
+  ),
+  realMic: resolve(process.env.BROWSER_SPEAK_REAL_MIC_JSON ?? `${tmpdir()}/browser-speak-real-mic-series.json`),
+  webgpu: resolve(process.env.BROWSER_SPEAK_WEBGPU_JSON ?? `${tmpdir()}/browser-speak-webgpu-results.json`),
+};
+const resultPath = resolve(
+  process.env.BROWSER_SPEAK_EVIDENCE_SUMMARY_JSON ?? `${tmpdir()}/browser-speak-evidence-summary.json`,
+);
+
+async function main() {
+  const currentSourceFingerprint = await sourceFingerprint();
+  const artifacts = Object.fromEntries(
+    await Promise.all(Object.entries(paths).map(async ([key, path]) => [key, await readArtifact(path, currentSourceFingerprint)])),
+  );
+  const checks = [
+    ...validationChecks(artifacts.validationAudit.value ?? artifacts.finalValidation.value?.audit),
+    hostedSmokeCheck(artifacts.hostedSmoke.value),
+    browserEvidenceCheck(artifacts.browserEvidenceAudit.value),
+    realMicArtifactCheck(artifacts.realMic.value),
+    webgpuArtifactCheck(artifacts.webgpu.value),
+    freshnessCheck(artifacts),
+  ];
+  const requiredChecks = dedupeChecks(checks).filter((check) => check.required);
+  const passed = requiredChecks.every((check) => check.status === "pass");
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    sourceFingerprint: currentSourceFingerprint,
+    passed,
+    artifacts: Object.fromEntries(Object.entries(artifacts).map(([key, artifact]) => [key, summarizeArtifact(artifact)])),
+    checks: requiredChecks,
+    nextActions: nextActions(requiredChecks),
+  };
+  await mkdir(dirname(resultPath), { recursive: true });
+  await writeFile(resultPath, `${JSON.stringify(payload, null, 2)}\n`);
+  console.log(`Wrote evidence summary JSON: ${resultPath}`);
+  console.log(`Source fingerprint: ${currentSourceFingerprint.hash}`);
+  for (const check of requiredChecks) {
+    console.log(`${check.status}: ${check.name} - ${check.message}`);
+  }
+  if (!passed) {
+    console.log("Next actions:");
+    for (const action of payload.nextActions) console.log(`- ${action}`);
+  }
+  if (!passed) process.exitCode = 1;
+}
+
+function validationChecks(audit) {
+  const checks = Array.isArray(audit?.checks)
+    ? audit.checks
+    : Array.isArray(audit?.required)
+      ? audit.required.map((check) => ({ ...check, required: true }))
+      : [];
+  return checks
+    .filter((check) => check.required !== false)
+    .map((check) => ({
+      name: check.name,
+      required: true,
+      status: check.status ?? "unknown",
+      message: check.message ?? "",
+      source: "validation audit",
+    }));
+}
+
+function hostedSmokeCheck(hostedSmoke) {
+  if (!hostedSmoke) {
+    return {
+      name: "hosted Space no-server smoke",
+      required: true,
+      status: "missing",
+      message: "Hosted smoke JSON is missing.",
+      source: "hosted smoke",
+    };
+  }
+  const passed =
+    hostedSmoke.passed === true &&
+    hostedSmoke.commitMatch === true &&
+    hostedSmoke.noServerSmoke === true &&
+    hostedSmoke.clientSideSummary?.benchmarkRequestCount === 0 &&
+    hostedSmoke.clientSideSummary?.serverInferenceSuspectCount === 0;
+  return {
+    name: "hosted Space no-server smoke",
+    required: true,
+    status: passed ? "pass" : "fail",
+    message: passed
+      ? `Hosted Space commit ${
+          hostedSmoke.hfInfo?.sha ?? hostedSmoke.hubApiInfo?.sha ?? "unknown"
+        } passed UI and no-server smoke.`
+      : "Hosted Space smoke did not prove the deployed no-server path.",
+    source: "hosted smoke",
+    evidence: {
+      spaceSha: hostedSmoke.hfInfo?.sha ?? null,
+      hubApiSha: hostedSmoke.hubApiInfo?.sha ?? null,
+      hostCommit: hostedSmoke.hostHead?.hfSpaceCommit ?? null,
+      commitMatch: hostedSmoke.commitMatch ?? null,
+      spaceConfigParsed: hostedSmoke.spaceConfigParsed ?? null,
+      runtimeStage: hostedSmoke.hubApiInfo?.runtime?.stage ?? hostedSmoke.hfInfo?.runtime?.stage ?? null,
+      noServerSmoke: hostedSmoke.noServerSmoke ?? null,
+      benchmarkRequestCount: hostedSmoke.clientSideSummary?.benchmarkRequestCount ?? null,
+      serverInferenceSuspectCount: hostedSmoke.clientSideSummary?.serverInferenceSuspectCount ?? null,
+      hostMetadata: hostedSmoke.clientSideSummary?.hostMetadata ?? null,
+    },
+  };
+}
+
+function browserEvidenceCheck(audit) {
+  if (!audit) {
+    return {
+      name: "downloaded browser evidence audit",
+      required: true,
+      status: "missing",
+      message: "Browser-downloaded benchmark evidence has not been audited.",
+      source: "browser evidence audit",
+    };
+  }
+  return {
+    name: "downloaded browser evidence audit",
+    required: true,
+    status: audit.passed === true ? "pass" : "missing",
+    message:
+      audit.passed === true
+        ? "Downloaded browser evidence meets real-mic and hardware-WebGPU gates."
+        : "Downloaded browser evidence is missing real-mic rows, hardware-WebGPU rows, or hosted metadata.",
+    source: "browser evidence audit",
+    evidence: {
+      inputPath: audit.inputPath ?? null,
+      checks: audit.checks?.map(({ name, status, message }) => ({ name, status, message })) ?? [],
+    },
+  };
+}
+
+function realMicArtifactCheck(realMic) {
+  if (!realMic) {
+    return {
+      name: "real microphone artifact",
+      required: true,
+      status: "missing",
+      message: "Real microphone artifact is missing.",
+      source: "real mic",
+    };
+  }
+  return {
+    name: "real microphone artifact",
+    required: true,
+    status: realMic.passed === true ? "pass" : "fail",
+    message: realMic.passed === true ? "Real microphone artifact passed." : "Real microphone artifact did not pass.",
+    source: "real mic",
+    evidence: {
+      generatedAt: realMic.generatedAt ?? null,
+      summary: realMic.summary ?? null,
+      config: realMic.config ?? null,
+    },
+  };
+}
+
+function webgpuArtifactCheck(webgpu) {
+  if (!webgpu) {
+    return {
+      name: "hardware WebGPU artifact",
+      required: true,
+      status: "missing",
+      message: "WebGPU benchmark artifact is missing.",
+      source: "webgpu",
+    };
+  }
+  const completeCandidates = Array.isArray(webgpu.candidates)
+    ? webgpu.candidates.filter((candidate) => candidate.status === "complete")
+    : [];
+  const passed = webgpu.skipped !== true && webgpu.webgpu?.available === true && webgpu.webgpu?.softwareAdapter !== true && completeCandidates.length > 0;
+  return {
+    name: "hardware WebGPU artifact",
+    required: true,
+    status: passed ? "pass" : "missing",
+    message: passed
+      ? `${completeCandidates.length} hardware WebGPU candidate(s) completed.`
+      : webgpu.reason ?? "No hardware WebGPU candidate completed.",
+    source: "webgpu",
+    evidence: {
+      generatedAt: webgpu.generatedAt ?? null,
+      webgpu: webgpu.webgpu ?? null,
+      candidates: webgpu.candidates ?? [],
+    },
+  };
+}
+
+function freshnessCheck(artifacts) {
+  const stale = Object.entries(artifacts)
+    .filter(([, artifact]) => artifact.exists && artifact.stale)
+    .map(([key, artifact]) => ({ key, path: artifact.path, artifactHash: artifact.sourceHash }));
+  return {
+    name: "artifact source freshness",
+    required: true,
+    status: stale.length === 0 ? "pass" : "stale",
+    message:
+      stale.length === 0
+        ? "Readable artifacts with source fingerprints match current files."
+        : `${stale.length} artifact(s) were generated from an older source fingerprint.`,
+    source: "summary",
+    evidence: { stale },
+  };
+}
+
+async function readArtifact(path, currentSourceFingerprint) {
+  if (!existsSync(path)) {
+    return { exists: false, path, ok: false, error: "missing" };
+  }
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    const sourceHash = value.sourceFingerprint?.hash ?? null;
+    return {
+      exists: true,
+      ok: true,
+      path,
+      value,
+      generatedAt: value.generatedAt ?? null,
+      sourceHash,
+      stale: Boolean(sourceHash && sourceHash !== currentSourceFingerprint.hash),
+    };
+  } catch (error) {
+    return { exists: true, ok: false, path, error: error.message };
+  }
+}
+
+function summarizeArtifact(artifact) {
+  return {
+    exists: artifact.exists,
+    ok: artifact.ok,
+    path: artifact.path,
+    generatedAt: artifact.generatedAt ?? null,
+    sourceHash: artifact.sourceHash ?? null,
+    stale: artifact.stale ?? false,
+    error: artifact.error ?? null,
+  };
+}
+
+function dedupeChecks(checks) {
+  const merged = new Map();
+  for (const check of checks) {
+    if (!check?.name) continue;
+    const previous = merged.get(check.name);
+    if (!previous || statusRank(check.status) < statusRank(previous.status)) {
+      merged.set(check.name, check);
+    }
+  }
+  return [...merged.values()];
+}
+
+function statusRank(status) {
+  return {
+    fail: 0,
+    stale: 1,
+    missing: 2,
+    unknown: 3,
+    warn: 4,
+    pass: 5,
+    skip: 6,
+  }[status] ?? 3;
+}
+
+function nextActions(checks) {
+  const actions = [];
+  const needsRealMic = checks.some((check) => check.status !== "pass" && check.name.includes("real microphone"));
+  const needsHardwareWebgpu = checks.some((check) => check.status !== "pass" && check.name.includes("WebGPU"));
+  const needsBrowserEvidence = checks.some(
+    (check) => check.status !== "pass" && check.name === "downloaded browser evidence audit",
+  );
+  if (needsRealMic || needsHardwareWebgpu || needsBrowserEvidence) {
+    actions.push(
+      "Run node tools/run-hosted-evidence-capture.mjs from a desktop Chrome session with a real microphone; use a machine exposing hardware WebGPU to satisfy both hosted browser evidence gates.",
+    );
+  }
+  for (const check of checks) {
+    if (check.status === "pass") continue;
+    if (check.name.includes("real microphone")) {
+      actions.push("Run node tools/run-real-mic-series.mjs on a machine with a real microphone.");
+    } else if (check.name.includes("WebGPU")) {
+      actions.push("Run node tools/run-webgpu-benchmark.mjs in Chrome on a machine exposing a hardware WebGPU adapter.");
+    } else if (check.name === "downloaded browser evidence audit") {
+      actions.push("Download JSON from the hosted Space after real-mic/WebGPU runs, then run node tools/audit-browser-evidence.mjs <file>.");
+    } else if (check.name === "hosted Space no-server smoke") {
+      actions.push("Run node tools/run-hosted-smoke.mjs.");
+    } else if (check.name === "artifact source freshness") {
+      actions.push("Rerun the stale harnesses so their source fingerprints match current files.");
+    } else {
+      actions.push(`Resolve evidence check: ${check.name}.`);
+    }
+  }
+  return [...new Set(actions)];
+}
+
+main().catch((error) => {
+  console.error(error.stack ?? error.message);
+  process.exitCode = 1;
+});

workers/asr-worker.js

@@ -2,6 +2,7 @@ import { AutoModel, Tensor, env, pipeline } from "https://cdn.jsdelivr.net/npm/@
 
 env.allowLocalModels = false;
 env.useBrowserCache = true;
+installFetchTelemetry("asr");
 
 const SAMPLE_RATE = 16000;
 const SPEECH_THRESHOLD = 0.3;
@@ -35,6 +36,49 @@ let lastPartialAt = 0;
 let utteranceStartedAt = 0;
 const recordingBuffer = new Float32Array(MAX_BUFFER_DURATION * SAMPLE_RATE);
 
+function installFetchTelemetry(scope) {
+  const originalFetch = globalThis.fetch?.bind(globalThis);
+  if (!originalFetch || globalThis.__browserSpeakFetchTelemetryInstalled) return;
+  globalThis.__browserSpeakFetchTelemetryInstalled = true;
+  globalThis.fetch = async (input, init) => {
+    const startedAt = performance.now();
+    const url = fetchUrl(input);
+    const method = String(init?.method || input?.method || "GET").toUpperCase();
+    try {
+      const response = await originalFetch(input, init);
+      self.postMessage({
+        type: "network",
+        scope,
+        method,
+        url,
+        responseUrl: response.url || url,
+        status: response.status,
+        ok: response.ok,
+        durationMs: performance.now() - startedAt,
+      });
+      return response;
+    } catch (error) {
+      self.postMessage({
+        type: "network",
+        scope,
+        method,
+        url,
+        status: null,
+        ok: false,
+        durationMs: performance.now() - startedAt,
+        error: error.message ?? String(error),
+      });
+      throw error;
+    }
+  };
+}
+
+function fetchUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input?.url ?? "";
+}
+
 self.onmessage = async (event) => {
   const message = event.data;
   try {

workers/llm-worker.js

@@ -8,6 +8,7 @@ import {
 
 env.allowLocalModels = false;
 env.useBrowserCache = true;
+installFetchTelemetry("llm");
 
 let tokenizer = null;
 let model = null;
@@ -15,6 +16,49 @@ let modelId = "";
 let stoppingCriteria = new InterruptableStoppingCriteria();
 let currentTurnId = 0;
 
+function installFetchTelemetry(scope) {
+  const originalFetch = globalThis.fetch?.bind(globalThis);
+  if (!originalFetch || globalThis.__browserSpeakFetchTelemetryInstalled) return;
+  globalThis.__browserSpeakFetchTelemetryInstalled = true;
+  globalThis.fetch = async (input, init) => {
+    const startedAt = performance.now();
+    const url = fetchUrl(input);
+    const method = String(init?.method || input?.method || "GET").toUpperCase();
+    try {
+      const response = await originalFetch(input, init);
+      self.postMessage({
+        type: "network",
+        scope,
+        method,
+        url,
+        responseUrl: response.url || url,
+        status: response.status,
+        ok: response.ok,
+        durationMs: performance.now() - startedAt,
+      });
+      return response;
+    } catch (error) {
+      self.postMessage({
+        type: "network",
+        scope,
+        method,
+        url,
+        status: null,
+        ok: false,
+        durationMs: performance.now() - startedAt,
+        error: error.message ?? String(error),
+      });
+      throw error;
+    }
+  };
+}
+
+function fetchUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input?.url ?? "";
+}
+
 self.onmessage = async (event) => {
   const message = event.data;
   try {

workers/tts-worker.js

@@ -2,6 +2,7 @@ import { env, pipeline } from "https://cdn.jsdelivr.net/npm/@huggingface/transfo
 
 env.allowLocalModels = false;
 env.useBrowserCache = true;
+installFetchTelemetry("tts");
 
 let synthesizer = null;
 let modelId = "";
@@ -11,6 +12,49 @@ const voiceEmbeddings = new Map();
 const voicePromises = new Map();
 const VOICES = ["F1", "F2", "M1", "M2"];
 
+function installFetchTelemetry(scope) {
+  const originalFetch = globalThis.fetch?.bind(globalThis);
+  if (!originalFetch || globalThis.__browserSpeakFetchTelemetryInstalled) return;
+  globalThis.__browserSpeakFetchTelemetryInstalled = true;
+  globalThis.fetch = async (input, init) => {
+    const startedAt = performance.now();
+    const url = fetchUrl(input);
+    const method = String(init?.method || input?.method || "GET").toUpperCase();
+    try {
+      const response = await originalFetch(input, init);
+      self.postMessage({
+        type: "network",
+        scope,
+        method,
+        url,
+        responseUrl: response.url || url,
+        status: response.status,
+        ok: response.ok,
+        durationMs: performance.now() - startedAt,
+      });
+      return response;
+    } catch (error) {
+      self.postMessage({
+        type: "network",
+        scope,
+        method,
+        url,
+        status: null,
+        ok: false,
+        durationMs: performance.now() - startedAt,
+        error: error.message ?? String(error),
+      });
+      throw error;
+    }
+  };
+}
+
+function fetchUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input?.url ?? "";
+}
+
 self.onmessage = (event) => {
   const message = event.data;
   if (message.type === "load") {