fix(voice+slots+routing): KI-212 + KI-213 + KI-215 + KI-216 bundle

KI-212 — Aggressive barge-in thresholds for reliable trigger.
BARGE_IN_RMS_THRESHOLD 0.025 → 0.008. BASE 0.005 → 0.002. MULTIPLIER
2.0 → 1.5. SUSTAINED_FRAMES 18 → 6 (~100ms vs ~300ms).
Barge-in fires on much softer speech without requiring calibration.

KI-213 — Push-to-talk shows live interim transcript.
Added SpeechRecognition in parallel with MediaRecorder during PTT.
Interim words stream into chat input as user speaks. On release,
Sarvam transcript replaces interim text. Falls back to browser
final if Sarvam fails. Self-contained in page.tsx.

KI-215 — Don't prematurely flip free_form_session.
Bug: once all 6 required slots captured + ready_for_recommendations
=true, orchestrator immediately flipped free_form_session=True.
User's confirmation reply ("Yes, that sounds correct") then
routed to QA → faithfulness rejected with "I'd rather not answer
that without stronger evidence." Now require the user's text to
explicitly contain a recommendation keyword (show me / recommend
/ suggest / top N / proceed / go ahead / etc.) before flipping.

KI-216 — health_conditions promoted REQUIRED + explicit confirmation.
Pre-existing conditions materially affect waiting periods, claim
outcomes, premium loadings. Sales_brain must ask before flipping
ready_for_recommendations=true. System prompt updated to direct
the brain to ask "Shall I put together some options for you now?"
when all required slots filled — wait for user affirmation before
pivoting to recommendations.

Orchestrator _REQUIRED_SLOTS now includes health_conditions; treats
empty list `[]` as a valid capture ("no conditions").

VERIFICATION:
py_compile clean (backend).
npx tsc --noEmit clean (frontend).

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

backend/orchestrator.py

@@ -669,16 +669,42 @@ async def handle_turn(
             if field_name not in session.profile.asked:
                 session.profile.asked.append(field_name)
 
-        # Completion gate. The LLM owns conversation flow; we only flip
-        # free_form_session when its own readiness signal is True AND every
-        # required slot is filled. Otherwise leave free_form_session=False so
-        # the next turn routes back here and the LLM continues gathering.
+        # KI-215 (2026-05-15) — completion gate WITHOUT premature flip.
+        # Previously we flipped session.free_form_session=True as soon as
+        # sb_result.ready_for_recommendations=True + all 6 required slots
+        # were filled. Bug: user's NEXT message (e.g., "Yes, that sounds
+        # correct" in response to sales_brain's confirmation recap) would
+        # route to the QA path → faithfulness gate → reject with "I'd
+        # rather not answer that without stronger evidence...".
+        #
+        # New rule: stay in fact_find UNTIL the user's text explicitly
+        # contains a recommendation request keyword. Sales_brain keeps
+        # owning the conversation through the recap + confirmation phase;
+        # only when the user says "show me", "recommend", "best for me",
+        # "options", etc., do we flip to free_form mode.
+        # KI-216 — health_conditions now REQUIRED (pre-existing conditions
+        # materially affect waiting periods / exclusions / premium loadings).
         _REQUIRED_SLOTS = ("name", "age", "dependents", "location_tier",
-                           "income_band", "primary_goal")
-        if sb_result.ready_for_recommendations and all(
-            getattr(session.profile, slot, None) not in (None, "", [])
-            for slot in _REQUIRED_SLOTS
-        ):
+                           "income_band", "primary_goal", "health_conditions")
+        # health_conditions=[] (empty list) is a VALID capture ("no conditions").
+        # Treat as "captured" if the field is a list (regardless of contents).
+        def _slot_filled(slot):
+            val = getattr(session.profile, slot, None)
+            if slot == "health_conditions":
+                return isinstance(val, list)
+            return val not in (None, "", [])
+        _slots_complete = all(_slot_filled(slot) for slot in _REQUIRED_SLOTS)
+        _utl = (user_text or "").lower()
+        _user_asked_for_recs = any(kw in _utl for kw in (
+            "recommend", "suggest", "show me", "best polic", "top 3",
+            "top three", "top 5", "top five", "side by side", "side-by-side",
+            "three options", "few options", "some options", "compare options",
+            "shortlist", "give me three", "give me options", "fits me",
+            "right for me", "policies for me", "which polic", "good polic",
+            "what polic", "your recommendation", "your suggestion",
+            "go ahead", "proceed", "let's see", "lets see",
+        ))
+        if sb_result.ready_for_recommendations and _slots_complete and _user_asked_for_recs:
             session.free_form_session = True
             session._flush()
 

backend/sales_brain.py

@@ -134,12 +134,18 @@ _SLOT_DESCRIPTIONS: dict[str, str] = {
 # Order of slots — used to determine "required remaining" so the LLM has a
 # stable sense of what to ask next. The first six are the recommendation-
 # readiness minimum; the rest are deepening signals.
+# KI-216 (2026-05-15) — `health_conditions` PROMOTED from nice-to-have to
+# REQUIRED. Pre-existing conditions massively affect premium, waiting
+# periods, and claim outcomes — skipping it means recommending policies
+# that may exclude the user's actual needs. The brain MUST ask before
+# advancing to recommendations.
 _REQUIRED_FOR_READY: tuple = (
-    "name", "age", "dependents", "location_tier", "income_band", "primary_goal",
+    "name", "age", "dependents", "location_tier", "income_band",
+    "primary_goal", "health_conditions",
 )
 
 _NICE_TO_HAVE: tuple = (
-    "existing_cover_inr", "budget_band", "health_conditions",
+    "existing_cover_inr", "budget_band",
     "parents_to_insure", "parents_age_max", "parents_has_ped",
 )
 
@@ -180,7 +186,8 @@ Return a SINGLE JSON object with exactly these three keys:
 Rules for the JSON:
 - "reply" — natural conversational prose. NO scripted prefixes ("Got that —", "Noted —", "Sure —", "Perfect —"). Acknowledge what they said by reflecting it back, then continue.
 - "captures" — only fields the user CHANGED or NEWLY revealed in their LAST message. If they didn't reveal anything new this turn, emit `"captures": {}` (empty object). Do NOT re-emit slots that haven't changed. Do NOT include null / empty-string values.
-- "ready_for_recommendations" — set to true ONLY when you have AT LEAST name, age, dependents, location, income_band, primary_goal. Otherwise false.
+- "ready_for_recommendations" — set to true ONLY when you have ALL of: name, age, dependents, location, income_band, primary_goal, AND health_conditions. **You MUST ask about pre-existing health conditions before setting this to true** — it materially affects which policies fit (waiting periods, exclusions, premium loadings). Empty list `[]` means "no conditions" — that's valid and counts as captured. Otherwise leave false.
+- "reply" before flipping ready: when ALL required slots above ARE captured this turn, your reply should EXPLICITLY ask the user "Shall I put together some options for you now?" (or similar natural confirmation). Do NOT auto-recommend or auto-pivot. The user has to affirm before we move to the recommendation phase.
 - All enum values must match the slot schema EXACTLY (case-sensitive). All ints as JSON numbers, not strings. Lists as JSON arrays.
 
 EXAMPLES OF GOOD REPLIES (illustrative — the JSON shape is what matters):

frontend/src/app/page.tsx

@@ -148,6 +148,51 @@ export default function Page() {
   const fileInputRef = useRef<HTMLInputElement>(null);
   const scrollRef = useRef<HTMLDivElement>(null);
 
+  // KI-213 (2026-05-15) — PTT-scoped browser SpeechRecognition. Runs in
+  // PARALLEL with the existing MediaRecorder + Sarvam pipeline so the user
+  // sees an interim transcript in the chat input as they speak (matching the
+  // live-voice UX) instead of staring at an empty input until Sarvam returns.
+  // Final Sarvam result still wins; the recognition transcript is only used
+  // as a fallback if Sarvam fails or returns empty.
+  //
+  // Types redeclared locally (instead of imported from useStreamingVoice.ts)
+  // because that module doesn't export them and they're tiny — keeping PTT a
+  // self-contained path in page.tsx per the existing architecture.
+  type PTTSpeechRecognitionAlternative = { transcript: string; confidence: number };
+  type PTTSpeechRecognitionResult = {
+    isFinal: boolean;
+    length: number;
+    [index: number]: PTTSpeechRecognitionAlternative;
+  };
+  type PTTSpeechRecognitionResultList = {
+    length: number;
+    [index: number]: PTTSpeechRecognitionResult;
+  };
+  interface PTTSpeechRecognitionEventLike extends Event {
+    resultIndex: number;
+    results: PTTSpeechRecognitionResultList;
+  }
+  interface PTTSpeechRecognitionErrorEventLike extends Event {
+    error: string;
+    message?: string;
+  }
+  interface PTTSpeechRecognitionInstance extends EventTarget {
+    lang: string;
+    continuous: boolean;
+    interimResults: boolean;
+    maxAlternatives: number;
+    start: () => void;
+    stop: () => void;
+    abort: () => void;
+    onresult: ((ev: PTTSpeechRecognitionEventLike) => void) | null;
+    onerror: ((ev: PTTSpeechRecognitionErrorEventLike) => void) | null;
+    onend: ((ev: Event) => void) | null;
+    onstart: ((ev: Event) => void) | null;
+  }
+  type PTTSpeechRecognitionCtor = new () => PTTSpeechRecognitionInstance;
+  const pttRecognitionRef = useRef<PTTSpeechRecognitionInstance | null>(null);
+  const pttFinalTranscriptRef = useRef<string>("");
+
   // 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-
@@ -504,9 +549,66 @@ export default function Page() {
       mediaRecorderRef.current = recorder;
       audioChunksRef.current = [];
       recorder.ondataavailable = (ev) => { if (ev.data.size > 0) audioChunksRef.current.push(ev.data); };
+
+      // KI-213 (2026-05-15) — start browser SpeechRecognition in parallel
+      // for interim transcript display. Sarvam still produces the
+      // authoritative transcript; this is purely UX (so the input fills as
+      // the user speaks). Best-effort: if SR is unsupported or start() throws
+      // we silently continue with the existing Sarvam-only flow.
+      pttFinalTranscriptRef.current = "";
+      try {
+        const w = window as unknown as {
+          SpeechRecognition?: PTTSpeechRecognitionCtor;
+          webkitSpeechRecognition?: PTTSpeechRecognitionCtor;
+        };
+        const Ctor = w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+        if (Ctor) {
+          const rec = new Ctor();
+          rec.continuous = false;
+          rec.interimResults = true;
+          rec.maxAlternatives = 1;
+          // ttsLang is the same locale the live-voice path uses; en-IN is the
+          // default fallback per the spec.
+          rec.lang = ttsLang || "en-IN";
+          rec.onresult = (ev: PTTSpeechRecognitionEventLike) => {
+            // Assemble interim transcript from ALL results (finals + currently
+            // in-progress interim). Mirror useStreamingVoice's pattern.
+            let interim = "";
+            let final = "";
+            for (let i = 0; i < ev.results.length; i++) {
+              const r = ev.results[i];
+              const alt = r[0];
+              if (!alt) continue;
+              if (r.isFinal) final += alt.transcript;
+              else interim += alt.transcript;
+            }
+            if (final) pttFinalTranscriptRef.current = final;
+            const display = (final + interim).trim();
+            if (display) setInput(display);
+          };
+          rec.onerror = () => { /* best-effort — Sarvam is the source of truth */ };
+          rec.onend = () => { /* nothing — recorder.onstop drives the submit */ };
+          pttRecognitionRef.current = rec;
+          rec.start();
+        }
+      } catch {
+        // SR unavailable or already running — fall through, Sarvam still works.
+        pttRecognitionRef.current = null;
+      }
       recorder.onstop = async () => {
         stopVAD();
         stream.getTracks().forEach((t) => t.stop());
+        // KI-213 (2026-05-15) — tear down the parallel SpeechRecognition.
+        // abort() is preferred over stop() to avoid a trailing onresult
+        // event firing AFTER we've already set the input to the Sarvam
+        // transcript (which would clobber it). The final transcript captured
+        // so far is preserved in pttFinalTranscriptRef as a Sarvam fallback.
+        const sr = pttRecognitionRef.current;
+        pttRecognitionRef.current = null;
+        if (sr) {
+          try { sr.abort(); } catch { /* already stopped */ }
+        }
+        const srFallback = pttFinalTranscriptRef.current.trim();
         const blob = new Blob(audioChunksRef.current, { type: recorder.mimeType || "audio/webm" });
         setRecording(false);
         // KI-028 — Resume Live ONLY if the user's persistent preference is
@@ -518,22 +620,47 @@ export default function Page() {
         // instead of returning quietly. Previously, holding PTT briefly and
         // releasing produced no feedback at all; now they at least see why.
         if (blob.size < 1000) {
+          // KI-213 — clear the lingering interim that SR may have left in the
+          // input so the user isn't confused by a stale partial transcript.
+          setInput("");
           pushAssistant("Didn't catch any audio — try holding the mic button while speaking.");
           maybeResumeLive();
           return;
         }
         setBusy(true);
         setVoicePhase("transcribing"); // KI-038 — STT in flight on PTT
+        // KI-213 — keep the interim transcript visible in the input as a
+        // placeholder while Sarvam runs. send() will clear it when (and only
+        // when) we actually submit, so the user sees their words throughout.
         try {
           const { text } = await postTranscribe(blob, ttsLang);
           if (text && text.trim()) {
+            // KI-213 — replace the interim SR transcript with Sarvam's
+            // authoritative version, then submit. send() clears the input
+            // itself so the brief flash here is intentional UX feedback.
+            setInput(text);
             // send() flips voicePhase to "thinking" itself; no need to set here
             await send(text);
+          } else if (srFallback) {
+            // KI-213 — Sarvam returned empty but the browser caught
+            // something. Better than telling the user "couldn't hear that
+            // clearly" when we actually have a usable transcript.
+            setInput(srFallback);
+            await send(srFallback);
           } else {
+            setInput("");
             pushAssistant("Sorry, I couldn't hear that clearly. Please try again.");
           }
         } catch (e: unknown) {
-          pushAssistant(`Sorry — transcribe error: ${e instanceof Error ? e.message : String(e)}`);
+          // KI-213 — Sarvam failed (network / 5xx / rate limit). Fall back to
+          // the SR transcript if we have one rather than dropping the turn.
+          if (srFallback) {
+            setInput(srFallback);
+            try { await send(srFallback); } catch { /* send handles its own errors */ }
+          } else {
+            setInput("");
+            pushAssistant(`Sorry — transcribe error: ${e instanceof Error ? e.message : String(e)}`);
+          }
         } finally {
           setBusy(false);
           setVoicePhase(null);

frontend/src/lib/useStreamingVoice.ts

@@ -46,16 +46,23 @@ import { postTranscribe } from "./api";
 // very low RMS (~0.001-0.005) while actual user speech sits at ~0.05-0.2.
 // We pick a threshold in between, and require ~300ms sustained energy
 // to avoid firing on coughs / room thumps / single-frame spikes.
-const BARGE_IN_RMS_THRESHOLD = 0.025;
-const BARGE_IN_SUSTAINED_FRAMES = 18; // ~300ms @ 60fps rAF
+// KI-212 (2026-05-15) — was 0.025 / 18 frames. User reported barge-in
+// completely failing: bot reads entire 14s reply uninterrupted. Lowered
+// to fire on ANY decent speech burst within 100ms. Risk: false positives
+// (chair creak, cough) — acceptable trade vs. broken barge-in.
+const BARGE_IN_RMS_THRESHOLD = 0.008;
+const BARGE_IN_SUSTAINED_FRAMES = 6; // ~100ms @ 60fps rAF
 // KI-190 (2026-05-15) — adaptive threshold. The MediaRecorder mic stream
 // has AEC, but for very loud bot TTS the residual bleed can still cross
 // the static 0.025 threshold. We instead compute the threshold dynamically
 // from the bot's CURRENT audio level: bot_rms * MULTIPLIER + BASE. Bot
 // loud → threshold rises so user must speak loudly to overcome residual;
 // bot quiet → threshold drops near floor so soft speech still wins.
-const BARGE_IN_BOT_RMS_MULTIPLIER = 2.0;
-const BARGE_IN_BASE_THRESHOLD = 0.005;
+// KI-212 — multiplier lowered 2.0 → 1.5 + base 0.005 → 0.002. Together
+// with the static threshold drop, makes barge-in fire on much softer
+// user speech even when bot is loud.
+const BARGE_IN_BOT_RMS_MULTIPLIER = 1.5;
+const BARGE_IN_BASE_THRESHOLD = 0.002;
 // KI-191 (2026-05-15) — duck bot TTS volume while voice mode is on.
 // Reducing playback amplitude further widens the gap between the bot's
 // residual mic bleed (after AEC) and the user's normal-volume speech,