fix(closure+voice+latency): KI-253 — P-bundle from U1 fails (P2 watchdog + P3 mark_rec gate + P4 instrumentation)

U1 Playwright re-test surfaced 4 remaining bugs after V-bundle landed. P-agents
diagnosed + fixed:

P1 — React #418 hydration: NO CODE CHANGE. V3 fix at page.tsx:229-232 + 357-363
(mounted flag gating micPermissionDenied) is correct + committed (52e5881).
P1 local rebuild + serve produces zero #418 errors. U1's failure was a stale
Next.js cache on HF Space — KI-252 redeploy will refresh.

P2 — Voice "green pill, zero audio" silent failure (V4 incomplete):
V4's catch worked for hard rejections (NotAllowedError), but TWO silent paths
bypassed it:
(a) Fake / silent stream — getUserMedia resolves but recorder.state never
reaches "recording" (Playwright fake-mic, Android WebView, codec
rejection). No error thrown, pill flipped to "Voice on" over dead stream.
(b) OS-stalled getUserMedia — locked-down Chromium / mic-busy / WebViews
leave getUserMedia pending forever instead of rejecting. V4's catch
never fires; user sits in limbo.
(c) PTT path bypassed the banner entirely — startRecording's catch called
pushAssistant but NOT setVoiceErrorBanner, so PTT failures were invisible.
Fix:
- useStreamingVoice.ensureAudioCapture: Promise.race against 2s StallTimeout
watchdog + assert recorder.state === "recording" post-acquire, else throw
RecorderNotRecording. Both fall into the existing mic_permission_denied catch.
- page.tsx startRecording: same watchdog + state validation; outer catch now
routes to setVoiceErrorBanner + setVoicePermDenied + setRecording(false) so
PTT failures show the same red banner.
Playwright headless 3-shim test confirmed:
REJECT → banner at 101ms, pill reverts to "Mic blocked"
STALL → banner at 2028ms (watchdog), pill reverts
FAKE → banner at 102ms (state check), pill reverts

P3 — mark_recommendation never invoked on soft-close:
U1 Test 9: "I'll go with that one" → bot offered next steps but didn't call
mark_recommendation(is_final=true). RULE 7 wasn't pulling the tool.
Fix:
- single_brain.py RULE 7 reframed as ordered STEP 1 (mandatory tool call) /
STEP 2 (prose), with explicit "NEVER SKIP" + chosen_id resolution table
(ordinal / insurer / "that one" → session.last_recommendation_ids[0]) +
verbatim worked example + explicit "RULE 7 violation" framing.
- main.py: server-side _CLOSER_KEYWORD_RE safety net catches "go with",
"I'll take", "let's do", "buy this", "purchase", "sign me up", "I'll go
with". After single_brain returns, if user_text matches AND brain_used
doesn't already contain mark_recommendation AND session.last_recommendation_ids
is non-empty, auto-calls brain_tools.mark_recommendation(session, [pid],
is_final=True). Guarantees the event is recorded even when Gemini forgets.

P4 — Latency 18.7s + profile_complete missing:
- single_brain.handle_turn now logs per-iter latency:
INFO single_brain iter=N gemini=Xs tools=Ys tool_calls=[...] per_tool=[...]
INFO single_brain retrieve_policies elapsed=Xs chunks=N query_len=N
Lets ops see whether Gemini sequential calls, retrieve, or cold-start
dominate before optimizing further. Hypothesized breakdown for the 18.7s:
3 Gemini round-trips @ ~5s each + 2.2s retrieve = sequential calls dominate.
- main.py: ChatResponse gained profile_complete: bool field; helper
_compute_profile_complete delegates to brain_tools._profile_complete
(single source of truth for the 7-slot list). Wired into all 4 response
build sites (success, timeout fallback, exception fallback, malformed body).
Frontend can now read profile_complete directly without a second /api/profile/completeness
roundtrip.

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

backend/main.py

@@ -12,6 +12,7 @@ import asyncio
 import base64
 import json
 import logging
+import re
 import time
 import uuid
 from pathlib import Path
@@ -39,6 +40,18 @@ USE_SINGLE_BRAIN = _os.environ.get("USE_SINGLE_BRAIN", "false").lower() in (
     "1", "true", "yes", "on",
 )
 
+# U1 Test 9 — safety net for RULE 7. If Gemini forgets to call
+# mark_recommendation when the user clearly commits to a policy ("I'll go
+# with that one", "let's do #2", "buy this"), the post-turn detector below
+# auto-calls mark_recommendation against session.last_recommendation_ids[:1]
+# so the closure event is recorded for analytics even when the LLM whiffs.
+# Word-boundary anchored; case-insensitive at match-time.
+_CLOSER_KEYWORD_RE = re.compile(
+    r"\b(go with|i'?ll take|i will take|let'?s do|let me get|sign me up|"
+    r"purchase|buy this|i want to purchase|i'?ll go with|i want to buy)\b",
+    re.IGNORECASE,
+)
+
 # Singleton provider instances (initialized on first call)
 _stt: Optional[SarvamSTT] = None
 _tts: Optional[SarvamTTS] = None
@@ -133,6 +146,21 @@ class ChatResponse(BaseModel):
             "flash an acknowledgment + refresh the completeness panel."
         ),
     )
+    # Issue B (KI-Z6-PROFILECOMPLETE, 2026-05-15) — frontend was making a
+    # second roundtrip to /api/profile/completeness after every chat turn to
+    # learn whether the 7 required slots are now captured. Surface it in the
+    # primary chat response so the UI can flip to 100% in the same render
+    # cycle. Computed via brain_tools._REQUIRED_FOR_READY (same slot list
+    # used by retrieve_policies' profile-complete gate) so client + server
+    # never disagree.
+    profile_complete: bool = Field(
+        False,
+        description=(
+            "True when every required profile slot (name, age, dependents, "
+            "location_tier, income_band, primary_goal, health_conditions) is "
+            "non-empty on the live session.profile at end-of-turn."
+        ),
+    )
 
 
 class TTSRequest(BaseModel):
@@ -180,6 +208,27 @@ class UploadResponse(BaseModel):
     elapsed_ms: int
 
 
+# Issue B (KI-Z6-PROFILECOMPLETE, 2026-05-15) — single source of truth for
+# "is this profile ready to recommend against". brain_tools._profile_complete
+# uses the same _REQUIRED_FOR_READY tuple; we mirror the call here instead of
+# duplicating the slot list so a future addition (e.g. risk_appetite) only
+# needs to be applied in brain_tools.
+def _compute_profile_complete(session_id: str) -> bool:
+    """Read the live session profile and return True iff every required slot
+    is populated. Tolerant of every failure mode (no session yet, session
+    state import explodes, profile missing attrs) — returns False on any
+    error so the frontend NEVER sees a stale `true` from a partial profile.
+    """
+    try:
+        from backend.session_state import get_session
+        from backend.brain_tools import _profile_complete
+
+        sess = get_session(session_id)
+        return bool(_profile_complete(sess.profile))
+    except Exception:  # noqa: BLE001 — never block a chat reply for this
+        return False
+
+
 # ---------- app ----------
 
 app = FastAPI(
@@ -232,6 +281,7 @@ async def _validation_exception_handler(request: Request, exc: RequestValidation
                 "faithfulness_reasons": [],
                 "blocked": False,
                 "profile_updates": {},
+                "profile_complete": False,
             },
         )
     # Default behaviour for every other endpoint.
@@ -620,6 +670,7 @@ async def chat(req: ChatRequest, request: Request):
             faithfulness_reasons=[],
             blocked=False,
             profile_updates={},
+            profile_complete=_compute_profile_complete(session_id),
         )
     except Exception as e:
         logging.exception(
@@ -646,6 +697,48 @@ async def chat(req: ChatRequest, request: Request):
             faithfulness_reasons=[],
             blocked=False,
             profile_updates={},
+            profile_complete=_compute_profile_complete(session_id),
+        )
+
+    # U1 Test 9 — server-side closer-keyword safety net for RULE 7.
+    # If the user clearly committed to a policy this turn but Gemini did
+    # NOT call mark_recommendation (single_brain stamps "mark_recommendation"
+    # into turn.brain_used when the tool fires — see single_brain.py:1052),
+    # auto-call mark_recommendation against session.last_recommendation_ids[:1]
+    # so the closure event is recorded for analytics regardless of whether
+    # the LLM remembered to pull the tool. Best-effort; never blocks the
+    # reply if anything goes wrong.
+    try:
+        if (
+            USE_SINGLE_BRAIN
+            and turn is not None
+            and getattr(turn, "reply_text", None)
+            and _CLOSER_KEYWORD_RE.search(req.user_text or "")
+            and "mark_recommendation" not in (turn.brain_used or "")
+        ):
+            from backend.session_state import get_session as _get_session
+            from backend import brain_tools as _brain_tools
+
+            _closer_session = _get_session(session_id)
+            _last_recs = list(
+                getattr(_closer_session, "last_recommendation_ids", []) or []
+            )
+            if _last_recs:
+                _result = _brain_tools.mark_recommendation(
+                    session=_closer_session,
+                    policy_ids=_last_recs[:1],
+                    is_final=True,
+                )
+                logging.info(
+                    "U1-T9 closer auto-mark (session=%s) user_text=%r "
+                    "policy_ids=%s result=%s",
+                    session_id, req.user_text, _last_recs[:1], _result,
+                )
+    except Exception as _closer_err:  # noqa: BLE001
+        # Safety-net must never break the reply.
+        logging.warning(
+            "U1-T9 closer auto-mark failed (session=%s): %s: %s",
+            session_id, type(_closer_err).__name__, _closer_err,
         )
 
     audio_b64 = None
@@ -740,6 +833,7 @@ async def chat(req: ChatRequest, request: Request):
             faithfulness_reasons=turn.faithfulness_reasons,
             blocked=turn.blocked,
             profile_updates=turn.profile_updates,
+            profile_complete=_compute_profile_complete(session_id),
         )
     except Exception as _resp_err:  # noqa: BLE001
         # Anything else (TypeError/AttributeError/ValidationError) on the
@@ -765,6 +859,7 @@ async def chat(req: ChatRequest, request: Request):
             faithfulness_reasons=[],
             blocked=False,
             profile_updates={},
+            profile_complete=_compute_profile_complete(session_id),
         )
 
 

backend/single_brain.py

@@ -227,11 +227,38 @@ Do NOT call retrieve_policies for out-of-scope queries.
 RULE 7 — Soft close after the customer picks one
 ═══════════════════════════════════════════════════════════
 Once you have recommended AND the user has chosen a single policy ("I'll
-go with #2", "let's pick the HDFC one", "sounds good"):
-  1. Call mark_recommendation(policy_ids=[chosen_id], is_final=true).
-  2. Offer next steps in one short reply:
-     "Great choice! Would you like me to walk you through the purchase
-      steps, or summarise the key benefits one more time?"
+go with #2", "let's pick the HDFC one", "sounds good", "I'll take that",
+"let's do the first one", "sign me up", "buy this", "I want to purchase"):
+
+  STEP 1 (MANDATORY, NEVER SKIP) — Call the tool FIRST, before writing prose:
+    mark_recommendation(policy_ids=[chosen_id], is_final=true)
+
+    To resolve "chosen_id":
+      - "the first one" / "first" / "#1"  → session.last_recommendation_ids[0]
+      - "the second" / "#2"               → session.last_recommendation_ids[1]
+      - "the HDFC one"                    → match insurer slug in last rec list
+      - "that one" / "this one" / bare "I'll go with that"
+                                          → most recent recommendation =
+                                            session.last_recommendation_ids[0]
+
+  STEP 2 — Only AFTER the tool call, write the prose reply:
+    "Great choice! [Policy Name] is a solid pick for your profile. Would
+     you like me to walk through the purchase steps, or summarise the key
+     benefits?"
+
+WORKED EXAMPLE
+  User: "I'll go with that one"
+  Your flow:
+    i.   IDENTIFY which policy "that one" refers to. With no ordinal cue,
+         default to the most recent recommendation =
+         session.last_recommendation_ids[0].
+    ii.  Call mark_recommendation(policy_ids=[chosen_id], is_final=true)
+         FIRST. This is non-negotiable — the recommendation MUST be
+         recorded for analytics before any prose is written.
+    iii. THEN write the prose reply offering next steps.
+  DO NOT skip step (ii). Offering "would you like purchase steps?" without
+  the mark_recommendation tool call is a RULE 7 violation.
+
 Do not re-pitch alternatives after the user has chosen — only act on
 their next instruction.
 
@@ -936,6 +963,13 @@ async def handle_turn(
     last_payload: dict = {}
 
     for it in range(MAX_ITERATIONS):
+        # Issue A instrumentation (KI-Z6-LATENCY, 2026-05-15) — Priya T3
+        # timed at 18.7s vs an 8s budget. We need per-iteration breakdown
+        # of (Gemini call time) vs (tool exec time) to identify whether
+        # cold-start, embedding/Chroma, or sequential LLM calls dominate.
+        # Wall-clock timers below feed `_log.info("iter %d: ...")` so HF
+        # Space logs surface the breakdown without any extra plumbing.
+        _t_iter0 = time.perf_counter()
         try:
             payload = await _gemini_call(
                 api_key=api_key,
@@ -951,6 +985,7 @@ async def handle_turn(
             raise SingleBrainError(
                 f"gemini_call unexpected error: {type(e).__name__}: {e}"
             ) from e
+        _t_gemini = time.perf_counter() - _t_iter0
 
         last_payload = payload
         parts = _extract_parts(payload)
@@ -962,6 +997,11 @@ async def handle_turn(
         # called out — completely valid, return immediately.
         if not function_calls:
             last_text = text
+            _log.info(
+                "single_brain iter=%d gemini=%.2fs tools=%.2fs "
+                "tool_calls=[] final_text=True",
+                it, _t_gemini, 0.0,
+            )
             break
 
         # CASE B — one or more function calls. Append the model turn
@@ -975,12 +1015,35 @@ async def handle_turn(
             }
         )
 
+        _t_tools0 = time.perf_counter()
+        _per_tool_latency: list[str] = []  # logged tail for iter summary
         response_parts: list[dict] = []
         for fc in function_calls:
             name = fc["name"]
             args = fc.get("args") or {}
             tool_calls_made.append(name)
+            _t_tool0 = time.perf_counter()
             result = await _execute_tool(session, name, args)
+            _t_tool = time.perf_counter() - _t_tool0
+            _per_tool_latency.append(f"{name}={_t_tool:.2f}s")
+
+            # Issue A — when retrieve_policies dominates iter latency we
+            # need to know whether it's the embedding step or the Chroma
+            # ANN query. brain_tools.retrieve_policies already returns
+            # chunks + count; surface the elapsed wall-clock here so the
+            # log line tags retrieve_policies separately. The deeper
+            # embedding vs Chroma breakdown lives inside rag.retrieve and
+            # is out of scope for this patch; this gives ops enough signal
+            # to decide whether to drill further.
+            if name == "retrieve_policies":
+                _log.info(
+                    "single_brain retrieve_policies elapsed=%.2fs "
+                    "chunks=%d query_len=%d filter_ids=%s",
+                    _t_tool,
+                    len(result.get("chunks") or []),
+                    len(str(args.get("query") or "")),
+                    bool(args.get("policy_filter_ids")),
+                )
 
             # Bookkeeping for the TurnResult fields.
             if name == "save_profile_field" and result.get("saved"):
@@ -1001,6 +1064,15 @@ async def handle_turn(
                     }
                 }
             )
+        _t_tools = time.perf_counter() - _t_tools0
+
+        _log.info(
+            "single_brain iter=%d gemini=%.2fs tools=%.2fs "
+            "tool_calls=[%s] per_tool=[%s]",
+            it, _t_gemini, _t_tools,
+            ",".join(fc["name"] for fc in function_calls),
+            " ".join(_per_tool_latency),
+        )
 
         contents.append({"role": "user", "parts": response_parts})
         # And loop — Gemini gets another shot to either call more

frontend/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

frontend/src/app/page.tsx

@@ -790,13 +790,26 @@ export default function Page() {
       // KI-185 (2026-05-15) — match the useStreamingVoice AEC constraints
       // on the PTT path too, so echo cancellation applies whether the user
       // is in live-voice mode OR push-to-talk.
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: {
-          echoCancellation: true,
-          noiseSuppression: true,
-          autoGainControl: true,
-        },
-      });
+      // W2 (2026-05-15) — 2s watchdog so a stalled getUserMedia
+      // (corporate-locked Chromium, OS-mic-busy, certain Android WebViews)
+      // doesn't leave the PTT button red-pulsing over a dead mic with no
+      // banner. Mirrors useStreamingVoice.ensureAudioCapture's W2 race.
+      const stream: MediaStream = await Promise.race([
+        navigator.mediaDevices.getUserMedia({
+          audio: {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+          },
+        }),
+        new Promise<MediaStream>((_, reject) => {
+          setTimeout(() => {
+            const e = new Error("getUserMedia stalled >2s") as Error & { name: string };
+            e.name = "StallTimeout";
+            reject(e);
+          }, 2000);
+        }),
+      ]);
       const mime = MediaRecorder.isTypeSupported("audio/webm") ? "audio/webm" : "";
       const recorder = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
       mediaRecorderRef.current = recorder;
@@ -962,6 +975,20 @@ export default function Page() {
         }
       };
       recorder.start();
+      // W2 (2026-05-15) — affirmative post-acquire validation. recorder.start()
+      // returns void and does NOT throw on a fake-mic / dead-stream / codec
+      // rejection; the only reliable signal is recorder.state. Without this
+      // check, Playwright's fake stream let the button flip to red-pulsing
+      // "Stop" over a silent capture with no banner. Treat any non-"recording"
+      // state as a hard fail and surface mic_permission_denied.
+      if (recorder.state !== "recording") {
+        try { stream.getTracks().forEach((t) => t.stop()); } catch { /* ignore */ }
+        mediaRecorderRef.current = null;
+        throw Object.assign(
+          new Error(`MediaRecorder did not enter recording state (got ${recorder.state})`),
+          { name: "RecorderNotRecording" },
+        );
+      }
       setRecording(true);
 
       // KI-027 — VAD auto-cutoff is now ALWAYS on for the push-to-talk
@@ -1020,6 +1047,14 @@ export default function Page() {
       }
     } catch (e) {
       console.error(e);
+      // W2 (2026-05-15) — route to the structured banner the same way the
+      // live-voice path does, so PTT denials / stalls / fake-stream failures
+      // surface in the same red banner (not just an in-chat assistant
+      // message). Also revert the button by clearing recording state and
+      // setting voicePermDenied so the "🔇 Mic blocked" branch fires.
+      setRecording(false);
+      setVoicePermDenied(true);
+      setVoiceErrorBanner({ type: "mic_permission_denied", ts: Date.now() });
       pushAssistant(`Sorry — mic permission denied or unavailable.`);
     }
   }

frontend/src/lib/useStreamingVoice.ts

@@ -432,13 +432,30 @@ export function useStreamingVoice(
       // For headphone users this gives near-perfect echo cancellation;
       // for speaker users it's 70-90% reduction (some bleed unavoidable
       // without server-side reference cancellation).
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: {
-          echoCancellation: true,
-          noiseSuppression: true,
-          autoGainControl: true,
-        },
-      });
+      // W2 (2026-05-15) — 2s watchdog around getUserMedia.
+      // Some devices (Chromium on locked-down corporate Windows, certain
+      // Android WebViews, OS-level mic-busy states) STALL getUserMedia
+      // indefinitely instead of rejecting. Without a watchdog the pill
+      // sits at "Voice on" forever, no banner, no recovery path.
+      // Race the permission prompt against a 2000ms timeout that
+      // rejects with name="StallTimeout" so the catch below treats it
+      // identically to a hard denial (mic_permission_denied banner).
+      const stream: MediaStream = await Promise.race([
+        navigator.mediaDevices.getUserMedia({
+          audio: {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+          },
+        }),
+        new Promise<MediaStream>((_, reject) => {
+          setTimeout(() => {
+            const e = new Error("getUserMedia stalled >2s") as Error & { name: string };
+            e.name = "StallTimeout";
+            reject(e);
+          }, 2000);
+        }),
+      ]);
       const mime = pickRecorderMime();
       recorderMimeRef.current = mime || "audio/webm";
       const recorder = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
@@ -459,8 +476,27 @@ export function useStreamingVoice(
       // 1s timeslice so chunks land progressively — ondataavailable fires
       // once per second instead of only on stop().
       recorder.start(1000);
+      // W2 (2026-05-15) — affirmative post-acquire validation. A
+      // MediaRecorder that .start()s without throwing is NOT proof the
+      // capture is alive: Playwright's fake-mic stream, a stream from a
+      // device that was unplugged between getUserMedia and start(), or a
+      // codec rejection that fires `onerror` async — all leave recorder.state
+      // anything other than "recording". Without this check, the pill flipped
+      // to "Voice on" over a silent stream. Treat any non-"recording" state
+      // as a hard fail and route to the same mic_permission_denied banner.
+      if (recorder.state !== "recording") {
+        try { stream.getTracks().forEach((t) => t.stop()); } catch { /* ignore */ }
+        mediaStreamRef.current = null;
+        mediaRecorderRef.current = null;
+        throw Object.assign(new Error(`MediaRecorder did not enter recording state (got ${recorder.state})`), {
+          name: "RecorderNotRecording",
+        });
+      }
       recorderActiveRef.current = true;
-      console.debug("[useStreamingVoice] MediaRecorder started", { mime: recorderMimeRef.current });
+      console.debug("[useStreamingVoice] MediaRecorder started", {
+        mime: recorderMimeRef.current,
+        state: recorder.state,
+      });
       return true;
     } catch (err) {
       // W1 (2026-05-15) — DOMException name → VoiceError mapping.