From 9bf1faa41f7ff7c627f55ac0d8717173803956b2 Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Tue, 25 Aug 2026 20:43:47 -0500
Subject: [PATCH 1/7] feat(web): add mobile browser voice turns

---
 web/src/components/ChatSidebar.tsx           |   8 +-
 web/src/components/ChatVoiceControl.test.tsx | 176 ++++++++++++
 web/src/components/ChatVoiceControl.tsx      | 266 +++++++++++++++++++
 web/src/lib/assistant-voice-output.test.ts   |  32 +++
 web/src/lib/assistant-voice-output.ts        |  41 +++
 web/src/lib/native-voice-bridge.test.ts      |  41 +++
 web/src/lib/native-voice-bridge.ts           |  79 ++++++
 web/src/lib/pty-voice-submit.test.ts         |  35 +++
 web/src/lib/pty-voice-submit.ts              |  30 +++
 web/src/pages/ChatPage.tsx                   |  38 +++
 10 files changed, 745 insertions(+), 1 deletion(-)
 create mode 100644 web/src/components/ChatVoiceControl.test.tsx
 create mode 100644 web/src/components/ChatVoiceControl.tsx
 create mode 100644 web/src/lib/assistant-voice-output.test.ts
 create mode 100644 web/src/lib/assistant-voice-output.ts
 create mode 100644 web/src/lib/native-voice-bridge.test.ts
 create mode 100644 web/src/lib/native-voice-bridge.ts
 create mode 100644 web/src/lib/pty-voice-submit.test.ts
 create mode 100644 web/src/lib/pty-voice-submit.ts

diff --git a/web/src/components/ChatSidebar.tsx b/web/src/components/ChatSidebar.tsx
index e7669921129c2..a79511e2c8c04 100644
--- a/web/src/components/ChatSidebar.tsx
+++ b/web/src/components/ChatSidebar.tsx
@@ -34,6 +34,7 @@ import { ModelReloadConfirm } from "@/components/ModelReloadConfirm";
 import { ReasoningPicker } from "@/components/ReasoningPicker";
 import { GatewayClient, type ConnectionState } from "@/lib/gatewayClient";
 import { api, buildWsUrl } from "@/lib/api";
+import { assistantFinalText } from "@/lib/assistant-voice-output";
 import { maybeReloadForLoopbackWsAuthFailure } from "@/lib/dashboard-auth-reload";
 import {
   EVENTS_CONNECT_TIMEOUT_MS,
@@ -92,6 +93,7 @@ interface ChatSidebarProps {
   className?: string;
   onDashboardNewSessionRequest?: () => void;
   onSessionTitleChange?: (title: string | null) => void;
+  onAssistantFinal?: (text: string) => void;
 }
 
 /** Build the ``session.create`` params for the sidecar session.
@@ -115,6 +117,7 @@ export function ChatSidebar({
   className,
   onDashboardNewSessionRequest,
   onSessionTitleChange,
+  onAssistantFinal,
 }: ChatSidebarProps) {
   // `version` bumps on reconnect; gw is derived so we never call setState
   // for it inside an effect (React 19's set-state-in-effect rule). The
@@ -413,6 +416,9 @@ export function ChatSidebar({
           }
         } else if (type === "dashboard.new_session_requested") {
           onDashboardNewSessionRequest?.();
+        } else if (type === "message.complete") {
+          const text = assistantFinalText(type, payload);
+          if (text) onAssistantFinal?.(text);
         }
       });
     };
@@ -429,7 +435,7 @@ export function ChatSidebar({
       }
       ws?.close();
     };
-  }, [channel, onDashboardNewSessionRequest, onSessionTitleChange, version]);
+  }, [channel, onAssistantFinal, onDashboardNewSessionRequest, onSessionTitleChange, version]);
 
   // Seed the badge on mount and re-read it whenever the sockets are rebuilt
   // (a profile/channel switch bumps `version`).
diff --git a/web/src/components/ChatVoiceControl.test.tsx b/web/src/components/ChatVoiceControl.test.tsx
new file mode 100644
index 0000000000000..c26a2b5a80620
--- /dev/null
+++ b/web/src/components/ChatVoiceControl.test.tsx
@@ -0,0 +1,176 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ChatVoiceControl } from "./ChatVoiceControl";
+
+(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+interface FakeResult { 0: { transcript: string }; isFinal: boolean }
+
+class FakeRecognition {
+  static instances: FakeRecognition[] = [];
+  continuous = false;
+  interimResults = false;
+  lang = "";
+  onresult: ((event: { resultIndex: number; results: FakeResult[] }) => void) | null = null;
+  onend: (() => void) | null = null;
+  onerror: ((event: { error: string }) => void) | null = null;
+  start = vi.fn();
+  stop = vi.fn();
+  abort = vi.fn();
+  constructor() { FakeRecognition.instances.push(this); }
+  result(resultIndex: number, ...rows: Array<[string, boolean]>) {
+    this.onresult?.({ resultIndex, results: rows.map(([transcript, isFinal]) => ({ 0: { transcript }, isFinal })) });
+  }
+}
+
+describe("ChatVoiceControl browser speech input", () => {
+  let host: HTMLDivElement;
+  let root: ReturnType<typeof createRoot>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    FakeRecognition.instances = [];
+    vi.stubGlobal("SpeechRecognition", FakeRecognition);
+    host = document.createElement("div");
+    document.body.append(host);
+    root = createRoot(host);
+  });
+
+  afterEach(async () => {
+    await act(async () => root.unmount());
+    delete (window as Window & { hermesVoiceBridge?: unknown }).hermesVoiceBridge;
+    host.remove();
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  async function render(submit = vi.fn(), connected = true) {
+    await act(async () => root.render(<ChatVoiceControl connected={connected} submit={submit} />));
+    return { submit, surface: host.querySelector('[aria-label="Browser voice input"]') as HTMLButtonElement };
+  }
+
+  it("accumulates final results while replacing interim text without submitting", async () => {
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    const recognition = FakeRecognition.instances[0];
+    expect(recognition.continuous).toBe(true);
+    expect(recognition.interimResults).toBe(true);
+    await act(async () => recognition.result(0, ["Call the ", true], ["cr", false]));
+    await act(async () => recognition.result(1, ["ignored", true], ["crew", false]));
+    expect(host.textContent).toContain("Call the crew");
+    expect(host.textContent).not.toContain("ignored");
+    expect(submit).not.toHaveBeenCalled();
+  });
+
+  it("restarts Android premature onend with bounded exponential backoff and no submit", async () => {
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => FakeRecognition.instances[0].result(0, ["Keep going", true]));
+    await act(async () => FakeRecognition.instances[0].onend?.());
+    await act(async () => vi.advanceTimersByTime(249));
+    expect(FakeRecognition.instances).toHaveLength(1);
+    await act(async () => vi.advanceTimersByTime(1));
+    expect(FakeRecognition.instances).toHaveLength(2);
+    await act(async () => FakeRecognition.instances[1].onend?.());
+    await act(async () => vi.advanceTimersByTime(499));
+    expect(FakeRecognition.instances).toHaveLength(2);
+    await act(async () => vi.advanceTimersByTime(1));
+    expect(FakeRecognition.instances).toHaveLength(3);
+    expect(host.textContent).toContain("Keep going");
+    expect(submit).not.toHaveBeenCalled();
+  });
+
+  it("stops retrying after the bounded restart budget", async () => {
+    const { surface } = await render();
+    await act(async () => surface.click());
+    for (let index = 0; index < 6; index += 1) {
+      await act(async () => FakeRecognition.instances.at(-1)?.onend?.());
+      await act(async () => vi.runOnlyPendingTimers());
+    }
+    await act(async () => FakeRecognition.instances.at(-1)?.onend?.());
+    await act(async () => vi.runAllTimers());
+    expect(FakeRecognition.instances).toHaveLength(7);
+    expect(host.textContent).toContain("kept stopping");
+  });
+
+  it("does not restart after a fatal permission error", async () => {
+    const { surface } = await render();
+    await act(async () => surface.click());
+    const recognition = FakeRecognition.instances[0];
+    await act(async () => recognition.onerror?.({ error: "not-allowed" }));
+    await act(async () => recognition.onend?.());
+    await act(async () => vi.runAllTimers());
+    expect(FakeRecognition.instances).toHaveLength(1);
+    expect(host.textContent).toContain("permission was denied");
+  });
+
+  it("submits one normalized transcript and aborts recognition", async () => {
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => FakeRecognition.instances[0].result(0, ["Call   the ", true], [" crew", false]));
+    await act(async () => surface.click());
+    await act(async () => surface.click());
+    expect(submit).toHaveBeenCalledTimes(1);
+    expect(submit).toHaveBeenCalledWith("Call the crew");
+    expect(FakeRecognition.instances[0].abort).toHaveBeenCalledOnce();
+  });
+
+  it("does not submit empty audio and remains listening", async () => {
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => surface.click());
+    expect(submit).not.toHaveBeenCalled();
+    expect(host.textContent).toContain("No speech heard");
+    expect(host.textContent).toContain("TAP ANYWHERE TO SEND");
+  });
+
+  it("cancel aborts capture, clears text, and prevents restart", async () => {
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    const recognition = FakeRecognition.instances[0];
+    await act(async () => recognition.result(0, ["do not send", true]));
+    const cancel = host.querySelector('[aria-label="Cancel browser voice input"]') as HTMLButtonElement;
+    await act(async () => cancel.click());
+    await act(async () => recognition.onend?.());
+    await act(async () => vi.runAllTimers());
+    expect(recognition.abort).toHaveBeenCalledOnce();
+    expect(submit).not.toHaveBeenCalled();
+    expect(host.textContent).not.toContain("do not send");
+  });
+
+  it("keeps the terminal text-entry fallback available", async () => {
+    const { surface } = await render();
+    expect(surface.textContent).toContain("Gboard typed fallback remains below");
+  });
+
+  it("refuses to start while chat is disconnected", async () => {
+    const { surface } = await render(vi.fn(), false);
+    await act(async () => surface.click());
+    expect(FakeRecognition.instances).toHaveLength(0);
+    expect(host.textContent).toContain("not connected");
+  });
+
+  it("uses the optional native bridge and accepts partial and final events", async () => {
+    let listener: ((event: MessageEvent) => void) | undefined;
+    const bridge = {
+      postMessage: vi.fn(),
+      addEventListener: vi.fn((_name: string, cb: (event: MessageEvent) => void) => { listener = cb; }),
+      removeEventListener: vi.fn(),
+    };
+    Object.defineProperty(window, "hermesVoiceBridge", { configurable: true, value: bridge });
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    expect(FakeRecognition.instances).toHaveLength(0);
+    expect(bridge.postMessage).toHaveBeenCalledWith(JSON.stringify({ version: 1, command: "start" }));
+    await act(async () => listener?.({ data: JSON.stringify({ version: 1, event: "partial", transcript: "Call" }) } as MessageEvent));
+    await act(async () => listener?.({ data: JSON.stringify({ version: 1, event: "final", transcript: "Call the crew" }) } as MessageEvent));
+    expect(host.textContent).toContain("Call the crew");
+    await act(async () => surface.click());
+    expect(submit).toHaveBeenCalledOnce();
+    expect(submit).toHaveBeenCalledWith("Call the crew");
+    expect(bridge.postMessage).toHaveBeenCalledWith(JSON.stringify({ version: 1, command: "stop" }));
+  });
+});
diff --git a/web/src/components/ChatVoiceControl.tsx b/web/src/components/ChatVoiceControl.tsx
new file mode 100644
index 0000000000000..5be2941579cdd
--- /dev/null
+++ b/web/src/components/ChatVoiceControl.tsx
@@ -0,0 +1,266 @@
+import { Mic, X } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import { Button } from "@nous-research/ui/ui/components/button";
+import {
+  connectNativeVoiceBridge,
+  type NativeVoiceBridgeConnection,
+  type NativeVoiceMessageTarget,
+} from "@/lib/native-voice-bridge";
+
+const RESTART_DELAY_MS = 250;
+const MAX_RESTARTS = 6;
+
+type VoiceState = "idle" | "listening" | "sent" | "error";
+
+interface SpeechRecognitionResultLike {
+  readonly isFinal: boolean;
+  readonly 0: { readonly transcript: string };
+}
+
+interface SpeechRecognitionEventLike {
+  readonly resultIndex: number;
+  readonly results: ArrayLike<SpeechRecognitionResultLike>;
+}
+
+interface SpeechRecognitionLike {
+  continuous: boolean;
+  interimResults: boolean;
+  lang: string;
+  onresult: ((event: SpeechRecognitionEventLike) => void) | null;
+  onend: (() => void) | null;
+  onerror: ((event: { error: string }) => void) | null;
+  start(): void;
+  abort(): void;
+}
+
+type SpeechRecognitionConstructor = new () => SpeechRecognitionLike;
+
+declare global {
+  interface Window {
+    SpeechRecognition?: SpeechRecognitionConstructor;
+    webkitSpeechRecognition?: SpeechRecognitionConstructor;
+    hermesVoiceBridge?: NativeVoiceMessageTarget;
+  }
+}
+
+interface ChatVoiceControlProps {
+  connected: boolean;
+  submit: (transcript: string) => void;
+  onBargeIn?: () => void;
+}
+
+function recognitionConstructor(): SpeechRecognitionConstructor | undefined {
+  return window.SpeechRecognition ?? window.webkitSpeechRecognition;
+}
+
+export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceControlProps) {
+  const [state, setState] = useState<VoiceState>("idle");
+  const [finalTranscript, setFinalTranscript] = useState("");
+  const [interimTranscript, setInterimTranscript] = useState("");
+  const [error, setError] = useState("");
+  const recognitionRef = useRef<SpeechRecognitionLike | null>(null);
+  const listeningRef = useRef(false);
+  const fatalRef = useRef(false);
+  const restartCountRef = useRef(0);
+  const restartTimerRef = useRef<number | null>(null);
+  const generationRef = useRef(0);
+  const nativeBridgeRef = useRef<NativeVoiceBridgeConnection | null>(null);
+  const finalRef = useRef("");
+  const interimRef = useRef("");
+
+  const clearRestart = useCallback(() => {
+    if (restartTimerRef.current !== null) window.clearTimeout(restartTimerRef.current);
+    restartTimerRef.current = null;
+  }, []);
+
+  const updateFinal = (value: string) => {
+    finalRef.current = value;
+    setFinalTranscript(value);
+  };
+
+  const updateInterim = (value: string) => {
+    interimRef.current = value;
+    setInterimTranscript(value);
+  };
+
+  function startRecognition(generation: number) {
+    if (!listeningRef.current || generation !== generationRef.current) return;
+    const Constructor = recognitionConstructor();
+    if (!Constructor) {
+      listeningRef.current = false;
+      setError("Chrome speech recognition is unavailable. Use Gboard typed input below.");
+      setState("error");
+      return;
+    }
+
+    const recognition = new Constructor();
+    recognition.continuous = true;
+    recognition.interimResults = true;
+    recognition.lang = "en-US";
+    recognition.onresult = (event) => {
+      if (generation !== generationRef.current || !listeningRef.current) return;
+      let appendedFinal = "";
+      let nextInterim = "";
+      for (let index = event.resultIndex; index < event.results.length; index += 1) {
+        const result = event.results[index];
+        const text = result?.[0]?.transcript ?? "";
+        if (result?.isFinal) appendedFinal += text;
+        else nextInterim += text;
+      }
+      if (appendedFinal) updateFinal(`${finalRef.current}${appendedFinal}`);
+      updateInterim(nextInterim);
+      setError("");
+    };
+    recognition.onerror = (event) => {
+      if (generation !== generationRef.current) return;
+      const fatal = event.error === "not-allowed" || event.error === "service-not-allowed";
+      if (fatal) {
+        fatalRef.current = true;
+        listeningRef.current = false;
+        setError(event.error === "not-allowed"
+          ? "Microphone permission was denied. Allow mic access in Chrome, then tap again."
+          : "Chrome speech recognition is not allowed on this device.");
+        setState("error");
+      } else {
+        setError(`Speech recognition error: ${event.error}. Retrying…`);
+      }
+    };
+    recognition.onend = () => {
+      if (generation !== generationRef.current || !listeningRef.current || fatalRef.current) return;
+      if (restartCountRef.current >= MAX_RESTARTS) {
+        listeningRef.current = false;
+        setError("Speech recognition kept stopping. Tap to resume or use Gboard typed input below.");
+        setState("error");
+        return;
+      }
+      const delay = RESTART_DELAY_MS * 2 ** Math.min(restartCountRef.current, 3);
+      restartCountRef.current += 1;
+      restartTimerRef.current = window.setTimeout(() => startRecognition(generation), delay);
+    };
+    recognitionRef.current = recognition;
+    try {
+      recognition.start();
+    } catch {
+      if (generation !== generationRef.current) return;
+      listeningRef.current = false;
+      setError("Could not start Chrome speech recognition. Tap to try again.");
+      setState("error");
+    }
+  }
+
+  const begin = () => {
+    if (!connected) {
+      setError("Chat is not connected yet.");
+      setState("error");
+      return;
+    }
+    onBargeIn?.();
+    clearRestart();
+    fatalRef.current = false;
+    restartCountRef.current = 0;
+    listeningRef.current = true;
+    const generation = generationRef.current + 1;
+    generationRef.current = generation;
+    setError("");
+    setState("listening");
+    if (nativeBridgeRef.current) nativeBridgeRef.current.command("start");
+    else startRecognition(generation);
+  };
+
+  const commit = () => {
+    const transcript = `${finalRef.current} ${interimRef.current}`.replace(/\s+/g, " ").trim();
+    if (!transcript) {
+      setError("No speech heard yet — keep talking, then tap anywhere to send.");
+      return;
+    }
+    listeningRef.current = false;
+    generationRef.current += 1;
+    clearRestart();
+    recognitionRef.current?.abort();
+    recognitionRef.current = null;
+    nativeBridgeRef.current?.command("stop");
+    submit(transcript);
+    updateFinal("");
+    updateInterim("");
+    setError("");
+    setState("sent");
+  };
+
+  const cancel = useCallback(() => {
+    listeningRef.current = false;
+    generationRef.current += 1;
+    clearRestart();
+    recognitionRef.current?.abort();
+    recognitionRef.current = null;
+    nativeBridgeRef.current?.command("cancel");
+    updateFinal("");
+    updateInterim("");
+    setError("");
+    setState("idle");
+  }, [clearRestart]);
+
+  useEffect(() => {
+    const connection = connectNativeVoiceBridge(window.hermesVoiceBridge, (event) => {
+      if (event.event === "partial") {
+        updateInterim(event.transcript ?? "");
+      } else if (event.event === "final") {
+        updateFinal(event.transcript ?? "");
+        updateInterim("");
+      } else if (event.event === "error") {
+        setError(event.message ?? "Native speech recognition failed.");
+        if (event.fatal) {
+          listeningRef.current = false;
+          setState("error");
+        }
+      } else if (event.event === "listening") {
+        setState("listening");
+      }
+    });
+    nativeBridgeRef.current = connection;
+    connection?.command("check");
+    return () => {
+      connection?.command("cancel");
+      connection?.disconnect();
+      if (nativeBridgeRef.current === connection) nativeBridgeRef.current = null;
+    };
+  }, []);
+
+  useEffect(() => cancel, [cancel]);
+
+  const transcript = `${finalTranscript}${interimTranscript}`.trim();
+  const headline = state === "listening"
+    ? (transcript || "LISTENING…")
+    : state === "sent"
+      ? "SENT"
+      : "TAP TO TALK";
+
+  return (
+    <div className="relative flex max-h-[52dvh] min-h-[42dvh] shrink-0 flex-col overflow-hidden border border-current/25 bg-black/30 pb-[env(safe-area-inset-bottom)] text-white lg:min-h-44">
+      <button
+        type="button"
+        aria-label="Browser voice input"
+        onClick={state === "listening" ? commit : begin}
+        className="flex min-h-[42dvh] w-full touch-manipulation flex-1 flex-col items-center justify-center gap-5 overflow-hidden px-5 py-8 text-center active:bg-white/10 lg:min-h-44"
+      >
+        <Mic className={state === "listening" ? "h-12 w-12 shrink-0 animate-pulse text-red-400" : "h-12 w-12 shrink-0"} />
+        <span className="max-h-[28dvh] w-full overflow-y-auto whitespace-pre-wrap break-words text-2xl font-semibold leading-tight sm:text-3xl">
+          {headline}
+        </span>
+        <span className="text-sm tracking-wide text-white/70">
+          {state === "listening" ? "TAP ANYWHERE TO SEND" : "Chrome live speech • Gboard typed fallback remains below"}
+        </span>
+      </button>
+      <Button
+        ghost
+        aria-label="Cancel browser voice input"
+        onClick={cancel}
+        className="absolute right-2 top-2 min-h-11 min-w-11 touch-manipulation px-2"
+        prefix={<X className="h-5 w-5" />}
+      >
+        Cancel
+      </Button>
+      {error && <div role="alert" className="px-4 pb-3 text-center text-sm text-red-300">{error}</div>}
+    </div>
+  );
+}
diff --git a/web/src/lib/assistant-voice-output.test.ts b/web/src/lib/assistant-voice-output.test.ts
new file mode 100644
index 0000000000000..d984c9bbda25a
--- /dev/null
+++ b/web/src/lib/assistant-voice-output.test.ts
@@ -0,0 +1,32 @@
+// @vitest-environment jsdom
+import { describe, expect, it, vi } from "vitest";
+
+import { assistantFinalText, speakAssistantFinal } from "./assistant-voice-output";
+
+describe("assistant voice output", () => {
+  it("accepts only successful structured message.complete payloads", () => {
+    expect(assistantFinalText("message.complete", { status: "complete", text: "Done" })).toBe("Done");
+    expect(assistantFinalText("message.complete", { status: "error", text: "secret failure" })).toBeNull();
+    expect(assistantFinalText("message.delta", { text: "partial" })).toBeNull();
+    expect(assistantFinalText("message.complete", { status: "complete", text: "  " })).toBeNull();
+  });
+
+  it("speaks through browser synthesis and settles once on end or cancellation", () => {
+    class FakeUtterance {
+      onend: (() => void) | null = null;
+      onerror: (() => void) | null = null;
+      readonly text: string;
+      constructor(text: string) { this.text = text; }
+    }
+    vi.stubGlobal("SpeechSynthesisUtterance", FakeUtterance);
+    const synth = { speak: vi.fn(), cancel: vi.fn() };
+    const settled = vi.fn();
+    const playback = speakAssistantFinal(synth, "Done", settled);
+    const utterance = synth.speak.mock.calls[0][0] as SpeechSynthesisUtterance;
+    expect(utterance.text).toBe("Done");
+    utterance.onend?.({} as SpeechSynthesisEvent);
+    playback.cancel();
+    expect(settled).toHaveBeenCalledOnce();
+    expect(synth.cancel).toHaveBeenCalledOnce();
+  });
+});
diff --git a/web/src/lib/assistant-voice-output.ts b/web/src/lib/assistant-voice-output.ts
new file mode 100644
index 0000000000000..cb23fe69f1c7f
--- /dev/null
+++ b/web/src/lib/assistant-voice-output.ts
@@ -0,0 +1,41 @@
+interface AssistantCompletePayload {
+  status?: unknown;
+  text?: unknown;
+}
+
+export function assistantFinalText(type: string, payload: unknown): string | null {
+  if (type !== "message.complete" || !payload || typeof payload !== "object") return null;
+  const complete = payload as AssistantCompletePayload;
+  if (complete.status !== undefined && complete.status !== "complete") return null;
+  if (typeof complete.text !== "string") return null;
+  const text = complete.text.trim();
+  return text || null;
+}
+
+interface SpeechSynthesisLike {
+  speak(utterance: SpeechSynthesisUtterance): void;
+  cancel(): void;
+}
+
+export function speakAssistantFinal(
+  synthesis: SpeechSynthesisLike,
+  text: string,
+  onSettled: () => void,
+): { cancel(): void } {
+  const utterance = new SpeechSynthesisUtterance(text);
+  let settled = false;
+  const settle = () => {
+    if (settled) return;
+    settled = true;
+    onSettled();
+  };
+  utterance.onend = settle;
+  utterance.onerror = settle;
+  synthesis.speak(utterance);
+  return {
+    cancel() {
+      synthesis.cancel();
+      settle();
+    },
+  };
+}
diff --git a/web/src/lib/native-voice-bridge.test.ts b/web/src/lib/native-voice-bridge.test.ts
new file mode 100644
index 0000000000000..dde405e3eef8f
--- /dev/null
+++ b/web/src/lib/native-voice-bridge.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { connectNativeVoiceBridge } from "./native-voice-bridge";
+
+describe("origin-scoped native voice bridge", () => {
+  it("sends only the declared command envelope and accepts declared transcript events", () => {
+    let listener: ((event: MessageEvent) => void) | undefined;
+    const target = {
+      postMessage: vi.fn(),
+      addEventListener: vi.fn((_name: string, cb: (event: MessageEvent) => void) => { listener = cb; }),
+      removeEventListener: vi.fn(),
+    };
+    const events = vi.fn();
+    const bridge = connectNativeVoiceBridge(target, events);
+    expect(bridge).not.toBeNull();
+    bridge?.command("check");
+    bridge?.command("start");
+    expect(target.postMessage).toHaveBeenNthCalledWith(1, JSON.stringify({ version: 1, command: "check" }));
+    expect(target.postMessage).toHaveBeenNthCalledWith(2, JSON.stringify({ version: 1, command: "start" }));
+
+    listener?.({ data: JSON.stringify({ version: 1, event: "partial", transcript: "hello" }) } as MessageEvent);
+    listener?.({ data: JSON.stringify({ version: 1, event: "unknown", transcript: "ignored" }) } as MessageEvent);
+    expect(events).toHaveBeenCalledOnce();
+    expect(events).toHaveBeenCalledWith({ version: 1, event: "partial", transcript: "hello" });
+  });
+
+  it("fails closed for missing or malformed bridge objects and events", () => {
+    expect(connectNativeVoiceBridge(undefined, vi.fn())).toBeNull();
+    const events = vi.fn();
+    let listener: ((event: MessageEvent) => void) | undefined;
+    const target = {
+      postMessage: vi.fn(),
+      addEventListener: vi.fn((_name: string, cb: (event: MessageEvent) => void) => { listener = cb; }),
+      removeEventListener: vi.fn(),
+    };
+    connectNativeVoiceBridge(target, events);
+    listener?.({ data: "not json" } as MessageEvent);
+    listener?.({ data: JSON.stringify({ version: 2, event: "final", transcript: "no" }) } as MessageEvent);
+    expect(events).not.toHaveBeenCalled();
+  });
+});
diff --git a/web/src/lib/native-voice-bridge.ts b/web/src/lib/native-voice-bridge.ts
new file mode 100644
index 0000000000000..2e86efebe09a9
--- /dev/null
+++ b/web/src/lib/native-voice-bridge.ts
@@ -0,0 +1,79 @@
+export type NativeVoiceCommand = "check" | "start" | "stop" | "cancel";
+export type NativeVoiceEventName =
+  | "availability"
+  | "ready"
+  | "listening"
+  | "partial"
+  | "final"
+  | "error"
+  | "ended";
+
+export interface NativeVoiceEvent {
+  version: 1;
+  event: NativeVoiceEventName;
+  transcript?: string;
+  available?: boolean;
+  message?: string;
+  fatal?: boolean;
+}
+
+export interface NativeVoiceMessageTarget {
+  postMessage(message: string): void;
+  addEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+  removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+}
+
+const EVENT_NAMES = new Set<NativeVoiceEventName>([
+  "availability", "ready", "listening", "partial", "final", "error", "ended",
+]);
+
+function parseNativeVoiceEvent(data: unknown): NativeVoiceEvent | null {
+  if (typeof data !== "string") return null;
+  try {
+    const value = JSON.parse(data) as Record<string, unknown>;
+    if (value.version !== 1 || typeof value.event !== "string" || !EVENT_NAMES.has(value.event as NativeVoiceEventName)) {
+      return null;
+    }
+    if (value.transcript !== undefined && typeof value.transcript !== "string") return null;
+    if (value.available !== undefined && typeof value.available !== "boolean") return null;
+    if (value.message !== undefined && typeof value.message !== "string") return null;
+    if (value.fatal !== undefined && typeof value.fatal !== "boolean") return null;
+    return value as unknown as NativeVoiceEvent;
+  } catch {
+    return null;
+  }
+}
+
+export interface NativeVoiceBridgeConnection {
+  command(command: NativeVoiceCommand): void;
+  disconnect(): void;
+}
+
+/**
+ * Bind the optional AndroidX WebKit WebMessage listener object.
+ *
+ * The native host owns origin allow-listing when it injects this target. The
+ * web app neither assumes a specific Android recognizer nor receives provider
+ * credentials. Missing/malformed targets fail closed to ordinary Web Speech.
+ */
+export function connectNativeVoiceBridge(
+  target: NativeVoiceMessageTarget | undefined,
+  onEvent: (event: NativeVoiceEvent) => void,
+): NativeVoiceBridgeConnection | null {
+  if (!target || typeof target.postMessage !== "function" || typeof target.addEventListener !== "function" || typeof target.removeEventListener !== "function") {
+    return null;
+  }
+  const listener = (message: MessageEvent) => {
+    const event = parseNativeVoiceEvent(message.data);
+    if (event) onEvent(event);
+  };
+  target.addEventListener("message", listener);
+  return {
+    command(command) {
+      target.postMessage(JSON.stringify({ version: 1, command }));
+    },
+    disconnect() {
+      target.removeEventListener("message", listener);
+    },
+  };
+}
diff --git a/web/src/lib/pty-voice-submit.test.ts b/web/src/lib/pty-voice-submit.test.ts
new file mode 100644
index 0000000000000..e3cceeb4839c0
--- /dev/null
+++ b/web/src/lib/pty-voice-submit.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { submitVoiceTranscriptToPty } from "./pty-voice-submit";
+
+describe("submitVoiceTranscriptToPty", () => {
+  it("sends transcript then exactly one Return in a separate PTY frame", () => {
+    vi.useFakeTimers();
+    const socket = { readyState: WebSocket.OPEN, send: vi.fn() };
+    const current = () => socket;
+
+    expect(submitVoiceTranscriptToPty(current, "Call the crew")).toBe(true);
+    expect(socket.send).toHaveBeenCalledTimes(1);
+    expect(socket.send).toHaveBeenNthCalledWith(1, "Call the crew");
+    vi.advanceTimersByTime(100);
+    expect(socket.send).toHaveBeenCalledTimes(2);
+    expect(socket.send).toHaveBeenNthCalledWith(2, "\r");
+    vi.useRealTimers();
+  });
+
+  it("does not send Return through a replacement or closed socket", () => {
+    vi.useFakeTimers();
+    const first = { readyState: WebSocket.OPEN, send: vi.fn<(data: string) => void>() };
+    const second = { readyState: WebSocket.OPEN, send: vi.fn<(data: string) => void>() };
+    let active: { readyState: number; send(data: string): void } = first;
+    expect(submitVoiceTranscriptToPty(() => active, "Hello")).toBe(true);
+    active = second;
+    vi.advanceTimersByTime(100);
+    expect(first.send).toHaveBeenCalledOnce();
+    expect(second.send).not.toHaveBeenCalled();
+
+    active = { readyState: WebSocket.CLOSED, send: vi.fn<(data: string) => void>() };
+    expect(submitVoiceTranscriptToPty(() => active, "Nope")).toBe(false);
+    vi.useRealTimers();
+  });
+});
diff --git a/web/src/lib/pty-voice-submit.ts b/web/src/lib/pty-voice-submit.ts
new file mode 100644
index 0000000000000..25c13916c8983
--- /dev/null
+++ b/web/src/lib/pty-voice-submit.ts
@@ -0,0 +1,30 @@
+const PTY_TRANSCRIPT_RETURN_DELAY_MS = 100;
+
+interface PtySocket {
+  readonly readyState: number;
+  send(data: string): void;
+}
+
+/**
+ * Submit one finalized browser transcript to Ink's composer.
+ *
+ * Return is deliberately a separate frame: a combined mobile WebSocket frame
+ * can be classified as a paste and remain in the composer. The captured socket
+ * must still be current before Return is sent, so a reconnect cannot submit the
+ * transcript into a replacement PTY session.
+ */
+export function submitVoiceTranscriptToPty(
+  currentSocket: () => PtySocket | null,
+  transcript: string,
+): boolean {
+  const socket = currentSocket();
+  if (!socket || socket.readyState !== WebSocket.OPEN) return false;
+
+  socket.send(transcript);
+  globalThis.setTimeout(() => {
+    if (currentSocket() === socket && socket.readyState === WebSocket.OPEN) {
+      socket.send("\r");
+    }
+  }, PTY_TRANSCRIPT_RETURN_DELAY_MS);
+  return true;
+}
diff --git a/web/src/pages/ChatPage.tsx b/web/src/pages/ChatPage.tsx
index 244fa1680751a..c69875714cdff 100644
--- a/web/src/pages/ChatPage.tsx
+++ b/web/src/pages/ChatPage.tsx
@@ -32,9 +32,11 @@ import { useSearchParams } from "react-router";
 
 import { ChatSidebar } from "@/components/ChatSidebar";
 import { ChatSessionList } from "@/components/ChatSessionList";
+import { ChatVoiceControl } from "@/components/ChatVoiceControl";
 import { usePageHeader } from "@/contexts/usePageHeader";
 import { useI18n } from "@/i18n";
 import { api } from "@/lib/api";
+import { speakAssistantFinal } from "@/lib/assistant-voice-output";
 import { latchChatActivation } from "@/lib/chat-activation";
 import { copyTextToClipboard } from "@/lib/clipboard";
 import { normalizeSessionTitle } from "@/lib/chat-title";
@@ -66,6 +68,7 @@ import {
   resolvePtyKeyboardShortcut,
   sendPtyShortcutSequence,
 } from "@/lib/pty-keyboard-shortcuts";
+import { submitVoiceTranscriptToPty } from "@/lib/pty-voice-submit";
 import {
   isViewportPinnedToBottom,
   parseResumeControlMessage,
@@ -180,6 +183,8 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
   const termRef = useRef<Terminal | null>(null);
   const fitRef = useRef<FitAddon | null>(null);
   const wsRef = useRef<WebSocket | null>(null);
+  const voiceTurnRef = useRef(false);
+  const voicePlaybackRef = useRef<{ cancel(): void } | null>(null);
   const stickToBottomRef = useRef(true);
   // Exposed to the main metrics-sync effect so it can refit the terminal
   // the moment `isActive` flips back to true (display:none → display:flex
@@ -506,6 +511,32 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
     termRef.current?.focus();
   };
 
+  const submitVoiceTranscript = useCallback((transcript: string) => {
+    if (!submitVoiceTranscriptToPty(() => wsRef.current, transcript)) {
+      setBanner("Chat disconnected before the voice transcript could be sent.");
+      return;
+    }
+    voiceTurnRef.current = true;
+    termRef.current?.focus();
+  }, []);
+
+  const cancelVoicePlayback = useCallback(() => {
+    voicePlaybackRef.current?.cancel();
+    voicePlaybackRef.current = null;
+  }, []);
+
+  const speakVoiceResponse = useCallback((text: string) => {
+    if (!voiceTurnRef.current || !("speechSynthesis" in window)) return;
+    voiceTurnRef.current = false;
+    cancelVoicePlayback();
+    const playback = speakAssistantFinal(window.speechSynthesis, text, () => {
+      if (voicePlaybackRef.current === playback) voicePlaybackRef.current = null;
+    });
+    voicePlaybackRef.current = playback;
+  }, [cancelVoicePlayback]);
+
+  useEffect(() => cancelVoicePlayback, [cancelVoicePlayback]);
+
   useEffect(() => {
     // Don't spawn the chat PTY (and the TUI/agent bootstrap it triggers)
     // until the chat tab has been activated. Prevents the persistently
@@ -1789,6 +1820,7 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
                 profile={scopedProfile}
                 onDashboardNewSessionRequest={startFreshDashboardChat}
                 onSessionTitleChange={handleSessionTitleChange}
+                onAssistantFinal={speakVoiceResponse}
               />
             </div>
             <ChatSessionList
@@ -1826,6 +1858,11 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
             boxShadow: "0 8px 32px rgba(0, 0, 0, 0.4)",
           }}
         >
+          <ChatVoiceControl
+            connected={ptyState === "open"}
+            submit={submitVoiceTranscript}
+            onBargeIn={cancelVoicePlayback}
+          />
           <div
             ref={hostRef}
             className="hermes-chat-xterm-host min-h-0 min-w-0 flex-1"
@@ -1961,6 +1998,7 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
                 profile={scopedProfile}
                 onDashboardNewSessionRequest={startFreshDashboardChat}
                 onSessionTitleChange={handleSessionTitleChange}
+                onAssistantFinal={speakVoiceResponse}
               />
             </div>
 

From 73476fccd2e12b415cab9fe2d63ceae5ae227ae0 Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Tue, 25 Aug 2026 20:55:10 -0500
Subject: [PATCH 2/7] fix(web): keep browser voice on Web Speech

---
 docs/review-artifacts/791ca2b9.patch.gz      | Bin 0 -> 30291 bytes
 docs/review-artifacts/s25-voice-lineage.md   |  33 ++++++++
 web/src/components/ChatVoiceControl.test.tsx |  21 -----
 web/src/components/ChatVoiceControl.tsx      |  38 +--------
 web/src/lib/native-voice-bridge.test.ts      |  41 ----------
 web/src/lib/native-voice-bridge.ts           |  79 -------------------
 6 files changed, 34 insertions(+), 178 deletions(-)
 create mode 100644 docs/review-artifacts/791ca2b9.patch.gz
 create mode 100644 docs/review-artifacts/s25-voice-lineage.md
 delete mode 100644 web/src/lib/native-voice-bridge.test.ts
 delete mode 100644 web/src/lib/native-voice-bridge.ts

diff --git a/docs/review-artifacts/791ca2b9.patch.gz b/docs/review-artifacts/791ca2b9.patch.gz
new file mode 100644
index 0000000000000000000000000000000000000000..5c933e98d0d4f6ad070213d65f99785044fd97e0
GIT binary patch
literal 30291
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%0DePc7y{2jLS$igH%LCBPqth@wwYce2;d^@7
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

literal 0
HcmV?d00001

diff --git a/docs/review-artifacts/s25-voice-lineage.md b/docs/review-artifacts/s25-voice-lineage.md
new file mode 100644
index 0000000000000..07d96ff2ace33
--- /dev/null
+++ b/docs/review-artifacts/s25-voice-lineage.md
@@ -0,0 +1,33 @@
+# S25 WebUI voice donor lineage
+
+This directory preserves the independently reviewable donor for the browser voice slice.
+
+## Immutable donor
+
+- Commit: `791ca2b9f8677568c3d49b38c97549aa981e0706`
+- Parent: `a79255d574bbf7279fadd2759782a4641c7976d9`
+- Subject: `fix(web): use live speech for mobile voice input`
+- Durable local ref: `refs/archive/s25-voice-donor-791ca2b9`
+- Deterministically compressed binary format-patch: `docs/review-artifacts/791ca2b9.patch.gz`
+- Compressed artifact SHA-256: `88fe5f0f1648cd3694de1c8dd76be1b61acd619b59433952581c2459b9610f0f`
+- Uncompressed patch SHA-256: `b8b5ac97c9384601d7ad62b21d24e4e63f88c60a1832a5525a950ef1605e9bec`
+- Stable patch-id: `79794abce4eb3e1a12eeb05e9a3bcf5c6626ddbd`
+
+After decompression, the stable patch-id computed from the committed patch equals the patch-id computed directly from commit `791ca2b9`, including the two donor screenshots. The committed patch remains sufficient if the non-published local archive ref is later removed.
+
+## Current-main port delta
+
+The candidate is a manual current-main port, not a cherry-pick. It retains the donor's browser `SpeechRecognition` direction, final/interim transcript accumulation, Android `onend` restart, fatal permission stop, tap-to-submit interaction, and typed Gboard fallback. Relative to the donor it:
+
+- ports onto `origin/main` at `f751a8c5467c41500e505d90cb0eb8b70929080f`;
+- bounds restart attempts with exponential backoff and protects callbacks with a capture generation;
+- normalizes and submits a non-empty transcript exactly once through a dedicated PTY helper;
+- adds explicit disconnected, cancel, unavailable, start-failure, retry-budget, and no-empty-submit behavior tests;
+- integrates the control into the current `ChatPage`/`ChatSidebar` layout;
+- consumes structured `message.complete` events for browser speech output and cancels playback on barge-in;
+- deliberately removes the unproven optional native bridge rather than selecting it from object shape alone; and
+- omits the donor screenshots from the product commit because they are preserved byte-for-byte in the binary donor patch and do not constitute real-device proof.
+
+## Truth boundary
+
+Gboard is typed fallback only. Chrome Web Speech supplies browser transcript events. This slice does not claim private Gboard audio/VAD access, on-device or offline recognition, continuous or hands-free conversation, or verified behavior on a physical S25. Those claims remain gated on real-device evidence.
diff --git a/web/src/components/ChatVoiceControl.test.tsx b/web/src/components/ChatVoiceControl.test.tsx
index c26a2b5a80620..bde6000e2eedc 100644
--- a/web/src/components/ChatVoiceControl.test.tsx
+++ b/web/src/components/ChatVoiceControl.test.tsx
@@ -41,7 +41,6 @@ describe("ChatVoiceControl browser speech input", () => {
 
   afterEach(async () => {
     await act(async () => root.unmount());
-    delete (window as Window & { hermesVoiceBridge?: unknown }).hermesVoiceBridge;
     host.remove();
     vi.useRealTimers();
     vi.unstubAllGlobals();
@@ -153,24 +152,4 @@ describe("ChatVoiceControl browser speech input", () => {
     expect(host.textContent).toContain("not connected");
   });
 
-  it("uses the optional native bridge and accepts partial and final events", async () => {
-    let listener: ((event: MessageEvent) => void) | undefined;
-    const bridge = {
-      postMessage: vi.fn(),
-      addEventListener: vi.fn((_name: string, cb: (event: MessageEvent) => void) => { listener = cb; }),
-      removeEventListener: vi.fn(),
-    };
-    Object.defineProperty(window, "hermesVoiceBridge", { configurable: true, value: bridge });
-    const { submit, surface } = await render();
-    await act(async () => surface.click());
-    expect(FakeRecognition.instances).toHaveLength(0);
-    expect(bridge.postMessage).toHaveBeenCalledWith(JSON.stringify({ version: 1, command: "start" }));
-    await act(async () => listener?.({ data: JSON.stringify({ version: 1, event: "partial", transcript: "Call" }) } as MessageEvent));
-    await act(async () => listener?.({ data: JSON.stringify({ version: 1, event: "final", transcript: "Call the crew" }) } as MessageEvent));
-    expect(host.textContent).toContain("Call the crew");
-    await act(async () => surface.click());
-    expect(submit).toHaveBeenCalledOnce();
-    expect(submit).toHaveBeenCalledWith("Call the crew");
-    expect(bridge.postMessage).toHaveBeenCalledWith(JSON.stringify({ version: 1, command: "stop" }));
-  });
 });
diff --git a/web/src/components/ChatVoiceControl.tsx b/web/src/components/ChatVoiceControl.tsx
index 5be2941579cdd..ef470900491bb 100644
--- a/web/src/components/ChatVoiceControl.tsx
+++ b/web/src/components/ChatVoiceControl.tsx
@@ -2,11 +2,6 @@ import { Mic, X } from "lucide-react";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { Button } from "@nous-research/ui/ui/components/button";
-import {
-  connectNativeVoiceBridge,
-  type NativeVoiceBridgeConnection,
-  type NativeVoiceMessageTarget,
-} from "@/lib/native-voice-bridge";
 
 const RESTART_DELAY_MS = 250;
 const MAX_RESTARTS = 6;
@@ -40,7 +35,6 @@ declare global {
   interface Window {
     SpeechRecognition?: SpeechRecognitionConstructor;
     webkitSpeechRecognition?: SpeechRecognitionConstructor;
-    hermesVoiceBridge?: NativeVoiceMessageTarget;
   }
 }
 
@@ -65,7 +59,6 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
   const restartCountRef = useRef(0);
   const restartTimerRef = useRef<number | null>(null);
   const generationRef = useRef(0);
-  const nativeBridgeRef = useRef<NativeVoiceBridgeConnection | null>(null);
   const finalRef = useRef("");
   const interimRef = useRef("");
 
@@ -164,8 +157,7 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     generationRef.current = generation;
     setError("");
     setState("listening");
-    if (nativeBridgeRef.current) nativeBridgeRef.current.command("start");
-    else startRecognition(generation);
+    startRecognition(generation);
   };
 
   const commit = () => {
@@ -179,7 +171,6 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     clearRestart();
     recognitionRef.current?.abort();
     recognitionRef.current = null;
-    nativeBridgeRef.current?.command("stop");
     submit(transcript);
     updateFinal("");
     updateInterim("");
@@ -193,39 +184,12 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     clearRestart();
     recognitionRef.current?.abort();
     recognitionRef.current = null;
-    nativeBridgeRef.current?.command("cancel");
     updateFinal("");
     updateInterim("");
     setError("");
     setState("idle");
   }, [clearRestart]);
 
-  useEffect(() => {
-    const connection = connectNativeVoiceBridge(window.hermesVoiceBridge, (event) => {
-      if (event.event === "partial") {
-        updateInterim(event.transcript ?? "");
-      } else if (event.event === "final") {
-        updateFinal(event.transcript ?? "");
-        updateInterim("");
-      } else if (event.event === "error") {
-        setError(event.message ?? "Native speech recognition failed.");
-        if (event.fatal) {
-          listeningRef.current = false;
-          setState("error");
-        }
-      } else if (event.event === "listening") {
-        setState("listening");
-      }
-    });
-    nativeBridgeRef.current = connection;
-    connection?.command("check");
-    return () => {
-      connection?.command("cancel");
-      connection?.disconnect();
-      if (nativeBridgeRef.current === connection) nativeBridgeRef.current = null;
-    };
-  }, []);
-
   useEffect(() => cancel, [cancel]);
 
   const transcript = `${finalTranscript}${interimTranscript}`.trim();
diff --git a/web/src/lib/native-voice-bridge.test.ts b/web/src/lib/native-voice-bridge.test.ts
deleted file mode 100644
index dde405e3eef8f..0000000000000
--- a/web/src/lib/native-voice-bridge.test.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { connectNativeVoiceBridge } from "./native-voice-bridge";
-
-describe("origin-scoped native voice bridge", () => {
-  it("sends only the declared command envelope and accepts declared transcript events", () => {
-    let listener: ((event: MessageEvent) => void) | undefined;
-    const target = {
-      postMessage: vi.fn(),
-      addEventListener: vi.fn((_name: string, cb: (event: MessageEvent) => void) => { listener = cb; }),
-      removeEventListener: vi.fn(),
-    };
-    const events = vi.fn();
-    const bridge = connectNativeVoiceBridge(target, events);
-    expect(bridge).not.toBeNull();
-    bridge?.command("check");
-    bridge?.command("start");
-    expect(target.postMessage).toHaveBeenNthCalledWith(1, JSON.stringify({ version: 1, command: "check" }));
-    expect(target.postMessage).toHaveBeenNthCalledWith(2, JSON.stringify({ version: 1, command: "start" }));
-
-    listener?.({ data: JSON.stringify({ version: 1, event: "partial", transcript: "hello" }) } as MessageEvent);
-    listener?.({ data: JSON.stringify({ version: 1, event: "unknown", transcript: "ignored" }) } as MessageEvent);
-    expect(events).toHaveBeenCalledOnce();
-    expect(events).toHaveBeenCalledWith({ version: 1, event: "partial", transcript: "hello" });
-  });
-
-  it("fails closed for missing or malformed bridge objects and events", () => {
-    expect(connectNativeVoiceBridge(undefined, vi.fn())).toBeNull();
-    const events = vi.fn();
-    let listener: ((event: MessageEvent) => void) | undefined;
-    const target = {
-      postMessage: vi.fn(),
-      addEventListener: vi.fn((_name: string, cb: (event: MessageEvent) => void) => { listener = cb; }),
-      removeEventListener: vi.fn(),
-    };
-    connectNativeVoiceBridge(target, events);
-    listener?.({ data: "not json" } as MessageEvent);
-    listener?.({ data: JSON.stringify({ version: 2, event: "final", transcript: "no" }) } as MessageEvent);
-    expect(events).not.toHaveBeenCalled();
-  });
-});
diff --git a/web/src/lib/native-voice-bridge.ts b/web/src/lib/native-voice-bridge.ts
deleted file mode 100644
index 2e86efebe09a9..0000000000000
--- a/web/src/lib/native-voice-bridge.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-export type NativeVoiceCommand = "check" | "start" | "stop" | "cancel";
-export type NativeVoiceEventName =
-  | "availability"
-  | "ready"
-  | "listening"
-  | "partial"
-  | "final"
-  | "error"
-  | "ended";
-
-export interface NativeVoiceEvent {
-  version: 1;
-  event: NativeVoiceEventName;
-  transcript?: string;
-  available?: boolean;
-  message?: string;
-  fatal?: boolean;
-}
-
-export interface NativeVoiceMessageTarget {
-  postMessage(message: string): void;
-  addEventListener(type: "message", listener: (event: MessageEvent) => void): void;
-  removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
-}
-
-const EVENT_NAMES = new Set<NativeVoiceEventName>([
-  "availability", "ready", "listening", "partial", "final", "error", "ended",
-]);
-
-function parseNativeVoiceEvent(data: unknown): NativeVoiceEvent | null {
-  if (typeof data !== "string") return null;
-  try {
-    const value = JSON.parse(data) as Record<string, unknown>;
-    if (value.version !== 1 || typeof value.event !== "string" || !EVENT_NAMES.has(value.event as NativeVoiceEventName)) {
-      return null;
-    }
-    if (value.transcript !== undefined && typeof value.transcript !== "string") return null;
-    if (value.available !== undefined && typeof value.available !== "boolean") return null;
-    if (value.message !== undefined && typeof value.message !== "string") return null;
-    if (value.fatal !== undefined && typeof value.fatal !== "boolean") return null;
-    return value as unknown as NativeVoiceEvent;
-  } catch {
-    return null;
-  }
-}
-
-export interface NativeVoiceBridgeConnection {
-  command(command: NativeVoiceCommand): void;
-  disconnect(): void;
-}
-
-/**
- * Bind the optional AndroidX WebKit WebMessage listener object.
- *
- * The native host owns origin allow-listing when it injects this target. The
- * web app neither assumes a specific Android recognizer nor receives provider
- * credentials. Missing/malformed targets fail closed to ordinary Web Speech.
- */
-export function connectNativeVoiceBridge(
-  target: NativeVoiceMessageTarget | undefined,
-  onEvent: (event: NativeVoiceEvent) => void,
-): NativeVoiceBridgeConnection | null {
-  if (!target || typeof target.postMessage !== "function" || typeof target.addEventListener !== "function" || typeof target.removeEventListener !== "function") {
-    return null;
-  }
-  const listener = (message: MessageEvent) => {
-    const event = parseNativeVoiceEvent(message.data);
-    if (event) onEvent(event);
-  };
-  target.addEventListener("message", listener);
-  return {
-    command(command) {
-      target.postMessage(JSON.stringify({ version: 1, command }));
-    },
-    disconnect() {
-      target.removeEventListener("message", listener);
-    },
-  };
-}

From 84b4cdece0e90f627fca56ef92122a92c0d8f4c0 Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Fri, 28 Aug 2026 14:40:06 -0500
Subject: [PATCH 3/7] fix(web): synchronize browser voice submission

---
 web/src/lib/assistant-voice-output.test.ts | 11 +++-
 web/src/lib/assistant-voice-output.ts      |  3 +-
 web/src/lib/pty-voice-submit.test.ts       | 35 +++++++----
 web/src/lib/pty-voice-submit.ts            | 20 ++++---
 web/src/pages/ChatPage.test.tsx            | 70 +++++++++++++++++++++-
 web/src/pages/ChatPage.tsx                 | 38 +++++++++---
 6 files changed, 148 insertions(+), 29 deletions(-)

diff --git a/web/src/lib/assistant-voice-output.test.ts b/web/src/lib/assistant-voice-output.test.ts
index d984c9bbda25a..1a7214e22c815 100644
--- a/web/src/lib/assistant-voice-output.test.ts
+++ b/web/src/lib/assistant-voice-output.test.ts
@@ -22,11 +22,20 @@ describe("assistant voice output", () => {
     const synth = { speak: vi.fn(), cancel: vi.fn() };
     const settled = vi.fn();
     const playback = speakAssistantFinal(synth, "Done", settled);
+    expect(playback).not.toBeNull();
     const utterance = synth.speak.mock.calls[0][0] as SpeechSynthesisUtterance;
     expect(utterance.text).toBe("Done");
     utterance.onend?.({} as SpeechSynthesisEvent);
-    playback.cancel();
+    playback?.cancel();
     expect(settled).toHaveBeenCalledOnce();
     expect(synth.cancel).toHaveBeenCalledOnce();
   });
+
+  it("does not start playback when SpeechSynthesisUtterance is unavailable", () => {
+    vi.stubGlobal("SpeechSynthesisUtterance", undefined);
+    const synth = { speak: vi.fn(), cancel: vi.fn() };
+
+    expect(speakAssistantFinal(synth, "Done", vi.fn())).toBeNull();
+    expect(synth.speak).not.toHaveBeenCalled();
+  });
 });
diff --git a/web/src/lib/assistant-voice-output.ts b/web/src/lib/assistant-voice-output.ts
index cb23fe69f1c7f..d09d90f9c285f 100644
--- a/web/src/lib/assistant-voice-output.ts
+++ b/web/src/lib/assistant-voice-output.ts
@@ -21,7 +21,8 @@ export function speakAssistantFinal(
   synthesis: SpeechSynthesisLike,
   text: string,
   onSettled: () => void,
-): { cancel(): void } {
+): { cancel(): void } | null {
+  if (typeof SpeechSynthesisUtterance !== "function") return null;
   const utterance = new SpeechSynthesisUtterance(text);
   let settled = false;
   const settle = () => {
diff --git a/web/src/lib/pty-voice-submit.test.ts b/web/src/lib/pty-voice-submit.test.ts
index e3cceeb4839c0..ee9f4060a469a 100644
--- a/web/src/lib/pty-voice-submit.test.ts
+++ b/web/src/lib/pty-voice-submit.test.ts
@@ -3,33 +3,48 @@ import { describe, expect, it, vi } from "vitest";
 import { submitVoiceTranscriptToPty } from "./pty-voice-submit";
 
 describe("submitVoiceTranscriptToPty", () => {
-  it("sends transcript then exactly one Return in a separate PTY frame", () => {
-    vi.useFakeTimers();
+  it("sends Return only after xterm reports the transcript render", () => {
     const socket = { readyState: WebSocket.OPEN, send: vi.fn() };
     const current = () => socket;
+    let terminalReady: (() => void) | undefined;
 
-    expect(submitVoiceTranscriptToPty(current, "Call the crew")).toBe(true);
+    expect(
+      submitVoiceTranscriptToPty(current, "Call the crew", (ready) => {
+        terminalReady = ready;
+      }, vi.fn()),
+    ).toBe(true);
     expect(socket.send).toHaveBeenCalledTimes(1);
     expect(socket.send).toHaveBeenNthCalledWith(1, "Call the crew");
-    vi.advanceTimersByTime(100);
+    terminalReady?.();
     expect(socket.send).toHaveBeenCalledTimes(2);
     expect(socket.send).toHaveBeenNthCalledWith(2, "\r");
-    vi.useRealTimers();
   });
 
   it("does not send Return through a replacement or closed socket", () => {
-    vi.useFakeTimers();
     const first = { readyState: WebSocket.OPEN, send: vi.fn<(data: string) => void>() };
     const second = { readyState: WebSocket.OPEN, send: vi.fn<(data: string) => void>() };
     let active: { readyState: number; send(data: string): void } = first;
-    expect(submitVoiceTranscriptToPty(() => active, "Hello")).toBe(true);
+    let terminalReady: (() => void) | undefined;
+    const onReturnFailed = vi.fn();
+    expect(
+      submitVoiceTranscriptToPty(() => active, "Hello", (ready) => {
+        terminalReady = ready;
+      }, onReturnFailed),
+    ).toBe(true);
     active = second;
-    vi.advanceTimersByTime(100);
+    terminalReady?.();
     expect(first.send).toHaveBeenCalledOnce();
     expect(second.send).not.toHaveBeenCalled();
+    expect(onReturnFailed).toHaveBeenCalledOnce();
 
     active = { readyState: WebSocket.CLOSED, send: vi.fn<(data: string) => void>() };
-    expect(submitVoiceTranscriptToPty(() => active, "Nope")).toBe(false);
-    vi.useRealTimers();
+    expect(
+      submitVoiceTranscriptToPty(
+        () => active,
+        "Nope",
+        () => undefined,
+        onReturnFailed,
+      ),
+    ).toBe(false);
   });
 });
diff --git a/web/src/lib/pty-voice-submit.ts b/web/src/lib/pty-voice-submit.ts
index 25c13916c8983..7cd56fc952531 100644
--- a/web/src/lib/pty-voice-submit.ts
+++ b/web/src/lib/pty-voice-submit.ts
@@ -1,5 +1,3 @@
-const PTY_TRANSCRIPT_RETURN_DELAY_MS = 100;
-
 interface PtySocket {
   readonly readyState: number;
   send(data: string): void;
@@ -8,23 +6,27 @@ interface PtySocket {
 /**
  * Submit one finalized browser transcript to Ink's composer.
  *
- * Return is deliberately a separate frame: a combined mobile WebSocket frame
- * can be classified as a paste and remain in the composer. The captured socket
- * must still be current before Return is sent, so a reconnect cannot submit the
- * transcript into a replacement PTY session.
+ * Return is deliberately a separate frame after xterm commits the PTY echo: a
+ * combined mobile WebSocket frame can be classified as a paste and remain in
+ * the composer. The captured socket must still be current before Return is
+ * sent, so a reconnect cannot submit into a replacement PTY session.
  */
 export function submitVoiceTranscriptToPty(
   currentSocket: () => PtySocket | null,
   transcript: string,
+  afterNextTerminalWrite: (ready: () => void) => void,
+  onReturnFailed: () => void,
 ): boolean {
   const socket = currentSocket();
   if (!socket || socket.readyState !== WebSocket.OPEN) return false;
 
-  socket.send(transcript);
-  globalThis.setTimeout(() => {
+  afterNextTerminalWrite(() => {
     if (currentSocket() === socket && socket.readyState === WebSocket.OPEN) {
       socket.send("\r");
+    } else {
+      onReturnFailed();
     }
-  }, PTY_TRANSCRIPT_RETURN_DELAY_MS);
+  });
+  socket.send(transcript);
   return true;
 }
diff --git a/web/src/pages/ChatPage.test.tsx b/web/src/pages/ChatPage.test.tsx
index 97a4f009a8140..3511ed3030c52 100644
--- a/web/src/pages/ChatPage.test.tsx
+++ b/web/src/pages/ChatPage.test.tsx
@@ -17,6 +17,9 @@ class FakeWebglAddon {
 }
 
 class FakeTerminal {
+  static instances: FakeTerminal[] = [];
+
+  writeCallbacks: Array<() => void> = [];
   options: Record<string, unknown>;
   rows = 24;
   cols = 80;
@@ -27,6 +30,7 @@ class FakeTerminal {
 
   constructor(options: Record<string, unknown>) {
     this.options = options;
+    FakeTerminal.instances.push(this);
   }
 
   attachCustomKeyEventHandler() {
@@ -75,7 +79,9 @@ class FakeTerminal {
 
   refresh() {}
 
-  write() {}
+  write(_data: string, callback?: () => void) {
+    if (callback) this.writeCallbacks.push(callback);
+  }
 }
 
 const maybeReloadForLoopbackWsAuthFailure = vi.fn(() => false);
@@ -94,6 +100,11 @@ vi.mock("@/components/ChatSidebar", () => ({
 vi.mock("@/components/ChatSessionList", () => ({
   ChatSessionList: () => null,
 }));
+vi.mock("@/components/ChatVoiceControl", () => ({
+  ChatVoiceControl: ({ submit }: { submit(text: string): void }) => (
+    <button onClick={() => submit("voice transcript")}>submit voice</button>
+  ),
+}));
 vi.mock("@/components/Backdrop", () => ({ Backdrop: () => null }));
 vi.mock("@/plugins", () => ({
   PluginSlot: () => null,
@@ -190,6 +201,7 @@ async function render(ui: ReactNode) {
 }
 
 beforeEach(() => {
+  FakeTerminal.instances = [];
   FakeWebSocket.instances = [];
   maybeReloadForLoopbackWsAuthFailure.mockClear();
   apiMocks.buildWsUrl.mockReset();
@@ -255,6 +267,62 @@ afterEach(async () => {
 });
 
 describe("ChatPage", () => {
+  it("waits for the post-submission terminal write before sending voice Return", async () => {
+    const { default: ChatPage } = await import("./ChatPage");
+    await render(
+      <MemoryRouter initialEntries={["/chat"]}>
+        <ChatPage isActive />
+      </MemoryRouter>,
+    );
+    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));
+    const socket = FakeWebSocket.instances[0];
+    socket.send = vi.fn();
+    socket.onmessage?.({ data: "older output" });
+
+    await act(async () => {
+      Array.from(container.querySelectorAll("button"))
+        .find((button) => button.textContent === "submit voice")!
+        .dispatchEvent(
+          new MouseEvent("click", { bubbles: true }),
+        );
+    });
+    expect(socket.send).toHaveBeenCalledOnce();
+    expect(socket.send).toHaveBeenCalledWith("voice transcript");
+
+    const terminal = FakeTerminal.instances[0];
+    terminal.writeCallbacks.shift()?.();
+    expect(socket.send).toHaveBeenCalledOnce();
+
+    socket.onmessage?.({ data: "voice transcript" });
+    terminal.writeCallbacks.shift()?.();
+    expect(socket.send).toHaveBeenNthCalledWith(2, "\r");
+  });
+
+  it("surfaces a voice submission failure when the socket closes before echo", async () => {
+    const { default: ChatPage } = await import("./ChatPage");
+    await render(
+      <MemoryRouter initialEntries={["/chat"]}>
+        <ChatPage isActive />
+      </MemoryRouter>,
+    );
+    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));
+    const socket = FakeWebSocket.instances[0];
+    socket.send = vi.fn();
+
+    await act(async () => {
+      Array.from(container.querySelectorAll("button"))
+        .find((button) => button.textContent === "submit voice")!
+        .dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      socket.readyState = 3;
+      socket.onclose?.({ code: 1006, reason: "", wasClean: false });
+    });
+
+    expect(container.textContent).toContain(
+      "Chat disconnected before the voice transcript could be submitted.",
+    );
+    expect(socket.send).not.toHaveBeenCalledWith("\r");
+  });
+
   it("treats loopback 4401 closes as stale-token reload candidates", async () => {
     const { default: ChatPage } = await import("./ChatPage");
 
diff --git a/web/src/pages/ChatPage.tsx b/web/src/pages/ChatPage.tsx
index c69875714cdff..661e283ddc403 100644
--- a/web/src/pages/ChatPage.tsx
+++ b/web/src/pages/ChatPage.tsx
@@ -185,6 +185,7 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
   const wsRef = useRef<WebSocket | null>(null);
   const voiceTurnRef = useRef(false);
   const voicePlaybackRef = useRef<{ cancel(): void } | null>(null);
+  const pendingVoiceReturnRef = useRef<(() => void) | null>(null);
   const stickToBottomRef = useRef(true);
   // Exposed to the main metrics-sync effect so it can refit the terminal
   // the moment `isActive` flips back to true (display:none → display:flex
@@ -512,7 +513,14 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
   };
 
   const submitVoiceTranscript = useCallback((transcript: string) => {
-    if (!submitVoiceTranscriptToPty(() => wsRef.current, transcript)) {
+    if (!submitVoiceTranscriptToPty(
+      () => wsRef.current,
+      transcript,
+      (ready) => {
+        pendingVoiceReturnRef.current = ready;
+      },
+      () => setBanner("Chat disconnected before the voice transcript could be submitted."),
+    )) {
       setBanner("Chat disconnected before the voice transcript could be sent.");
       return;
     }
@@ -532,7 +540,7 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
     const playback = speakAssistantFinal(window.speechSynthesis, text, () => {
       if (voicePlaybackRef.current === playback) voicePlaybackRef.current = null;
     });
-    voicePlaybackRef.current = playback;
+    if (playback) voicePlaybackRef.current = playback;
   }, [cancelVoicePlayback]);
 
   useEffect(() => cancelVoicePlayback, [cancelVoicePlayback]);
@@ -1344,17 +1352,24 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
       // bottom as each chunk COMMITS (xterm write callback) instead of
       // guessing with a fixed delay, and release the pin the moment the user
       // scrolls up to read the backlog (#59591).
-      const followScroll = shouldFollowPtyOutput(
+      const shouldFollowScroll = shouldFollowPtyOutput(
         effectiveResume,
         stickToBottomRef.current,
-      )
-        ? () => termRef.current?.scrollToBottom()
-        : undefined;
-      term.write(rendered, followScroll);
+      );
+      const submitReturn = pendingVoiceReturnRef.current;
+      term.write(rendered, () => {
+        if (shouldFollowScroll) termRef.current?.scrollToBottom();
+        if (submitReturn && pendingVoiceReturnRef.current === submitReturn) {
+          pendingVoiceReturnRef.current = null;
+          submitReturn();
+        }
+      });
       noteResumePtyChunk(rendered);
     };
 
     ws.onclose = (ev) => {
+      const failPendingVoiceReturn = pendingVoiceReturnRef.current;
+      pendingVoiceReturnRef.current = null;
       // Drain buffered sanitizer state. A buffered partial escape is dropped
       // (writing an unterminated CSI would wedge xterm's parser); a buffered
       // newline run is emitted collapsed.
@@ -1379,6 +1394,15 @@ export default function ChatPage({ isActive = true }: { isActive?: boolean }) {
       const why = ev.reason ? ` reason=${ev.reason}` : "";
       console.warn(`[chat] PTY WebSocket closed code=${ev.code}${why}`);
       setLastCloseCode(ev.code);
+      if (failPendingVoiceReturn) {
+        if (!ev.wasClean || ev.code === 1001 || ev.code === 1006) {
+          scheduleReconnect(ev.code);
+        } else {
+          setPtyState("closed");
+        }
+        failPendingVoiceReturn();
+        return;
+      }
       if (ev.code === 4401) {
         if (maybeReloadForLoopbackWsAuthFailure(ev.code)) {
           return;

From 65539bc3361faf7afca31872db38eae70754052b Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Fri, 28 Aug 2026 21:35:59 -0500
Subject: [PATCH 4/7] fix(web): respect reduced motion in voice control

---
 web/src/components/ChatVoiceControl.test.tsx | 8 ++++++++
 web/src/components/ChatVoiceControl.tsx      | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/web/src/components/ChatVoiceControl.test.tsx b/web/src/components/ChatVoiceControl.test.tsx
index bde6000e2eedc..b4a25e780afcf 100644
--- a/web/src/components/ChatVoiceControl.test.tsx
+++ b/web/src/components/ChatVoiceControl.test.tsx
@@ -145,6 +145,14 @@ describe("ChatVoiceControl browser speech input", () => {
     expect(surface.textContent).toContain("Gboard typed fallback remains below");
   });
 
+  it("suppresses the listening pulse when reduced motion is requested", async () => {
+    const { surface } = await render();
+    await act(async () => surface.click());
+    const mic = surface.querySelector("svg");
+    expect(mic?.classList.contains("animate-pulse")).toBe(true);
+    expect(mic?.classList.contains("motion-reduce:animate-none")).toBe(true);
+  });
+
   it("refuses to start while chat is disconnected", async () => {
     const { surface } = await render(vi.fn(), false);
     await act(async () => surface.click());
diff --git a/web/src/components/ChatVoiceControl.tsx b/web/src/components/ChatVoiceControl.tsx
index ef470900491bb..52c6449979195 100644
--- a/web/src/components/ChatVoiceControl.tsx
+++ b/web/src/components/ChatVoiceControl.tsx
@@ -207,7 +207,7 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
         onClick={state === "listening" ? commit : begin}
         className="flex min-h-[42dvh] w-full touch-manipulation flex-1 flex-col items-center justify-center gap-5 overflow-hidden px-5 py-8 text-center active:bg-white/10 lg:min-h-44"
       >
-        <Mic className={state === "listening" ? "h-12 w-12 shrink-0 animate-pulse text-red-400" : "h-12 w-12 shrink-0"} />
+        <Mic className={state === "listening" ? "h-12 w-12 shrink-0 animate-pulse text-red-400 motion-reduce:animate-none" : "h-12 w-12 shrink-0"} />
         <span className="max-h-[28dvh] w-full overflow-y-auto whitespace-pre-wrap break-words text-2xl font-semibold leading-tight sm:text-3xl">
           {headline}
         </span>

From b105ef594d055801d3f9e5f5796aaf8f642615a8 Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Tue, 25 Aug 2026 21:29:25 -0500
Subject: [PATCH 5/7] feat(web): add verified Android voice bridge

---
 web/src/components/ChatVoiceControl.test.tsx | 124 ++++++++++++++++++
 web/src/components/ChatVoiceControl.tsx      | 127 ++++++++++++++++++-
 2 files changed, 249 insertions(+), 2 deletions(-)

diff --git a/web/src/components/ChatVoiceControl.test.tsx b/web/src/components/ChatVoiceControl.test.tsx
index b4a25e780afcf..1b9084cfb8942 100644
--- a/web/src/components/ChatVoiceControl.test.tsx
+++ b/web/src/components/ChatVoiceControl.test.tsx
@@ -26,6 +26,17 @@ class FakeRecognition {
   }
 }
 
+class FakeNativeBridge {
+  messages: string[] = [];
+  onmessage: ((event: MessageEvent<string>) => void) | null = null;
+  postMessage(message: string) { this.messages.push(message); }
+  emit(event: string, text?: string) {
+    this.onmessage?.(new MessageEvent("message", {
+      data: JSON.stringify({ version: 1, event, ...(text === undefined ? {} : { text }) }),
+    }));
+  }
+}
+
 describe("ChatVoiceControl browser speech input", () => {
   let host: HTMLDivElement;
   let root: ReturnType<typeof createRoot>;
@@ -160,4 +171,117 @@ describe("ChatVoiceControl browser speech input", () => {
     expect(host.textContent).toContain("not connected");
   });
 
+  it("checks the native bridge and falls back when on-device recognition is unavailable", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { surface } = await render();
+
+    await act(async () => surface.click());
+    expect(bridge.messages).toEqual([JSON.stringify({ version: 1, command: "check" })]);
+    await act(async () => bridge.emit("availability", "on-device-unavailable;fallback-choice-required"));
+
+    expect(FakeRecognition.instances).toHaveLength(1);
+    expect(FakeRecognition.instances[0].start).toHaveBeenCalledOnce();
+  });
+
+  it("does not trust ready or final events before confirmed native availability", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { submit, surface } = await render();
+
+    await act(async () => surface.click());
+    await act(async () => bridge.emit("ready"));
+    await act(async () => bridge.emit("final", "must not send"));
+    await act(async () => vi.advanceTimersByTime(1_000));
+
+    expect(submit).not.toHaveBeenCalled();
+    expect(FakeRecognition.instances).toHaveLength(1);
+  });
+
+  it("uses confirmed native partials for display and submits a final exactly once", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { submit, surface } = await render();
+
+    await act(async () => surface.click());
+    await act(async () => bridge.emit("availability", "on-device"));
+    expect(bridge.messages.at(-1)).toBe(JSON.stringify({ version: 1, command: "start" }));
+    await act(async () => bridge.emit("ready"));
+    await act(async () => bridge.emit("partial", "Call the cr"));
+    expect(host.textContent).toContain("Call the cr");
+    expect(submit).not.toHaveBeenCalled();
+    const staleHandler = bridge.onmessage;
+    await act(async () => bridge.emit("final", "Call   the crew"));
+    await act(async () => staleHandler?.(new MessageEvent("message", {
+      data: JSON.stringify({ version: 1, event: "final", text: "duplicate" }),
+    })));
+
+    expect(submit).toHaveBeenCalledTimes(1);
+    expect(submit).toHaveBeenCalledWith("Call the crew");
+  });
+
+  it("falls back after a bounded native handshake timeout", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => vi.advanceTimersByTime(999));
+    expect(FakeRecognition.instances).toHaveLength(0);
+    await act(async () => vi.advanceTimersByTime(1));
+    expect(FakeRecognition.instances).toHaveLength(1);
+    expect(bridge.messages.at(-1)).toBe(JSON.stringify({ version: 1, command: "cancel" }));
+  });
+
+  it.each(["ended", "error"])("falls back when native emits %s while listening", async (event) => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => bridge.emit("availability", "on-device"));
+    await act(async () => bridge.emit("listening"));
+    await act(async () => bridge.emit(event, "native-ended"));
+    await act(async () => vi.advanceTimersByTime(500));
+    expect(FakeRecognition.instances).toHaveLength(1);
+    expect(FakeRecognition.instances[0].start).toHaveBeenCalledOnce();
+  });
+
+  it("accepts the concrete Android consumer final that follows speech-ended", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => bridge.emit("availability", "on-device"));
+    await act(async () => bridge.emit("ready"));
+    await act(async () => bridge.emit("ended", "speech-ended"));
+    await act(async () => bridge.emit("final", "Android final"));
+    await act(async () => vi.advanceTimersByTime(500));
+    expect(submit).toHaveBeenCalledOnce();
+    expect(submit).toHaveBeenCalledWith("Android final");
+    expect(FakeRecognition.instances).toHaveLength(0);
+  });
+
+  it("falls back if native stop never produces a final or ended event", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => bridge.emit("availability", "on-device"));
+    await act(async () => bridge.emit("ready"));
+    await act(async () => surface.click());
+    expect(bridge.messages.at(-1)).toBe(JSON.stringify({ version: 1, command: "stop" }));
+    await act(async () => vi.advanceTimersByTime(1_000));
+    expect(FakeRecognition.instances).toHaveLength(1);
+  });
+
+  it("cancels the native bridge and detaches its event handler on unmount", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { surface } = await render();
+    await act(async () => surface.click());
+    await act(async () => root.unmount());
+    expect(bridge.messages.at(-1)).toBe(JSON.stringify({ version: 1, command: "cancel" }));
+    expect(bridge.onmessage).toBeNull();
+    root = createRoot(host);
+  });
+
 });
diff --git a/web/src/components/ChatVoiceControl.tsx b/web/src/components/ChatVoiceControl.tsx
index 52c6449979195..851cf52ad59d5 100644
--- a/web/src/components/ChatVoiceControl.tsx
+++ b/web/src/components/ChatVoiceControl.tsx
@@ -5,6 +5,8 @@ import { Button } from "@nous-research/ui/ui/components/button";
 
 const RESTART_DELAY_MS = 250;
 const MAX_RESTARTS = 6;
+const NATIVE_HANDSHAKE_TIMEOUT_MS = 1_000;
+const NATIVE_FINAL_GRACE_MS = 250;
 
 type VoiceState = "idle" | "listening" | "sent" | "error";
 
@@ -29,12 +31,24 @@ interface SpeechRecognitionLike {
   abort(): void;
 }
 
+interface NativeVoiceBridge {
+  postMessage(message: string): void;
+  onmessage: ((event: MessageEvent<string>) => void) | null;
+}
+
+interface NativeVoiceEvent {
+  version: 1;
+  event: "availability" | "ready" | "listening" | "partial" | "final" | "error" | "ended";
+  text?: string;
+}
+
 type SpeechRecognitionConstructor = new () => SpeechRecognitionLike;
 
 declare global {
   interface Window {
     SpeechRecognition?: SpeechRecognitionConstructor;
     webkitSpeechRecognition?: SpeechRecognitionConstructor;
+    zer0Voice?: NativeVoiceBridge;
   }
 }
 
@@ -61,12 +75,26 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
   const generationRef = useRef(0);
   const finalRef = useRef("");
   const interimRef = useRef("");
+  const nativeRef = useRef<NativeVoiceBridge | null>(null);
+  const nativeTimerRef = useRef<number | null>(null);
+  const nativeAvailableRef = useRef(false);
+  const nativeSelectedRef = useRef(false);
+  const submittedRef = useRef(false);
 
   const clearRestart = useCallback(() => {
     if (restartTimerRef.current !== null) window.clearTimeout(restartTimerRef.current);
     restartTimerRef.current = null;
   }, []);
 
+  const clearNativeTimer = useCallback(() => {
+    if (nativeTimerRef.current !== null) window.clearTimeout(nativeTimerRef.current);
+    nativeTimerRef.current = null;
+  }, []);
+
+  const sendNativeCommand = (command: "check" | "start" | "stop" | "cancel") => {
+    nativeRef.current?.postMessage(JSON.stringify({ version: 1, command }));
+  };
+
   const updateFinal = (value: string) => {
     finalRef.current = value;
     setFinalTranscript(value);
@@ -142,6 +170,82 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     }
   }
 
+  function fallbackToBrowser(generation: number) {
+    if (generation !== generationRef.current || !listeningRef.current) return;
+    clearNativeTimer();
+    const bridge = nativeRef.current;
+    nativeRef.current = null;
+    nativeAvailableRef.current = false;
+    nativeSelectedRef.current = false;
+    if (bridge) {
+      bridge.onmessage = null;
+      bridge.postMessage(JSON.stringify({ version: 1, command: "cancel" }));
+    }
+    startRecognition(generation);
+  }
+
+  function startNative(bridge: NativeVoiceBridge, generation: number) {
+    nativeRef.current = bridge;
+    nativeAvailableRef.current = false;
+    nativeSelectedRef.current = false;
+    bridge.onmessage = (message) => {
+      if (generation !== generationRef.current || !listeningRef.current) return;
+      let event: NativeVoiceEvent;
+      try {
+        event = JSON.parse(message.data) as NativeVoiceEvent;
+      } catch {
+        fallbackToBrowser(generation);
+        return;
+      }
+      if (event.version !== 1) return;
+      switch (event.event) {
+        case "availability":
+          if (event.text !== "on-device") fallbackToBrowser(generation);
+          else {
+            nativeAvailableRef.current = true;
+            sendNativeCommand("start");
+          }
+          break;
+        case "ready":
+        case "listening":
+          if (!nativeAvailableRef.current) return;
+          nativeSelectedRef.current = true;
+          clearNativeTimer();
+          setError("");
+          setState("listening");
+          break;
+        case "partial":
+          if (nativeSelectedRef.current) updateInterim(event.text ?? "");
+          break;
+        case "final": {
+          const transcript = (event.text ?? "").replace(/\s+/g, " ").trim();
+          if (!nativeSelectedRef.current || !transcript || submittedRef.current) return;
+          submittedRef.current = true;
+          listeningRef.current = false;
+          generationRef.current += 1;
+          clearNativeTimer();
+          bridge.onmessage = null;
+          nativeRef.current = null;
+          updateFinal("");
+          updateInterim("");
+          submit(transcript);
+          setError("");
+          setState("sent");
+          break;
+        }
+        case "error":
+          fallbackToBrowser(generation);
+          break;
+        case "ended":
+          clearNativeTimer();
+          nativeTimerRef.current = window.setTimeout(() => fallbackToBrowser(generation), NATIVE_FINAL_GRACE_MS);
+          break;
+      }
+    };
+    sendNativeCommand("check");
+    nativeTimerRef.current = window.setTimeout(() => fallbackToBrowser(generation), NATIVE_HANDSHAKE_TIMEOUT_MS);
+  }
+
   const begin = () => {
     if (!connected) {
       setError("Chat is not connected yet.");
@@ -152,15 +256,25 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     clearRestart();
     fatalRef.current = false;
     restartCountRef.current = 0;
+    submittedRef.current = false;
     listeningRef.current = true;
     const generation = generationRef.current + 1;
     generationRef.current = generation;
     setError("");
     setState("listening");
-    startRecognition(generation);
+    const bridge = window.zer0Voice;
+    if (bridge?.postMessage) startNative(bridge, generation);
+    else startRecognition(generation);
   };
 
   const commit = () => {
+    if (nativeRef.current && nativeSelectedRef.current) {
+      sendNativeCommand("stop");
+      clearNativeTimer();
+      const generation = generationRef.current;
+      nativeTimerRef.current = window.setTimeout(() => fallbackToBrowser(generation), NATIVE_HANDSHAKE_TIMEOUT_MS);
+      return;
+    }
     const transcript = `${finalRef.current} ${interimRef.current}`.replace(/\s+/g, " ").trim();
     if (!transcript) {
       setError("No speech heard yet — keep talking, then tap anywhere to send.");
@@ -182,13 +296,22 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     listeningRef.current = false;
     generationRef.current += 1;
     clearRestart();
+    clearNativeTimer();
+    const bridge = nativeRef.current;
+    nativeRef.current = null;
+    nativeAvailableRef.current = false;
+    nativeSelectedRef.current = false;
+    if (bridge) {
+      bridge.onmessage = null;
+      bridge.postMessage(JSON.stringify({ version: 1, command: "cancel" }));
+    }
     recognitionRef.current?.abort();
     recognitionRef.current = null;
     updateFinal("");
     updateInterim("");
     setError("");
     setState("idle");
-  }, [clearRestart]);
+  }, [clearNativeTimer, clearRestart]);
 
   useEffect(() => cancel, [cancel]);
 

From af53edc41c6bced7311755fd88ea60bad76b52cb Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Tue, 25 Aug 2026 21:35:24 -0500
Subject: [PATCH 6/7] fix(web): reject stale Android voice callbacks

---
 web/src/components/ChatVoiceControl.test.tsx | 29 ++++++++++++++++++++
 web/src/components/ChatVoiceControl.tsx      |  2 +-
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/web/src/components/ChatVoiceControl.test.tsx b/web/src/components/ChatVoiceControl.test.tsx
index 1b9084cfb8942..13fa0e545e56c 100644
--- a/web/src/components/ChatVoiceControl.test.tsx
+++ b/web/src/components/ChatVoiceControl.test.tsx
@@ -232,6 +232,35 @@ describe("ChatVoiceControl browser speech input", () => {
     expect(bridge.messages.at(-1)).toBe(JSON.stringify({ version: 1, command: "cancel" }));
   });
 
+  it("rejects every retained native callback after timeout fallback", async () => {
+    const bridge = new FakeNativeBridge();
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { submit, surface } = await render();
+    await act(async () => surface.click());
+    const staleHandler = bridge.onmessage;
+
+    await act(async () => vi.advanceTimersByTime(1_000));
+    expect(FakeRecognition.instances).toHaveLength(1);
+    const displayAfterFallback = host.textContent;
+
+    for (const [event, text] of [
+      ["availability", "on-device"],
+      ["ready", undefined],
+      ["partial", "stale partial"],
+      ["final", "stale final"],
+      ["error", "stale error"],
+    ] as const) {
+      await act(async () => staleHandler?.(new MessageEvent("message", {
+        data: JSON.stringify({ version: 1, event, ...(text === undefined ? {} : { text }) }),
+      })));
+    }
+
+    expect(host.textContent).toBe(displayAfterFallback);
+    expect(submit).not.toHaveBeenCalled();
+    expect(FakeRecognition.instances).toHaveLength(1);
+    expect(FakeRecognition.instances[0].start).toHaveBeenCalledOnce();
+  });
+
   it.each(["ended", "error"])("falls back when native emits %s while listening", async (event) => {
     const bridge = new FakeNativeBridge();
     Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
diff --git a/web/src/components/ChatVoiceControl.tsx b/web/src/components/ChatVoiceControl.tsx
index 851cf52ad59d5..c39fb9020dd28 100644
--- a/web/src/components/ChatVoiceControl.tsx
+++ b/web/src/components/ChatVoiceControl.tsx
@@ -189,7 +189,7 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     nativeAvailableRef.current = false;
     nativeSelectedRef.current = false;
     bridge.onmessage = (message) => {
-      if (generation !== generationRef.current || !listeningRef.current) return;
+      if (nativeRef.current !== bridge || generation !== generationRef.current || !listeningRef.current) return;
       let event: NativeVoiceEvent;
       try {
         event = JSON.parse(message.data) as NativeVoiceEvent;

From f843f20d9ddb7d1ac7f74e6d6fb754413cb58c76 Mon Sep 17 00:00:00 2001
From: lesseradmin <veeman961@gmail.com>
Date: Fri, 28 Aug 2026 16:44:38 -0500
Subject: [PATCH 7/7] fix(web): preserve native voice on malformed payloads

---
 web/src/components/ChatVoiceControl.test.tsx | 24 ++++++++++++++++++++
 web/src/components/ChatVoiceControl.tsx      |  4 ++--
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/web/src/components/ChatVoiceControl.test.tsx b/web/src/components/ChatVoiceControl.test.tsx
index 13fa0e545e56c..eafdae115badc 100644
--- a/web/src/components/ChatVoiceControl.test.tsx
+++ b/web/src/components/ChatVoiceControl.test.tsx
@@ -75,6 +75,15 @@ describe("ChatVoiceControl browser speech input", () => {
     expect(submit).not.toHaveBeenCalled();
   });
 
+  it("uses the browser locale for speech recognition", async () => {
+    vi.stubGlobal("navigator", { language: "fr-CA" });
+    const { surface } = await render();
+
+    await act(async () => surface.click());
+
+    expect(FakeRecognition.instances[0].lang).toBe("fr-CA");
+  });
+
   it("restarts Android premature onend with bounded exponential backoff and no submit", async () => {
     const { submit, surface } = await render();
     await act(async () => surface.click());
@@ -198,6 +207,21 @@ describe("ChatVoiceControl browser speech input", () => {
     expect(FakeRecognition.instances).toHaveLength(1);
   });
 
+  it("logs and ignores a malformed native bridge payload", async () => {
+    const bridge = new FakeNativeBridge();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+    Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
+    const { surface } = await render();
+
+    await act(async () => surface.click());
+    await act(async () => bridge.onmessage?.(new MessageEvent("message", { data: "not-json" })));
+
+    expect(warn).toHaveBeenCalledWith("[voice] Ignoring malformed native bridge payload");
+    expect(FakeRecognition.instances).toHaveLength(0);
+    await act(async () => bridge.emit("availability", "on-device"));
+    expect(bridge.messages.at(-1)).toBe(JSON.stringify({ version: 1, command: "start" }));
+  });
+
   it("uses confirmed native partials for display and submits a final exactly once", async () => {
     const bridge = new FakeNativeBridge();
     Object.defineProperty(window, "zer0Voice", { configurable: true, value: bridge });
diff --git a/web/src/components/ChatVoiceControl.tsx b/web/src/components/ChatVoiceControl.tsx
index c39fb9020dd28..d472e54e4122e 100644
--- a/web/src/components/ChatVoiceControl.tsx
+++ b/web/src/components/ChatVoiceControl.tsx
@@ -118,7 +118,7 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
     const recognition = new Constructor();
     recognition.continuous = true;
     recognition.interimResults = true;
-    recognition.lang = "en-US";
+    recognition.lang = navigator.language;
     recognition.onresult = (event) => {
       if (generation !== generationRef.current || !listeningRef.current) return;
       let appendedFinal = "";
@@ -194,7 +194,7 @@ export function ChatVoiceControl({ connected, submit, onBargeIn }: ChatVoiceCont
       try {
         event = JSON.parse(message.data) as NativeVoiceEvent;
       } catch {
-        fallbackToBrowser(generation);
+        console.warn("[voice] Ignoring malformed native bridge payload");
         return;
       }
       if (event.version !== 1) return;