fix(voice+brain+timeout): KI-168 + KI-169 + KI-170 bundle

KI-168 — Voice input rebuilt as hybrid streaming flow.
+ frontend/src/lib/useStreamingVoice.ts (NEW)
Web Speech API streams interim transcripts to chat input in real time
(ChatGPT/Claude-voice UX). MediaRecorder runs in parallel; on browser
silence-detect, audio blob POSTs to Sarvam /api/transcribe for the
authoritative final transcript. Replaces input text + auto-submits.
Falls back to Web Speech transcript if Sarvam errors. KI-165 race
guards preserved (isTextRequestPendingRef + skip-if-tiny-blob).
M frontend/src/app/page.tsx
Swapped useLiveConversation → useStreamingVoice. interim → setInput,
final → send(). Voice OFF by default (KI-131) preserved.
Old useLiveConversation.ts left on disk as graveyard.

KI-169 — Sales brain <think>-tag empty-reply retry.
M backend/sales_brain.py
qwen3-next-80b occasionally emits all reasoning inside <think>...</think>
in the JSON reply field, leaving nothing after strip → orchestrator
fell back to persona.py:221's cryptic "I'm thinking through that.
Could you rephrase or ask a follow-up?". Three fixes:
- System prompt: explicit "NEVER include <think> tags in reply" rule
- Post-parse: strip <think>...</think> from inside the reply value
- On empty-after-strip: retry the LLM call ONCE with a stricter
reminder system message. If retry also empty, bubble up
sales_brain::error:empty_reply.

KI-170 — Timeout bumped 25s → 45s.
Live latency samples on qwen3-next-80b + response_format=json_object:
16.3s / 16.6s / 6.1s. 25s ceiling breached periodically. Bumped both
inner (_TIMEOUT_S in sales_brain) and outer (orchestrator wait_for) to
45s. Outer timeout fallback message reworded from "Sorry, the system
is taking too long" → "Sorry, that took longer than expected — could
you say that one more time?".

VERIFICATION:
py_compile clean for sales_brain.py + orchestrator.py.
npx tsc --noEmit clean (frontend).
Live latency probe: brain_used=sales_brain::nim:qwen, replies natural.

DOCS CASCADE: still held per user request. Stash @0 has WS5 doc edits
(CLAUDE.md + README.md + ADR-039) — restoring after live confirmation
of this bundle.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/orchestrator.py

@@ -569,16 +569,16 @@ async def handle_turn(
                     chat_history=chat_history[-10:],
                     session_id=session_id,
                 ),
-                timeout=25.0,
+                timeout=45.0,  # KI-170 — bumped from 25s; qwen3-next-80b + JSON mode regularly lands 15-25s
             )
         except asyncio.TimeoutError:
             # No scripted fallback. Fail loud — let the operator see it.
             sb_result = SalesBrainResult(
-                reply_text="Sorry, the system is taking too long. Try again in a moment.",
+                reply_text="Sorry, that took longer than expected — could you say that one more time?",
                 captured_updates={},
                 ready_for_recommendations=False,
-                brain_used="sales_brain::error:timeout_25s",
-                error_reason="outer_timeout_25s",
+                brain_used="sales_brain::error:timeout_45s",
+                error_reason="outer_timeout_45s",
             )
 
         # Apply captured updates to profile. captured_updates is already

backend/sales_brain.py

@@ -80,10 +80,16 @@ class SalesBrainResult:
 # 25s mirrors fact_find_brain's KI-075 setting — gives NIM cold-start headroom
 # + leaves room for one chain fallback. The fast-brain chain already has its
 # own per-link + total-chain budget; this wait_for is a belt-and-braces stop.
-_TIMEOUT_S: float = 25.0
+_TIMEOUT_S: float = 45.0         # KI-170 — qwen3-next-80b + JSON mode regularly lands 15-25s; 25s breached periodically
 _MAX_TOKENS: int = 700           # prose + structured JSON object with safety margin
 _TEMPERATURE: float = 0.6        # mirrors fact_find_brain — conversational warmth
 
+# KI-169 — strip <think>...</think> blocks the LLM may emit inside the JSON
+# reply value (vs. as a preamble before the JSON, which _parse_brain_json
+# already handles).
+import re as _re_for_think
+_REPLY_THINK_BLOCK = _re_for_think.compile(r"<think>.*?</think>", _re_for_think.DOTALL)
+
 
 # ----------------------------------------------------------------------------
 # Slot metadata — descriptions surfaced to the LLM so it knows what to ask for
@@ -139,6 +145,7 @@ CONVERSATION RULES:
 - Indian English is fine — "₹", "lakh", "metro/tier-2 city", "BP", "diabetes" all natural.
 - On health conditions, be straight: hiding a condition lowers premium today but turns into a denied claim later. Encourage honesty without lecturing.
 - Never use markdown bold/italics — your reply may be read aloud by TTS.
+- NEVER include <think> tags or chain-of-thought reasoning in the "reply" field. The "reply" field is the EXACT prose shown to the user. Any internal reasoning is forbidden in "reply" — keep it natural and conversational.
 
 OUTPUT FORMAT — STRICT:
 Return a SINGLE JSON object with exactly these three keys:
@@ -432,6 +439,13 @@ async def drive_sales_brain(
     if not isinstance(reply_text, str):
         reply_text = str(reply_text)
     reply_text = reply_text.strip()
+    # KI-169 — strip <think>...</think> blocks the LLM may have emitted INSIDE
+    # the reply field value (vs. as a preamble to the JSON, which
+    # _parse_brain_json handles separately). qwen3-next-80b occasionally emits
+    # all of its reasoning inside <think>...</think> in the reply string,
+    # leaving nothing user-facing after a strip downstream.
+    if reply_text and "<think>" in reply_text:
+        reply_text = _REPLY_THINK_BLOCK.sub("", reply_text).strip()
 
     captures_raw = parsed.get("captures") or parsed.get("captured") or {}
     if not isinstance(captures_raw, dict):
@@ -445,16 +459,74 @@ async def drive_sales_brain(
     # Normalize + validate captures via the deterministic post-processor.
     captured_updates = normalize_captures(captures_raw, profile)
 
-    # Empty reply text is a soft-fail — the brain produced JSON but no prose.
-    # Surface this to the caller so it can decide what to do.
+    # KI-169 — empty reply text after <think>-strip: retry ONCE with a
+    # stricter reminder before failing. The retry adds a system message
+    # forbidding <think> tags + reminds the LLM to put prose in "reply".
     if not reply_text:
+        logging.info(
+            "sales_brain empty reply after think-strip — retrying once (session=%s, model=%s)",
+            session_id, served_model,
+        )
+        retry_messages = list(messages) + [
+            ChatMessage(
+                role="system",
+                content=(
+                    "REMINDER: Your previous response had an empty or <think>-only reply. "
+                    "The 'reply' field MUST contain natural user-facing prose. "
+                    "Do NOT include any <think> blocks or internal reasoning in 'reply'. "
+                    "Try again with a clean conversational reply."
+                ),
+            ),
+        ]
+        try:
+            retry_result = await asyncio.wait_for(
+                llm.chat(
+                    messages=retry_messages,
+                    temperature=_TEMPERATURE,
+                    max_tokens=_MAX_TOKENS,
+                    response_format={"type": "json_object"},
+                ),
+                timeout=_TIMEOUT_S,
+            )
+            retry_parsed = _parse_brain_json((retry_result.text or "").strip())
+            if retry_parsed:
+                retry_reply = retry_parsed.get("reply") or ""
+                if isinstance(retry_reply, str):
+                    retry_reply = retry_reply.strip()
+                    if "<think>" in retry_reply:
+                        retry_reply = _REPLY_THINK_BLOCK.sub("", retry_reply).strip()
+                    if retry_reply:
+                        # Merge new captures from retry on top of first attempt
+                        retry_captures = retry_parsed.get("captures") or {}
+                        if isinstance(retry_captures, dict):
+                            merged = dict(captures_raw)
+                            merged.update(retry_captures)
+                            captured_updates = normalize_captures(merged, profile)
+                        retry_ready = retry_parsed.get("ready_for_recommendations")
+                        if retry_ready is not None:
+                            ready_for_recommendations = bool(retry_ready)
+                        retry_model = getattr(retry_result, "model", served_model) or served_model
+                        return SalesBrainResult(
+                            reply_text=retry_reply,
+                            captured_updates=captured_updates,
+                            ready_for_recommendations=ready_for_recommendations,
+                            brain_used=f"sales_brain::nim:{retry_model}::retry",
+                            raw_json=retry_parsed,
+                            error_reason=None,
+                        )
+        except (asyncio.TimeoutError, Exception) as retry_exc:  # noqa: BLE001
+            logging.warning(
+                "sales_brain retry also failed (session=%s): %s",
+                session_id, type(retry_exc).__name__,
+            )
+        # Retry failed — bubble up to orchestrator
         return SalesBrainResult(
             reply_text="",
             captured_updates=captured_updates,
             ready_for_recommendations=ready_for_recommendations,
             brain_used="sales_brain::error:empty_reply",
             raw_json=parsed,
-            error_reason=f"reply_field_empty from model={served_model}",
+            error_reason=f"reply_field_empty from model={served_model} (retry also empty)",
         )
 
     return SalesBrainResult(

frontend/src/app/page.tsx

@@ -30,7 +30,10 @@ import {
   UserProfile,
 } from "@/lib/api";
 import { translate, UILang, StringKey, GLOSSARY } from "@/lib/i18n";
-import { useLiveConversation } from "@/lib/useLiveConversation";
+// KI-168 (2026-05-15) — voice path migrated from custom-VAD `useLiveConversation`
+// to native browser SpeechRecognition via `useStreamingVoice`. The old hook
+// remains on disk as a graveyard reference until KI-168 is field-verified.
+import { useStreamingVoice } from "@/lib/useStreamingVoice";
 
 type DisplayMessage = ChatMessage & {
   id: string;
@@ -145,24 +148,65 @@ export default function Page() {
   const fileInputRef = useRef<HTMLInputElement>(null);
   const scrollRef = useRef<HTMLDivElement>(null);
 
-  // Live-conversation mode (full-duplex VAD barge-in). Defined further down
-  // in the component body so it can reference `sessionId`, `messages`, etc.
-  // via closure when the onUtterance handler fires. See useLiveConversation.ts.
-  const liveOnUtteranceRef = useRef<((blob: Blob, abort: AbortController) => Promise<void>) | null>(null);
+  // KI-168 (2026-05-15) — streaming-voice path replaces the legacy
+  // useLiveConversation full-duplex VAD machinery. Interim transcript shows
+  // in the chat input as the user speaks; browser silence-detection auto-
+  // submits the final transcript through send().
+  //
   // KI-165 (2026-05-15) — typed-text request inflight flag, observed by the
-  // voice hook so background-noise-triggered captures during a typed-text
-  // turn are discarded silently instead of clobbering the text response.
+  // voice hook so a transcript that finalises while a typed-text turn is
+  // racing is dropped silently instead of clobbering the text response.
   // Set to true at the start of `send()`, reset to false in its finally.
   // Use a ref (not state) so the voice hook reads the latest value without
   // re-rendering / re-subscribing.
   const isTextRequestPendingRef = useRef(false);
-  const live = useLiveConversation({
-    onUtterance: async (blob, abort) => {
-      const fn = liveOnUtteranceRef.current;
-      if (fn) await fn(blob, abort);
-    },
+
+  // Compatibility surface: the rest of the component (PTT path, UI pill, mic
+  // blocked indicator) still references live.live / live.setLive /
+  // live.recording / live.micPermissionDenied — preserve that shape so the
+  // rename is contained.
+  const [voiceEnabled, setVoiceEnabled] = useState(false);
+  const [voiceListening, setVoiceListening] = useState(false);
+  const [voicePermDenied, setVoicePermDenied] = useState(false);
+  // Submit handler — bound to the latest send() via a ref so the hook
+  // doesn't need to re-subscribe on every closure change.
+  const voiceSubmitRef = useRef<((text: string) => void) | null>(null);
+  const streamingVoice = useStreamingVoice({
+    enabled: voiceEnabled,
+    language: ttsLang,
     isTextRequestPendingRef,
+    onInterimTranscript: (text) => {
+      // Show the running transcript in the chat input area as the user speaks.
+      setInput(text);
+    },
+    onFinalTranscript: (text) => {
+      // Browser detected end-of-speech — auto-submit through the regular
+      // send() path (which clears the input).
+      const submit = voiceSubmitRef.current;
+      if (submit) submit(text);
+    },
+    onError: (msg) => {
+      // Surface as an inline assistant message + drop the pill into blocked
+      // state if it's a permission failure. Match the legacy
+      // micPermissionDenied UX so the existing "🔇 Mic blocked" branch fires.
+      if (/Mic permission denied|No microphone/i.test(msg)) {
+        setVoicePermDenied(true);
+        setVoiceEnabled(false);
+      }
+      setMessages((m) => [
+        ...m,
+        { id: `sys_${Date.now()}`, role: "assistant", content: msg },
+      ]);
+    },
+    onListening: setVoiceListening,
   });
+  // Legacy-shape adapter so the rest of the file's `live.*` refs keep working.
+  const live = {
+    live: voiceEnabled,
+    recording: voiceListening,
+    micPermissionDenied: voicePermDenied || !streamingVoice.isSupported,
+    setLive: setVoiceEnabled,
+  };
 
   useEffect(() => {
     getHealth()
@@ -394,59 +438,24 @@ export default function Page() {
     }
   }
 
-  // Live-conversation onUtterance binding. Rebinds when relevant state changes
-  // so the latest sessionId / history / view are captured in the closure.
+  // KI-168 (2026-05-15) — streaming-voice submit binding. The browser does
+  // the STT; we just route the finalised transcript through send() so it
+  // shares the typed-text code path (history, view_context, retries, TTS
+  // reply, profile completeness refresh, etc.). The input clears as part
+  // of send().
   useEffect(() => {
-    liveOnUtteranceRef.current = async (blob, abort) => {
-      try {
-        setVoicePhase("transcribing"); // KI-038 — show indicator while STT runs
-        const transcribed = await postTranscribe(blob, ttsLang, abort.signal);
-        const text = (transcribed.text || "").trim();
-        if (text.length < 2) { setVoicePhase(null); return; }
-
-        pushUser(text);
-        setVoicePhase("thinking"); // KI-038 — STT done; brain in flight now
-        const history: ChatMessage[] = messages.map((m) => ({ role: m.role, content: m.content }));
-        const active_view: "chat" | "marketplace" | "profile" | "premium" | "policy_detail" =
-          openPolicy ? "policy_detail" :
-          showMarketplace ? "marketplace" :
-          showProfile ? "profile" :
-          showPremium ? "premium" :
-          "chat";
-
-        const res = await postChat({
-          user_text: text,
-          session_id: sessionId,
-          chat_history: history,
-          return_audio: true,
-          tts_language_code: ttsLang,
-          view_context: { active_view, active_policy_id: openPolicy?.policy_id },
-          signal: abort.signal,
-        });
-        setSessionId(res.session_id);
-        getProfileCompleteness(res.session_id)
-          .then(setProfileCompleteness)
-          .catch(() => {});
-        const audioUrl = res.audio_base64 ? audioBlobURLFromBase64(res.audio_base64) : undefined;
-        pushAssistant(res.reply_text, {
-          citations: res.citations,
-          audioUrl,
-          brain: res.brain_used,
-          latencyMs: res.latency_ms,
-          blocked: res.blocked,
-        });
-        // KI-030 — playback handled by the in-DOM <audio> in Message component
-        // (autoplay-on-mount); needed so barge-in's querySelectorAll("audio")
-        // can pause it. See comment in the typed-send branch.
-      } catch (e: unknown) {
-        const name = (e as { name?: string })?.name;
-        if (name === "AbortError") { setVoicePhase(null); return; } // barge-in
-        // eslint-disable-next-line no-console
-        console.error("[live mode] turn failed:", e);
-      } finally {
-        setVoicePhase(null); // KI-038 — clear indicator once turn lands
-      }
+    voiceSubmitRef.current = (text: string) => {
+      const t = text.trim();
+      if (t.length < 2) return;
+      // Mirror the typed-input flow: drop transcript into the input
+      // (so the user sees their final words land in the box for a frame
+      // before send() clears it) then submit.
+      setInput(t);
+      void send(t);
     };
+    // send() reads `messages` / `sessionId` / `ttsLang` / view flags via
+    // closure; rebind whenever they change so the latest values are used.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [messages, sessionId, ttsLang, openPolicy, showMarketplace, showProfile, showPremium]);
 
   async function startRecording() {

frontend/src/lib/useStreamingVoice.ts

@@ -0,0 +1,538 @@
+"use client";
+
+/**
+ * useStreamingVoice — KI-168 (2026-05-15).
+ *
+ * Replaces the custom AudioWorklet + VAD + WAV-encode + /api/transcribe path
+ * (useLiveConversation) with the browser's native Web Speech API. The user
+ * sees their words land in the chat input area in real time as they speak,
+ * just like ChatGPT / Claude voice mode — and when the browser detects
+ * end-of-utterance silence, the final transcript is auto-submitted through
+ * the existing send() path.
+ *
+ * Why this exists
+ * -------------------------------------------------------------------------
+ * The previous live-mode stack accumulated 12+ KIs of failure modes
+ * (KI-044/057/060/064/113/114/115/131/134/139/141/159/165) trying to bolt
+ * a reliable VAD onto raw mic PCM. Every fix surfaced a new failure on a
+ * different mic / room / browser combo. The native SpeechRecognition API
+ * gives us:
+ *   - browser-grade end-of-speech detection (no rmsThreshold tuning)
+ *   - streaming interim transcripts (no "where did my words go?" gap)
+ *   - in-browser STT (no /api/transcribe round-trip latency)
+ *
+ * Behaviour
+ * -------------------------------------------------------------------------
+ *   - `enabled = true` → recognition.start() runs, mic icon stays live,
+ *     interim transcript streams into the chat input via onInterimTranscript.
+ *   - Browser detects ~1.5s silence → onend fires → we hand the final
+ *     transcript to onFinalTranscript (caller calls send()).
+ *   - After onend, if `enabled` is still true and no text request is in
+ *     flight, we restart recognition so the mic stays live (continuous-mode
+ *     emulation; native `continuous=true` doesn't fire silence-end on most
+ *     browsers, so we use continuous=false + auto-restart instead).
+ *   - `enabled = false` → recognition.abort() runs, no callbacks fire.
+ *
+ * Bot TTS playback is untouched — the page.tsx-owned <audio> elements still
+ * play Sarvam-generated audio for assistant replies.
+ */
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { postTranscribe } from "./api";
+
+// Minimal types for the Web Speech API since lib.dom.d.ts ships them under
+// `webkitSpeechRecognition` only and the standard `SpeechRecognition` symbol
+// is still vendor-prefixed in most browsers as of 2026-05.
+type SpeechRecognitionAlternative = { transcript: string; confidence: number };
+type SpeechRecognitionResult = {
+  isFinal: boolean;
+  length: number;
+  [index: number]: SpeechRecognitionAlternative;
+};
+type SpeechRecognitionResultList = {
+  length: number;
+  [index: number]: SpeechRecognitionResult;
+};
+interface SpeechRecognitionEventLike extends Event {
+  resultIndex: number;
+  results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionErrorEventLike extends Event {
+  error: string;
+  message?: string;
+}
+interface SpeechRecognitionInstance extends EventTarget {
+  lang: string;
+  continuous: boolean;
+  interimResults: boolean;
+  maxAlternatives: number;
+  start: () => void;
+  stop: () => void;
+  abort: () => void;
+  onresult: ((ev: SpeechRecognitionEventLike) => void) | null;
+  onerror: ((ev: SpeechRecognitionErrorEventLike) => void) | null;
+  onend: ((ev: Event) => void) | null;
+  onstart: ((ev: Event) => void) | null;
+}
+type SpeechRecognitionCtor = new () => SpeechRecognitionInstance;
+
+export interface UseStreamingVoiceOptions {
+  enabled: boolean;
+  onInterimTranscript: (text: string) => void;
+  onFinalTranscript: (text: string) => void;
+  onError: (msg: string) => void;
+  onListening: (listening: boolean) => void;
+  isTextRequestPendingRef: React.MutableRefObject<boolean>;
+  language?: string;
+}
+
+export interface UseStreamingVoiceReturn {
+  start: () => void;
+  stop: () => void;
+  isSupported: boolean;
+}
+
+function resolveCtor(): SpeechRecognitionCtor | null {
+  if (typeof window === "undefined") return null;
+  const w = window as unknown as {
+    SpeechRecognition?: SpeechRecognitionCtor;
+    webkitSpeechRecognition?: SpeechRecognitionCtor;
+  };
+  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+}
+
+export function useStreamingVoice(
+  opts: UseStreamingVoiceOptions,
+): UseStreamingVoiceReturn {
+  const {
+    enabled,
+    onInterimTranscript,
+    onFinalTranscript,
+    onError,
+    onListening,
+    isTextRequestPendingRef,
+    language = "en-IN",
+  } = opts;
+
+  // Keep latest callback refs so the recognition handlers always call the
+  // freshest closure without re-binding the recognition instance on every
+  // render (re-binding mid-utterance loses interim results).
+  const onInterimRef = useRef(onInterimTranscript);
+  const onFinalRef = useRef(onFinalTranscript);
+  const onErrorRef = useRef(onError);
+  const onListeningRef = useRef(onListening);
+  useEffect(() => { onInterimRef.current = onInterimTranscript; }, [onInterimTranscript]);
+  useEffect(() => { onFinalRef.current = onFinalTranscript; }, [onFinalTranscript]);
+  useEffect(() => { onErrorRef.current = onError; }, [onError]);
+  useEffect(() => { onListeningRef.current = onListening; }, [onListening]);
+
+  const recognitionRef = useRef<SpeechRecognitionInstance | null>(null);
+  const finalsRef = useRef<string[]>([]);
+  const wantRunningRef = useRef(false); // mirrors `enabled` for handler closures
+  const restartTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const errorBackoffRef = useRef(0);
+
+  // ----------------------------------------------------------------------
+  // KI-168 PHASE 2 — Sarvam authoritative-transcript layer.
+  // We run a MediaRecorder in parallel with SpeechRecognition. When the
+  // browser detects end-of-utterance silence (recognition.onend), we
+  // already have the raw audio chunks in memory. Send them to the backend
+  // /api/transcribe endpoint (Sarvam STT) and replace the Web Speech text
+  // with Sarvam's authoritative result. Web Speech remains the fallback if
+  // Sarvam times out, errors, or the audio path failed to initialise.
+  // ----------------------------------------------------------------------
+  const mediaStreamRef = useRef<MediaStream | null>(null);
+  const mediaRecorderRef = useRef<MediaRecorder | null>(null);
+  const chunksRef = useRef<Blob[]>([]);
+  const recorderMimeRef = useRef<string>("audio/webm");
+  // True only when MediaRecorder.start() actually succeeded. If false we
+  // bypass the Sarvam path and use Web Speech transcripts directly.
+  const recorderActiveRef = useRef(false);
+  // Promise resolved on the recorder's next `stop` event so we can wait
+  // for the final ondataavailable chunk before building the blob.
+  const recorderStopWaiterRef = useRef<(() => void) | null>(null);
+
+  const [isSupported] = useState<boolean>(() => resolveCtor() !== null);
+
+  const clearRestartTimer = useCallback(() => {
+    if (restartTimerRef.current !== null) {
+      clearTimeout(restartTimerRef.current);
+      restartTimerRef.current = null;
+    }
+  }, []);
+
+  const safeStart = useCallback(() => {
+    const rec = recognitionRef.current;
+    if (!rec) return;
+    try {
+      rec.start();
+    } catch {
+      // start() throws InvalidStateError if recognition is already running.
+      // Safe to ignore — onstart/onend will keep state in sync.
+    }
+  }, []);
+
+  // Pick the best MediaRecorder mimeType. iOS Safari only supports
+  // audio/mp4; Chromium/Firefox prefer audio/webm. Mirrors page.tsx PTT
+  // recorder + the KI-134 fallback logic.
+  const pickRecorderMime = useCallback((): string => {
+    if (typeof window === "undefined" || typeof MediaRecorder === "undefined") {
+      return "";
+    }
+    const candidates = ["audio/webm;codecs=opus", "audio/webm", "audio/mp4", "audio/mpeg"];
+    for (const m of candidates) {
+      try {
+        if (MediaRecorder.isTypeSupported(m)) return m;
+      } catch {
+        // ignore
+      }
+    }
+    return "";
+  }, []);
+
+  const stopRecorder = useCallback((): Promise<void> => {
+    const recorder = mediaRecorderRef.current;
+    if (!recorder || recorder.state === "inactive") {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      recorderStopWaiterRef.current = () => resolve();
+      try {
+        recorder.stop();
+      } catch {
+        // already stopped
+        recorderStopWaiterRef.current = null;
+        resolve();
+      }
+    });
+  }, []);
+
+  const teardownAudio = useCallback(() => {
+    const recorder = mediaRecorderRef.current;
+    if (recorder) {
+      try {
+        if (recorder.state !== "inactive") recorder.stop();
+      } catch {
+        // ignore
+      }
+      recorder.ondataavailable = null;
+      recorder.onstop = null;
+      recorder.onerror = null;
+    }
+    mediaRecorderRef.current = null;
+    const stream = mediaStreamRef.current;
+    if (stream) {
+      stream.getTracks().forEach((t) => {
+        try { t.stop(); } catch { /* ignore */ }
+      });
+    }
+    mediaStreamRef.current = null;
+    chunksRef.current = [];
+    recorderActiveRef.current = false;
+    recorderStopWaiterRef.current = null;
+  }, []);
+
+  const ensureAudioCapture = useCallback(async (): Promise<boolean> => {
+    if (mediaRecorderRef.current && recorderActiveRef.current) return true;
+    if (typeof navigator === "undefined" || !navigator.mediaDevices) return false;
+    if (typeof MediaRecorder === "undefined") return false;
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const mime = pickRecorderMime();
+      recorderMimeRef.current = mime || "audio/webm";
+      const recorder = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
+      chunksRef.current = [];
+      recorder.ondataavailable = (ev: BlobEvent) => {
+        if (ev.data && ev.data.size > 0) chunksRef.current.push(ev.data);
+      };
+      recorder.onstop = () => {
+        const waiter = recorderStopWaiterRef.current;
+        recorderStopWaiterRef.current = null;
+        if (waiter) waiter();
+      };
+      recorder.onerror = (ev: Event) => {
+        console.debug("[useStreamingVoice] MediaRecorder error", ev);
+      };
+      mediaStreamRef.current = stream;
+      mediaRecorderRef.current = recorder;
+      // 1s timeslice so chunks land progressively — ondataavailable fires
+      // once per second instead of only on stop().
+      recorder.start(1000);
+      recorderActiveRef.current = true;
+      console.debug("[useStreamingVoice] MediaRecorder started", { mime: recorderMimeRef.current });
+      return true;
+    } catch (err) {
+      console.debug("[useStreamingVoice] MediaRecorder init failed — falling back to Web Speech only", err);
+      recorderActiveRef.current = false;
+      return false;
+    }
+  }, [pickRecorderMime]);
+
+  const buildRecognition = useCallback((): SpeechRecognitionInstance | null => {
+    const Ctor = resolveCtor();
+    if (!Ctor) return null;
+    const rec = new Ctor();
+    rec.lang = language;
+    rec.continuous = false;
+    rec.interimResults = true;
+    rec.maxAlternatives = 1;
+
+    rec.onstart = () => {
+      onListeningRef.current(true);
+    };
+
+    rec.onresult = (ev: SpeechRecognitionEventLike) => {
+      let interim = "";
+      // Walk every result; finals get pushed onto finalsRef, interims get
+      // concatenated into a running string that's displayed in the input.
+      for (let i = 0; i < ev.results.length; i++) {
+        const result = ev.results[i];
+        const alt = result[0];
+        if (!alt) continue;
+        if (result.isFinal) {
+          const t = alt.transcript.trim();
+          if (t) finalsRef.current.push(t);
+        } else {
+          interim += alt.transcript;
+        }
+      }
+      const running = (finalsRef.current.join(" ") + " " + interim).trim();
+      onInterimRef.current(running);
+    };
+
+    rec.onerror = (ev: SpeechRecognitionErrorEventLike) => {
+      const code = ev.error;
+      // `no-speech` and `aborted` are routine in continuous-restart mode —
+      // no audio detected in a window, or we deliberately stopped. Silent
+      // restart via onend.
+      if (code === "no-speech" || code === "aborted") return;
+      if (code === "not-allowed" || code === "service-not-allowed") {
+        wantRunningRef.current = false;
+        onErrorRef.current(
+          "Mic permission denied. Click the lock icon in your browser's URL bar to enable the microphone.",
+        );
+        return;
+      }
+      if (code === "audio-capture") {
+        wantRunningRef.current = false;
+        onErrorRef.current("No microphone detected. Check your audio device and try again.");
+        return;
+      }
+      if (code === "network") {
+        // Transient — let onend's restart loop pick it up with backoff.
+        errorBackoffRef.current = Math.min(errorBackoffRef.current + 500, 3000);
+        return;
+      }
+      onErrorRef.current(`Voice error: ${code}${ev.message ? ` (${ev.message})` : ""}`);
+    };
+
+    rec.onend = () => {
+      onListeningRef.current(false);
+      const webSpeechText = finalsRef.current.join(" ").trim();
+      finalsRef.current = [];
+
+      // KI-168 PHASE 2 — race guard: if a typed-text turn is in flight,
+      // drop both transcripts on the floor (text wins). Don't start a
+      // Sarvam fetch we'd be throwing away.
+      const textRacing = isTextRequestPendingRef.current;
+
+      const scheduleRestart = () => {
+        if (wantRunningRef.current && !isTextRequestPendingRef.current) {
+          const backoff = errorBackoffRef.current;
+          errorBackoffRef.current = 0;
+          clearRestartTimer();
+          restartTimerRef.current = setTimeout(() => {
+            restartTimerRef.current = null;
+            if (wantRunningRef.current) safeStart();
+          }, Math.max(50, backoff));
+        } else if (wantRunningRef.current && isTextRequestPendingRef.current) {
+          // Text turn in flight — retry shortly so mic resumes the moment
+          // the text turn lands.
+          clearRestartTimer();
+          restartTimerRef.current = setTimeout(() => {
+            restartTimerRef.current = null;
+            if (wantRunningRef.current && !isTextRequestPendingRef.current) safeStart();
+          }, 250);
+        }
+      };
+
+      // Pull the chunks we've accumulated so far so the recorder can keep
+      // capturing the next utterance without us re-running getUserMedia.
+      const drainChunks = (): Blob[] => {
+        const drained = chunksRef.current;
+        chunksRef.current = [];
+        return drained;
+      };
+
+      // If there's no audio recorder, or text is racing, fall back to the
+      // Phase 1 behaviour: submit the Web Speech transcript and bail.
+      if (!recorderActiveRef.current || textRacing) {
+        if (webSpeechText && !textRacing) {
+          onFinalRef.current(webSpeechText);
+        }
+        // Best-effort: clear any partial audio so the next utterance isn't
+        // contaminated with the previous one's tail.
+        if (recorderActiveRef.current) drainChunks();
+        scheduleRestart();
+        return;
+      }
+
+      // Sarvam path. Fire-and-forget so we don't block the recognition
+      // restart loop on the network round-trip.
+      void (async () => {
+        // Snapshot user-visible interim so the input area doesn't go blank
+        // while Sarvam is in flight. The page-side input still shows the
+        // Web Speech transcript; we'll overwrite it via onFinalTranscript
+        // once Sarvam returns.
+        if (webSpeechText) onInterimRef.current(webSpeechText);
+
+        // We need to stop the recorder to get the final dataavailable
+        // chunk; then we re-arm a new recorder for the next utterance.
+        await stopRecorder();
+        const drained = drainChunks();
+        const totalSize = drained.reduce((n, b) => n + b.size, 0);
+        console.debug("[useStreamingVoice] silence-detect", {
+          webSpeechLen: webSpeechText.length,
+          chunkCount: drained.length,
+          blobBytes: totalSize,
+        });
+
+        // Re-arm audio capture for the next utterance (don't block on it).
+        teardownAudio();
+        // Only restart the audio pipeline if the user still wants the mic
+        // live. Fire-and-forget; recognition restart is scheduled below.
+        if (wantRunningRef.current) {
+          void ensureAudioCapture();
+        }
+
+        // Skip submit when there's effectively no audio or no Web Speech
+        // text. ~3 KB is the empirical noise floor used by the PTT path's
+        // KI-134 silence guard (page.tsx uses 1 KB; we're stricter here
+        // because Live mode auto-fires on every silence pause).
+        const MIN_BLOB_BYTES = 3000;
+        if (!webSpeechText && totalSize < MIN_BLOB_BYTES) {
+          console.debug("[useStreamingVoice] skipping submit — no text and tiny blob");
+          scheduleRestart();
+          return;
+        }
+
+        // If Web Speech got nothing, but we have a real blob, still try
+        // Sarvam — Web Speech occasionally drops short utterances on noisy
+        // mics that Sarvam handles fine.
+        if (!webSpeechText && totalSize < MIN_BLOB_BYTES) {
+          scheduleRestart();
+          return;
+        }
+
+        // Race-check again after the await — text turn may have started
+        // while we were stopping the recorder.
+        if (isTextRequestPendingRef.current) {
+          console.debug("[useStreamingVoice] text turn started mid-await; dropping voice turn");
+          scheduleRestart();
+          return;
+        }
+
+        let authoritativeText = webSpeechText;
+        if (drained.length > 0 && totalSize >= MIN_BLOB_BYTES) {
+          const blob = new Blob(drained, { type: recorderMimeRef.current || "audio/webm" });
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 8000);
+          try {
+            console.debug("[useStreamingVoice] POST /api/transcribe", { bytes: blob.size, mime: blob.type, lang: language });
+            const sarvam = await postTranscribe(blob, language, controller.signal);
+            const sarvamText = (sarvam.text || "").trim();
+            if (sarvamText) {
+              authoritativeText = sarvamText;
+              console.debug("[useStreamingVoice] Sarvam OK", {
+                latency_ms: sarvam.latency_ms,
+                webSpeechLen: webSpeechText.length,
+                sarvamLen: sarvamText.length,
+              });
+            } else {
+              console.debug("[useStreamingVoice] Sarvam returned empty; using Web Speech fallback");
+            }
+          } catch (err) {
+            console.debug("[useStreamingVoice] Sarvam failed; using Web Speech fallback", err);
+          } finally {
+            clearTimeout(timeoutId);
+          }
+        }
+
+        if (authoritativeText && !isTextRequestPendingRef.current) {
+          onFinalRef.current(authoritativeText);
+        }
+        scheduleRestart();
+      })();
+    };
+
+    return rec;
+  }, [language, isTextRequestPendingRef, clearRestartTimer, safeStart, stopRecorder, teardownAudio, ensureAudioCapture]);
+
+  const start = useCallback(() => {
+    if (!isSupported) {
+      onErrorRef.current(
+        "Live voice not supported in this browser. Use push-to-talk or type instead.",
+      );
+      return;
+    }
+    wantRunningRef.current = true;
+    if (!recognitionRef.current) {
+      recognitionRef.current = buildRecognition();
+    }
+    finalsRef.current = [];
+    // Kick off audio capture in parallel with recognition. If it fails we
+    // degrade to Web Speech-only — onend handles the fallback path.
+    void ensureAudioCapture();
+    safeStart();
+  }, [isSupported, buildRecognition, safeStart, ensureAudioCapture]);
+
+  const stop = useCallback(() => {
+    wantRunningRef.current = false;
+    clearRestartTimer();
+    const rec = recognitionRef.current;
+    if (rec) {
+      try {
+        rec.abort();
+      } catch {
+        // ignore
+      }
+    }
+    teardownAudio();
+    finalsRef.current = [];
+    onListeningRef.current(false);
+  }, [clearRestartTimer, teardownAudio]);
+
+  // Drive start/stop from the `enabled` prop so the hook is fire-and-forget
+  // for the caller (mirrors useLiveConversation's `live` state semantics).
+  useEffect(() => {
+    if (enabled) {
+      start();
+    } else {
+      stop();
+    }
+    return () => {
+      stop();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled]);
+
+  // Unmount cleanup.
+  useEffect(() => {
+    return () => {
+      wantRunningRef.current = false;
+      clearRestartTimer();
+      const rec = recognitionRef.current;
+      if (rec) {
+        try { rec.abort(); } catch {}
+        rec.onresult = null;
+        rec.onerror = null;
+        rec.onend = null;
+        rec.onstart = null;
+      }
+      recognitionRef.current = null;
+      teardownAudio();
+    };
+  }, [clearRestartTimer, teardownAudio]);
+
+  return { start, stop, isSupported };
+}