fix(batch): voice interim, TTS truncation, RULE2.5 re-ask, faithfulness regression, markdown, compare-reviews, policy-name

Eight user-reported defects fixed together (all root-caused, all verified):

#17 page.tsx PTT live transcript: separate inline SpeechRecognition had
continuous=false + no-op onend (died after first pause, never
restarted) + replace-not-accumulate. Added cross-session final
accumulator, want-gated onend restart + 3s heartbeat, trailing flush.
#19 sarvam_tts.py: bulbul:v2 silently voices only the first sentence of
an over-real-limit single request; hard-coded 1500 ceiling meant the
chunker never engaged for 370-720-char replies. Ceiling 1500->500,
dropped undocumented enable_preprocessing, added a WAV-duration
truncation guard (fail-loud). RED->GREEN proven.
#18 single_brain.py: _profile_to_snapshot never exported smoker/
copay_pct/family_medical_history/parents_age_max, so the model
couldn't know they were captured -> RULE 2.5 re-asked them. Snapshot
widened + RULE 2.5 'omit captured items' directive.
#23 single_brain.py: get_policy_facts policies now registered into
retrieved_chunks_all so _verify_prose_grounding stops false-flagging
the UIN warning (regression from the get_policy_facts tool). Control
test proves the guard is not weakened.
#22 page.tsx: stray sentence-final numbers (15. 43. 52.) no longer
parsed as <ol>; genuine 1./2./3. lists preserved.
#21 PolicyCompareModal.tsx + page.tsx: Reviews & claim-settlement
section added to the in-chat compare modal (Bug 3 only covered the
inline cited cards).
#24 policy_identity.clean_display_policy_name: targeted display-only
cleanup ('HDFC ERGO my:Optima Secure (older variant)' ->
'Optima Secure (older variant)'); my:health & other names untouched;
policy_id/UIN/dedup unchanged. Applied at scorecard, brain_tools x4,
main.py citations+coverage.

Verified: full pytest suite exit 0 (no regression); TTS RED->GREEN;
#24 + grounding tests pass; frontend tsc clean, eslint 0-new.

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

backend/brain_tools.py

@@ -66,6 +66,7 @@ from pathlib import Path
 from typing import Any, Optional
 
 from backend.config import settings
+from backend.policy_identity import clean_display_policy_name
 
 _log = logging.getLogger(__name__)
 
@@ -713,7 +714,9 @@ def _quality_seed_candidates(profile, limit: int = 25) -> list[dict]:
             ch = {
                 "chunk_id": f"{pid}__qseed",
                 "policy_id": pid,
-                "policy_name": data.get("policy_name", pid),
+                "policy_name": clean_display_policy_name(
+                    data.get("policy_name", pid)
+                ),
                 "insurer_slug": data.get("insurer_slug")
                 or (pid.split("__", 1)[0] if "__" in pid else ""),
                 "doc_type": "policy",
@@ -802,7 +805,9 @@ async def _retrieve_uploaded_only(
         uploaded.append({
             "chunk_id": getattr(c, "chunk_id", ""),
             "policy_id": getattr(c, "policy_id", ""),
-            "policy_name": getattr(c, "policy_name", ""),
+            "policy_name": clean_display_policy_name(
+                getattr(c, "policy_name", "")
+            ),
             "insurer_slug": getattr(c, "insurer_slug", "") or "user-upload",
             "doc_type": "user_upload",
             "source_url": getattr(c, "source_url", ""),
@@ -1154,7 +1159,9 @@ async def retrieve_policies(
         chunk_dict = {
             "chunk_id": getattr(c, "chunk_id", ""),
             "policy_id": pid,
-            "policy_name": getattr(c, "policy_name", ""),
+            "policy_name": clean_display_policy_name(
+                getattr(c, "policy_name", "")
+            ),
             "insurer_slug": getattr(c, "insurer_slug", ""),
             "doc_type": doc_type,
             "source_url": getattr(c, "source_url", ""),
@@ -1320,7 +1327,9 @@ def get_policy_facts(session, policy_ids: Optional[list[str]] = None) -> dict:
     for pid in ids:
         cur = curated.get(pid) or {}
         slug = (slug_map.get(pid) or cur.get("insurer_slug") or "").strip()
-        pname = name_by_id.get(pid) or cur.get("policy_name") or pid
+        pname = clean_display_policy_name(
+            name_by_id.get(pid) or cur.get("policy_name") or pid
+        )
         rv = _insurer_reviews(slug) or {}
         cm = rv.get("claim_metrics") or {}
         agg = rv.get("aggregate_score") or {}

backend/main.py

@@ -1355,6 +1355,7 @@ async def chat(req: ChatRequest, request: Request):
     # an explicit try/except so a malformed citation can never silently
     # bypass our envelope.
     try:
+        from backend.policy_identity import clean_display_policy_name
         safe_citations: list[CitationOut] = []
         for c in turn.citations or []:
             if not isinstance(c, dict):
@@ -1363,7 +1364,9 @@ async def chat(req: ChatRequest, request: Request):
                 safe_citations.append(
                     CitationOut(
                         policy_id=str(c.get("policy_id", "") or ""),
-                        policy_name=str(c.get("policy_name", "") or ""),
+                        policy_name=clean_display_policy_name(
+                            str(c.get("policy_name", "") or "")
+                        ),
                         insurer_slug=str(c.get("insurer_slug", "") or ""),
                         page_start=int(c.get("page_start", 0) or 0),
                         page_end=int(c.get("page_end", 0) or 0),
@@ -1480,6 +1483,7 @@ async def coverage():
     # this refactor: badge = cards = 158 / 19.
     # KI-129 + KI-130 invariants still hold (profile + regulatory excluded).
     import json as _json
+    from backend.policy_identity import clean_display_policy_name
     _DOCTYPE_RANK_COV = {"wordings": 0, "prospectus": 1, "cis": 2, "brochure": 3}
     _doctype_of_cov = lambda stem: stem.rsplit("__", 1)[1] if "__" in stem else ""
     _product_key_of_cov = lambda pid: pid.rsplit("__", 1)[0] if "__" in pid else pid
@@ -1638,7 +1642,7 @@ async def coverage():
         if pkey in seen_product_keys:
             continue
         seen_product_keys.add(pkey)
-        name = data.get("policy_name", "") or pid
+        name = clean_display_policy_name(data.get("policy_name", "") or pid)
         url = data.get("source_pdf_url", "")
         if slug not in by_insurer:
             by_insurer[slug] = {"products": set(), "names": [], "chunks": 0, "aliases": 0}
@@ -1680,7 +1684,9 @@ async def coverage():
         if pkey in seen_product_keys and curated_pid not in ki145_variant_curated_ids_cov:
             continue
         seen_product_keys.add(pkey)
-        name = data.get("policy_name", "") or curated_pid
+        name = clean_display_policy_name(
+            data.get("policy_name", "") or curated_pid
+        )
         url = data.get("source_pdf_url", "")
         if slug not in by_insurer:
             by_insurer[slug] = {"products": set(), "names": [], "chunks": 0, "aliases": 0}
@@ -3100,6 +3106,7 @@ def _marketplace_catalogue(user_profile_dict):
     """
     import json as _json
     from backend.scorecard import build_scorecard
+    from backend.policy_identity import clean_display_policy_name
     corpus_url_index = _build_corpus_url_index()
     curated_facts = _load_curated_facts()
 
@@ -3332,8 +3339,10 @@ def _marketplace_catalogue(user_profile_dict):
             terminal_pkey = _product_key_of(terminal)
         else:
             terminal_pkey = terminal
-        alias_name = (curated_facts.get(curated_policy_id, {}).get("policy_name")
-                      or curated_policy_id)
+        alias_name = clean_display_policy_name(
+            curated_facts.get(curated_policy_id, {}).get("policy_name")
+            or curated_policy_id
+        )
         parent_pkey_aliases.setdefault(terminal_pkey, []).append(alias_name)
         aliased_curated_ids.add(curated_policy_id)
 
@@ -3428,7 +3437,9 @@ def _marketplace_catalogue(user_profile_dict):
             )
             out.append(MarketplacePolicy(
                 policy_id=policy_id,
-                policy_name=data.get("policy_name", fp.stem),
+                policy_name=clean_display_policy_name(
+                    data.get("policy_name", fp.stem)
+                ),
                 insurer_slug=slug,
                 insurer_name=name,
                 insurer_home_url=home,
@@ -3554,7 +3565,9 @@ def _marketplace_catalogue(user_profile_dict):
             )
             out.append(MarketplacePolicy(
                 policy_id=curated_policy_id,
-                policy_name=data.get("policy_name", curated_policy_id),
+                policy_name=clean_display_policy_name(
+                    data.get("policy_name", curated_policy_id)
+                ),
                 insurer_slug=slug,
                 insurer_name=name,
                 insurer_home_url=home,
@@ -3664,6 +3677,7 @@ async def compare_policies(policy_ids: list[str] = None):
     """Side-by-side comparison of 2-4 policies with their scorecards + field diffs."""
     import json as _json
     from backend.scorecard import build_scorecard
+    from backend.policy_identity import clean_display_policy_name
 
     if not policy_ids:
         from fastapi import Query
@@ -3717,7 +3731,9 @@ async def compare_policies(policy_ids: list[str] = None):
         sc = build_scorecard(data, insurer_reviews=ir)
         entries.append(CompareEntry(
             policy_id=pid,
-            policy_name=data.get("policy_name", pid),
+            policy_name=clean_display_policy_name(
+                data.get("policy_name", pid)
+            ),
             insurer_slug=slug or "?",
             fields=data,
             scorecard=ScorecardResponse(

backend/policy_identity.py

@@ -28,6 +28,15 @@ Public API:
     normalize_uin(raw) -> str
         Upper-cased, whitespace/punctuation-collapsed UIN, or "" when the
         value is absent / not a plausible UIN.
+    clean_display_policy_name(name) -> str
+        Display-only cleanup of the user-facing product name (BUG #24).
+        Strips the typo-looking lowercase `my:` prefix from HDFC ERGO's
+        Optima family ("my:Optima Secure (older variant)" ->
+        "Optima Secure (older variant)") and a duplicated leading
+        "HDFC ERGO " insurer label (the card shows the insurer
+        separately). TARGETED — `my:health Suraksha` etc. are legitimate
+        HDFC ERGO brand names and are left untouched. Never alters the
+        policy_id / UIN / dedup key (name is display-only).
 """
 
 from __future__ import annotations
@@ -123,4 +132,65 @@ def canonical_key(chunk_or_meta: Any) -> str:
     return f"nm:{name}" if name else "pk:"
 
 
-__all__ = ["canonical_key", "product_key", "normalize_uin"]
+# BUG #24 — display-name cleanup. The user-facing name for HDFC ERGO's
+# Optima Secure carries a typo-looking lowercase `my:` prefix
+# ("my:Optima Secure (older variant)") that reads as a formatting error.
+# It originates in the corpus manifest / extracted JSON / curated facts
+# and flows to every surface (marketplace card, chat citations,
+# get_policy_facts, scorecard, retrieve_policies chunks). We normalise it
+# once, centrally, at every user-facing surface.
+#
+# TARGETED — NOT a blanket `my:` strip:
+#   * `my:Optima ...`  -> `Optima ...`            (the BUG — fixed)
+#   * `my:health Suraksha` / `my:health Medisure Prime` / ...
+#                       -> UNCHANGED              (legitimate HDFC ERGO
+#                                                  brand names — KEEP)
+# We also drop a duplicated leading "HDFC ERGO " insurer label because
+# the card/citation shows the insurer separately
+# ("HDFC ERGO my:Optima Secure" -> "Optima Secure").
+#
+# The "(older variant)" suffix is an intentional KI-145 dedup
+# disambiguator (1 IRDAI UIN = 1 card) and is preserved verbatim.
+#
+# This is display-only: policy_id / UIN / canonical_key are never derived
+# from the cleaned name, so dedup + policy_id resolution are unchanged.
+
+# Only the leading "<duplicate insurer> " prefix on THIS product family is
+# stripped — scoped so we never touch an insurer token inside another
+# insurer's product name.
+_DUP_INSURER_PREFIX_RE = re.compile(
+    r"^\s*HDFC\s*ERGO\s+(?=my:\s*Optima\b|Optima\s+Secure\b)",
+    re.IGNORECASE,
+)
+# `my:Optima` (any case, optional space after the colon) -> `Optima`.
+# Bounded to the literal word "Optima" so `my:health ...` never matches.
+_MY_OPTIMA_PREFIX_RE = re.compile(r"\bmy:\s*(?=Optima\b)", re.IGNORECASE)
+
+
+def clean_display_policy_name(name: Any) -> str:
+    """Return the user-facing product name with the BUG #24 typo-looking
+    `my:` prefix removed for the HDFC ERGO Optima family ONLY, plus any
+    duplicated leading "HDFC ERGO " insurer label stripped.
+
+    Conservative and idempotent: a name with no `my:Optima` / leading
+    "HDFC ERGO " is returned unchanged (so `my:health Suraksha`,
+    `Optima Secure (older variant)`, every non-HDFC name pass through
+    untouched). Never mutates identity — callers pass the display string
+    only; policy_id / UIN / dedup keys are computed elsewhere from the
+    raw id, not from this value.
+    """
+    if not isinstance(name, str):
+        return name if name is not None else ""
+    out = _DUP_INSURER_PREFIX_RE.sub("", name)
+    out = _MY_OPTIMA_PREFIX_RE.sub("", out)
+    # Collapse any double space the prefix removals may have left and trim.
+    out = re.sub(r"\s{2,}", " ", out).strip()
+    return out or name
+
+
+__all__ = [
+    "canonical_key",
+    "product_key",
+    "normalize_uin",
+    "clean_display_policy_name",
+]

backend/providers/sarvam_tts.py

@@ -50,11 +50,21 @@ logger = logging.getLogger(__name__)
 # Ceiling is set below the documented cap so per-language preprocessing
 # expansion + minor jitter never pushes a chunk back over Sarvam's real
 # limit.
+# BUG #19 (2026-05-19): Sarvam bulbul:v2 silently returns HTTP 200 but
+# voices ONLY THE FIRST SENTENCE of any single request over its REAL
+# (small) limit — far below the 1500-char documented cap. A normal
+# 370–720-char recommendation reply was sent whole, so the user heard
+# only "Thanks for providing all those details, Rohit!" (~2s) and never
+# the policy list. The documented cap is NOT the operative limit; lower
+# the per-model ceiling so the existing sentence-seam chunker engages for
+# normal replies (effective v2 ceiling = 500 - 200 = 300 → a 370–720
+# char reply splits into 2–3 chunks, each synthesized and concatenated by
+# the already-correct `_concat_wav_bytes`).
 _TTS_CHAR_LIMIT_BY_MODEL = {
-    "bulbul:v2": 1500,
-    "bulbul:v3": 2500,
+    "bulbul:v2": 500,
+    "bulbul:v3": 1500,
 }
-_TTS_CHAR_LIMIT_DEFAULT = 1500  # safest assumption for unknown models
+_TTS_CHAR_LIMIT_DEFAULT = 500   # safest assumption for unknown models
 _TTS_SAFETY_MARGIN = 200        # headroom under the documented hard cap
 
 
@@ -394,7 +404,10 @@ class SarvamTTS(TTSProvider):
             "target_language_code": language_code,
             "speaker": speaker or self.default_speaker,
             "model": self.model,
-            "enable_preprocessing": True,
+            # BUG #19: `enable_preprocessing` is NOT in Sarvam's documented
+            # TTS schema; it triggers undocumented server-side first-sentence
+            # segmentation (HTTP 200 + only the first sentence voiced).
+            # Removed so the full chunk text is synthesized.
             "speech_sample_rate": 22050,
             "pitch": 0.0,
             "pace": 1.0,
@@ -413,7 +426,29 @@ class SarvamTTS(TTSProvider):
         if not audios:
             raise RuntimeError(f"Sarvam TTS returned no audio: {payload}")
         # Sarvam returns base64-encoded WAV in `audios[0]`
-        return base64.b64decode(audios[0])
+        wav_bytes = base64.b64decode(audios[0])
+
+        # BUG #19 — defensive truncation guard. Sarvam can return HTTP 200
+        # with audio that voices only the FIRST SENTENCE (the silent-
+        # truncation symptom). Decode the WAV and, if the playback duration
+        # is confidently too short for the text we sent (~30ms/char floor),
+        # raise so `classify_tts_exception` surfaces it LOUDLY instead of
+        # silently shipping a ~2s clip. The wave decode is wrapped so a
+        # decode failure (unexpected container) never masks the real audio;
+        # we ONLY raise on a confidently-short, successfully-decoded result.
+        try:
+            with wave.open(io.BytesIO(wav_bytes), "rb") as w:
+                framerate = w.getframerate()
+                n_frames = w.getnframes()
+            duration_s = (n_frames / framerate) if framerate else None
+        except Exception:  # pragma: no cover — never raise on decode failure
+            duration_s = None
+        if duration_s is not None and duration_s < 0.030 * len(text):
+            raise RuntimeError(
+                f"sarvam tts returned truncated audio: {duration_s:.2f}s "
+                f"for {len(text)} chars"
+            )
+        return wav_bytes
 
     async def synthesize_with_mime(
         self,

backend/scorecard.py

@@ -892,7 +892,14 @@ def build_scorecard(policy: dict, insurer_reviews: Optional[dict] = None, profil
     if not isinstance(policy, dict):
         policy = {}
     pid = policy.get("policy_id", "") or ""
-    pname = policy.get("policy_name", "") or ""
+    # BUG #24 — clean the typo-looking lowercase `my:` prefix off the
+    # user-facing name (HDFC ERGO Optima family only) at the scorecard
+    # chokepoint, so every scorecard-derived surface (compare, single &
+    # bulk /api/scorecard) shows "Optima Secure (older variant)" not
+    # "my:Optima Secure (older variant)". Display-only — policy_id below
+    # is untouched, so dedup / resolution are unchanged.
+    from backend.policy_identity import clean_display_policy_name
+    pname = clean_display_policy_name(policy.get("policy_name", "") or "")
     pslug = policy.get("insurer_slug", "") or ""
 
     completeness = compute_data_completeness(policy)

backend/single_brain.py

@@ -208,6 +208,9 @@ If the first call returns 0 or 1 chunk, retry ONCE with a broader query (drop th
 RULE 2.5 — Pricing inputs (SOFT capture, post-recap)
 ═══════════════════════════════════
 After all 7 slots are saved AND the user has confirmed the recap (RULE 4 implicit confirmation or explicit yes), BEFORE you call retrieve_policies, ask — in ONE compact prompt:
+
+CHECK THE PROFILE SNAPSHOT FIRST (Bug #FIX18 — DO NOT re-ask captured pricing slots): Before sending the pricing bundle, OMIT every item already present in the profile snapshot above (e.g. if `smoker` is set, do NOT ask smoking; if `existing_cover_inr` set, skip existing cover; if `family_medical_history` set, skip it; if `desired_sum_insured_inr`/`budget_band`/`copay_pct` set, skip those; if `parents_age_max` set, skip the parent-age item). Ask ONLY the genuinely missing ones, renumbered from 1 with no gaps. If ALL bundle items are already captured, SKIP the bundle entirely and proceed straight to retrieve_policies. The bundle items map 1:1 to these snapshot keys: 1→desired_sum_insured_inr, 2→budget_band, 3→existing_cover_inr, 4→copay_pct, 5→family_medical_history, 6→parents_age_max, 7→smoker. The verbatim template below is the FULL bundle — only emit the subset that is genuinely ABSENT.
+
   "A few quick pricing inputs (you can skip any):
    1. How much sum insured? (e.g., ₹5L / ₹10L / ₹25L / ₹1Cr)
    2. Premium budget? (e.g., ₹10–15K/year, or ₹50K+ for premium covers)
@@ -218,6 +221,7 @@ After all 7 slots are saved AND the user has confirmed the recap (RULE 4 implici
    7. Smoking status: Do you smoke or use tobacco products? (yes / no)
       Save: save_profile_field(field='smoker', value='yes' or 'no')
       Smokers face 30-50% premium loading; capturing this gives an accurate band."
+  (Renumber whatever subset you actually ask starting from 1 — never show gaps like "1, 3, 6".)
 
 When the user answers, call save_profile_field once per provided value:
   save_profile_field(field="desired_sum_insured_inr", value="1000000")  # ₹10L
@@ -620,10 +624,20 @@ def _profile_to_snapshot(profile) -> dict:
     fields it already has access to.
     """
     snap: dict[str, Any] = {}
+    # FIX #18 (2026-05-19) — the RULE 2.5 pricing-bundle fields
+    # (copay_pct / family_medical_history / smoker / parents_age_max) were
+    # NOT exported here, so the SYSTEM_PROMPT snapshot never showed the
+    # model that e.g. `smoker` was already captured (confirmed via
+    # save_profile_field + user "yes, correct"). RULE 2.5 then re-asked
+    # "Smoking status: ..." verbatim. They are now included so RULE 2.5's
+    # "OMIT every item already present in the profile snapshot" instruction
+    # has the data to act on. `smoker` is a bool → render as "yes"/"no" so
+    # the model reads it the same way it would write it.
     for fld in (
         "name", "age", "dependents", "location_tier", "income_band",
         "primary_goal", "health_conditions", "existing_cover_inr",
         "budget_band", "desired_sum_insured_inr",
+        "copay_pct", "family_medical_history", "parents_age_max",
     ):
         try:
             v = getattr(profile, fld, None)
@@ -631,6 +645,12 @@ def _profile_to_snapshot(profile) -> dict:
             v = None
         if v not in (None, "", []):
             snap[fld] = v
+    try:
+        _sm = getattr(profile, "smoker", None)
+    except Exception:
+        _sm = None
+    if _sm is not None:
+        snap["smoker"] = "yes" if _sm else "no"
     return snap
 
 
@@ -2015,6 +2035,60 @@ async def handle_turn(
             elif name == "retrieve_policies":
                 for c in result.get("chunks") or []:
                     retrieved_chunks_all.append(c)
+            elif name == "get_policy_facts" and result.get("ok"):
+                # FIX #23 (2026-05-19) — REGRESSION from the get_policy_facts
+                # tool. _verify_prose_grounding only treated retrieve_policies
+                # chunks as grounding, so policy NAMES the model legitimately
+                # stated FROM get_policy_facts (claim/denial/comparison
+                # answers) tripped the no-invented-numbers / UIN guard and the
+                # reply got the false "⚠️ … could not be verified against our
+                # records" caveat appended. Register each policy
+                # get_policy_facts actually returned as a synthetic grounding
+                # entry mirroring the retrieve_policies chunk shape
+                # ({policy_id, policy_name, insurer_slug, uin_code,
+                # source_url, chunk_text}) so the verifier sees it as
+                # grounded. We register ONLY what the tool returned — the
+                # guard is NOT weakened for genuinely ungrounded names.
+                for _p in result.get("policies") or []:
+                    if not isinstance(_p, dict):
+                        continue
+                    _pid = (_p.get("policy_id") or "").strip()
+                    _pname = (_p.get("policy_name") or "").strip()
+                    if not (_pid or _pname):
+                        continue
+                    _facts_bits = []
+                    for _k in (
+                        "claim_settlement_ratio_pct",
+                        "three_year_avg_csr_pct",
+                        "complaints_per_10k_policies",
+                        "incurred_claim_ratio_pct",
+                        "scorecard_grade",
+                        "reputation_headline",
+                    ):
+                        _v = _p.get(_k)
+                        if _v not in (None, "", []):
+                            _facts_bits.append(f"{_k}={_v}")
+                    retrieved_chunks_all.append(
+                        {
+                            "policy_id": _pid,
+                            "policy_name": _pname,
+                            "insurer_slug": (_p.get("insurer_slug") or ""),
+                            "uin_code": _p.get("uin_code") or "",
+                            "source_url": _p.get("claim_data_source_url")
+                            or "",
+                            "doc_type": "policy_facts",
+                            "chunk_text": (
+                                f"{_pname} ({_pid}) — "
+                                + (
+                                    "; ".join(_facts_bits)
+                                    if _facts_bits
+                                    else "get_policy_facts record"
+                                )
+                            ),
+                            "score": 1.0,
+                            "_synthetic_get_policy_facts": True,
+                        }
+                    )
             elif name == "mark_recommendation" and result.get("recorded"):
                 last_marked_policy_ids = list(result.get("policy_ids") or [])
 

frontend/src/app/page.tsx

@@ -258,6 +258,27 @@ export default function Page() {
   type PTTSpeechRecognitionCtor = new () => PTTSpeechRecognitionInstance;
   const pttRecognitionRef = useRef<PTTSpeechRecognitionInstance | null>(null);
   const pttFinalTranscriptRef = useRef<string>("");
+  // FIX #17 (A) — accumulator of finalized SR segments across the WHOLE PTT
+  // cycle (continuous=false makes Web Speech end+restart on every <1.5s
+  // pause; each restart begins a fresh `ev.results` list). Without this the
+  // running display rebuilt from only the current session's results loses
+  // every earlier finalized word. Mirrors useStreamingVoice's finalsRef.
+  const pttFinalSegmentsRef = useRef<string[]>([]);
+  // FIX #17 (A) — per-session cursor of how many of THIS recognition
+  // session's finals we've already pushed onto pttFinalSegmentsRef, so a
+  // re-fired onresult for the same session doesn't double-push the same
+  // final index. Reset to 0 on every onstart (new session). Mirrors the
+  // hook's finalsConsumedRef intent at session granularity.
+  const pttSessionFinalsConsumedRef = useRef<number>(0);
+  // FIX #17 (B) — intent flag mirroring useStreamingVoice's wantRunningRef.
+  // `true` from just-before rec.start() until any teardown / abort / error
+  // early-return. The onend auto-restart and the heartbeat both gate on it
+  // so recognition only restarts while we genuinely still want it running.
+  const pttSrWantRunningRef = useRef(false);
+  // FIX #17 (B) — KI-173-style heartbeat interval handle. Browser
+  // SpeechRecognition occasionally enters a stopped state without onend
+  // firing; this 3s watchdog re-issues rec.start() while we still want it.
+  const pttSrHeartbeatRef = useRef<number | null>(null);
 
   // KI-168 (2026-05-15) — streaming-voice path replaces the legacy
   // useLiveConversation full-duplex VAD machinery. Interim transcript shows
@@ -1022,6 +1043,11 @@ export default function Page() {
       // the user speaks). Best-effort: if SR is unsupported or start() throws
       // we silently continue with the existing Sarvam-only flow.
       pttFinalTranscriptRef.current = "";
+      // FIX #17 (A) — reset the cross-session final accumulator + session
+      // cursor at the start of every PTT cycle alongside pttFinalTranscriptRef
+      // so finalized words from a previous utterance don't leak forward.
+      pttFinalSegmentsRef.current = [];
+      pttSessionFinalsConsumedRef.current = 0;
       // V4 FIX 1 / FIX 3 — reset both the visible interim strip AND the
       // throttle ref each new PTT cycle so a stale gray-italic transcript
       // from the previous turn doesn't leak through.
@@ -1046,28 +1072,55 @@ export default function Page() {
           // 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.
+            // FIX #17 (A) — accumulate finals across the WHOLE PTT cycle.
+            // continuous=false ends+restarts SR on every <1.5s pause, and
+            // each restart begins a fresh `ev.results` list. The old code
+            // rebuilt the display from ONLY the current session's results
+            // and OVERWROTE pttFinalTranscriptRef with `final`, so every
+            // earlier finalized word was lost. Mirror useStreamingVoice:
+            // walk this session's results, push NOT-YET-CONSUMED finals
+            // onto the cross-session accumulator (tracking a per-session
+            // cursor so a re-fired onresult can't double-push), and build
+            // the display from accumulator + live interim.
             let interim = "";
-            let final = "";
+            let sessionFinalCount = 0;
             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 (r.isFinal) {
+                // The i-th final result of THIS session. Only push it once:
+                // sessionFinalCount counts finals seen so far in this event;
+                // pttSessionFinalsConsumedRef is how many of this session's
+                // finals are already in the accumulator.
+                if (sessionFinalCount >= pttSessionFinalsConsumedRef.current) {
+                  const t = alt.transcript.trim();
+                  if (t) pttFinalSegmentsRef.current.push(t);
+                  pttSessionFinalsConsumedRef.current = sessionFinalCount + 1;
+                }
+                sessionFinalCount += 1;
+              } else {
+                interim += alt.transcript;
+              }
             }
-            // V4 FIX 2 — dedup repeated finals within 500ms.
-            if (final) {
-              const trimmedFinal = final.trim();
+            const accumulated = pttFinalSegmentsRef.current.join(" ").trim();
+            // V4 FIX 2 — dedup repeated finals within 500ms (kept for the
+            // Safari double-final quirk; now compares the ACCUMULATED text
+            // rather than only the last session's final).
+            if (accumulated) {
               const { text: prevText, at: prevAt } = lastFinalTextRef.current;
               const now = Date.now();
-              if (trimmedFinal && (trimmedFinal !== prevText || now - prevAt > 500)) {
-                pttFinalTranscriptRef.current = final;
-                lastFinalTextRef.current = { text: trimmedFinal, at: now };
+              if (accumulated !== prevText || now - prevAt > 500) {
+                lastFinalTextRef.current = { text: accumulated, at: now };
               }
+              // FIX #17 (A) — Sarvam fallback transcript is the ACCUMULATED
+              // text (all finalized words this cycle), not last-session-only.
+              pttFinalTranscriptRef.current = accumulated;
             }
-            const display = (final + interim).trim();
+            const display = [accumulated, interim.trim()]
+              .filter(Boolean)
+              .join(" ")
+              .trim();
             // V4 FIX 4 — interim transcript flows into the input as a
             // transcript-sourced fragment so Backspace can word-erase.
             if (display) setInputFromTranscript(display);
@@ -1082,10 +1135,55 @@ export default function Page() {
               }, 200);
             }
           };
-          rec.onerror = () => { /* best-effort — Sarvam is the source of truth */ };
-          rec.onend = () => { /* nothing — recorder.onstop drives the submit */ };
+          // FIX #17 (A) — each recognition session restarts with a fresh
+          // `ev.results` list, so the per-session consumed cursor must reset
+          // to 0 at the start of every session (mirrors the hook resetting
+          // its session view on restart). The cross-session accumulator
+          // (pttFinalSegmentsRef) is NOT reset here — only on PTT-cycle start.
+          rec.onstart = () => { pttSessionFinalsConsumedRef.current = 0; };
+          rec.onerror = (ev: PTTSpeechRecognitionErrorEventLike) => {
+            // FIX #17 (B) — on a terminal permission/device error, stop
+            // wanting to run so the onend auto-restart + heartbeat don't
+            // fight a dead device. `no-speech` / `aborted` are routine in
+            // continuous=false restart mode — keep wanting, onend revives.
+            const code = ev.error;
+            if (code === "not-allowed" || code === "service-not-allowed" || code === "audio-capture") {
+              pttSrWantRunningRef.current = false;
+            }
+            /* otherwise best-effort — Sarvam remains the source of truth */
+          };
+          // FIX #17 (B) — continuous=false makes Web Speech END after the
+          // first ~1.5s pause. The old no-op onend meant recognition was
+          // NEVER restarted, so the live interim froze mid-utterance. Port
+          // useStreamingVoice's restart contract: only restart while we
+          // still WANT to be running; swallow InvalidStateError (already
+          // running) since the heartbeat covers genuinely-dead states.
+          rec.onend = () => {
+            if (!pttSrWantRunningRef.current) return;
+            try { rec.start(); } catch { /* InvalidState — heartbeat covers */ }
+          };
           pttRecognitionRef.current = rec;
+          // FIX #17 (B) — declare intent to be running BEFORE start() so a
+          // synchronous onend (some engines) sees want=true and restarts.
+          pttSrWantRunningRef.current = true;
           rec.start();
+          // FIX #17 (B) — KI-173-style 3s heartbeat. SpeechRecognition can
+          // enter a stopped state without onend firing (transient OS audio
+          // interruption, tab visibility edge cases); the onend restart
+          // never gets a chance to run and the mic stays silently dead.
+          // While we're recording AND still want SR running, re-issue
+          // start() unconditionally — InvalidStateError (already running)
+          // is swallowed, otherwise this revives the dead state.
+          if (pttSrHeartbeatRef.current !== null) {
+            clearInterval(pttSrHeartbeatRef.current);
+            pttSrHeartbeatRef.current = null;
+          }
+          pttSrHeartbeatRef.current = window.setInterval(() => {
+            if (!pttSrWantRunningRef.current) return;
+            const r = pttRecognitionRef.current;
+            if (!r) return;
+            try { r.start(); } catch { /* already running — fine */ }
+          }, 3000);
         }
       } catch {
         // SR unavailable or already running — fall through, Sarvam still works.
@@ -1099,11 +1197,26 @@ export default function Page() {
         // 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.
+        // FIX #17 (B) — stop WANTING recognition to run BEFORE abort() so
+        // the onend auto-restart (which fires on abort) and the heartbeat
+        // both no-op instead of reviving a recognition we're tearing down.
+        pttSrWantRunningRef.current = false;
+        if (pttSrHeartbeatRef.current !== null) {
+          clearInterval(pttSrHeartbeatRef.current);
+          pttSrHeartbeatRef.current = null;
+        }
         const sr = pttRecognitionRef.current;
         pttRecognitionRef.current = null;
         if (sr) {
           try { sr.abort(); } catch { /* already stopped */ }
         }
+        // FIX #17 (C) — trailing flush. The 200ms throttle only SCHEDULES a
+        // setPttInterim when no timer is pending; the last burst of words
+        // arriving while a timer is still pending (or right at release) was
+        // dropped because the block below clears it. Flush the latest value
+        // once more so the final spoken words are visible until the Sarvam
+        // authoritative transcript replaces them.
+        const lastInterim = pttInterimLatestRef.current;
         // V4 FIX 3 — atomically clear the interim ghost text (both the
         // pending throttled update AND any visible state). Without this,
         // the gray-italic strip below the mic can keep showing the last
@@ -1113,6 +1226,11 @@ export default function Page() {
           pttInterimTimerRef.current = null;
         }
         pttInterimLatestRef.current = "";
+        // FIX #17 (C) — push the last burst into the input as a
+        // transcript-sourced fragment (Backspace word-erase still works)
+        // so it isn't lost; it is replaced by the Sarvam authoritative
+        // text below the moment transcription completes.
+        if (lastInterim) setInputFromTranscript(lastInterim);
         setPttInterim("");
         const srFallback = pttFinalTranscriptRef.current.trim();
         const blob = new Blob(audioChunksRef.current, { type: recorder.mimeType || "audio/webm" });
@@ -1276,6 +1394,20 @@ export default function Page() {
       }
     } catch (e) {
       console.error(e);
+      // FIX #17 (B) — if we threw AFTER wiring up the parallel SR (e.g. the
+      // W2 `recorder.state !== "recording"` hard-fail), the SR + 3s
+      // heartbeat were already started. Stop wanting it, clear the
+      // heartbeat, and abort recognition so the mic doesn't stay silently
+      // alive behind a failed recorder.
+      pttSrWantRunningRef.current = false;
+      if (pttSrHeartbeatRef.current !== null) {
+        clearInterval(pttSrHeartbeatRef.current);
+        pttSrHeartbeatRef.current = null;
+      }
+      if (pttRecognitionRef.current) {
+        try { pttRecognitionRef.current.abort(); } catch { /* already stopped */ }
+        pttRecognitionRef.current = null;
+      }
       // 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
@@ -3358,6 +3490,15 @@ function parseInline(src: string): MdInlineToken[] {
   };
   while (i < src.length) {
     const rest = src.slice(i);
+    // FIX #22 — unescape the `\.` emitted by sanitizeStrayNumberedLines so
+    // a guarded sentence-final number renders as a normal "15." with no
+    // visible backslash. Scoped to `\.` only (the single escape we emit)
+    // so we don't accidentally swallow legitimate backslashes elsewhere.
+    if (rest.startsWith("\\.")) {
+      buf += ".";
+      i += 2;
+      continue;
+    }
     // Links: [label](http(s)://… or relative). Only http/https/mailto or
     // root-relative hrefs are kept; anything else (javascript:, data:) is
     // rendered as plain text so there's no injection vector.
@@ -3442,6 +3583,82 @@ function renderInline(tokens: MdInlineToken[], keyPrefix: string): React.ReactNo
   });
 }
 
+// FIX #22 — sentence-final number guard. A bot reply like
+//   "...complaints per 10,000 policies are low at 15. Niva Bupa is..."
+// has "15." followed by whitespace + more prose. parseBlocks' run-on
+// splitter (`/\s(?=\d{1,2}\.\s)/ → "\n"`) turns the space before "15."
+// into a hard break, then the ol matcher `/^(\d{1,2})[.)]\s+/` renders
+// it as `<ol start=15>` — breaking the sentence into a bogus list item
+// ("15." / "43." / "52." were the live repros).
+//
+// A GENUINE recommendation list is small sequential numbers (1, 2, 3)
+// each at the START of its own line / preceded by blank or list context.
+// So the SAFE rule: a number is NOT an intended list marker when EITHER
+//   (a) the number is >= 10  (recommendation lists never start at 10+;
+//       they enumerate 1,2,3…), OR
+//   (b) it appears MID-LINE after sentence prose (text precedes it on the
+//       same physical line) — that is unambiguously a sentence wrapping.
+// In those cases we escape the dot as `\.` so neither the run-on splitter
+// nor the ol matcher fires; renderInline unescapes `\.`→`.` so the user
+// still sees a normal "15." with no backslash. Single small digits at a
+// real line start (a true "1. …" / "2. …" list) are left untouched.
+function sanitizeStrayNumberedLines(src: string): string {
+  // Walk physical lines so we never touch a number that legitimately
+  // starts its own line as item 1..9 of a real list.
+  const lines = src.replace(/\r\n?/g, "\n").split("\n");
+  const isListLine = (s: string) =>
+    /^\s*(\d+)[.)]\s+/.test(s) || /^\s*[-*•]\s+/.test(s);
+  let prevNonEmpty = "";
+  // A run-on list the model streamed on ONE physical line looks like
+  // "...: 1. A 2. B 3. C" — small SEQUENTIAL numbers. parseBlocks already
+  // splits those into a real <ol> via its `/\s(?=\d{1,2}\.\s)/→"\n"` rule,
+  // so we must NOT escape them. We treat a line as a run-on list when it
+  // contains a "1." AND a "2." marker (sequential small markers); only
+  // then do we leave its small-number dots alone.
+  const looksLikeRunOnList = (s: string) =>
+    /(^|\s)1\.\s/.test(s) && /(^|\s)2\.\s/.test(s);
+  return lines
+    .map((rawLine) => {
+      const runOn = looksLikeRunOnList(rawLine);
+      // (b) MID-LINE: a "<digits>. " with non-space text before it on the
+      // same line is a wrapped sentence ("...are low at 15. Niva..."),
+      // NOT a list. Escape it so the run-on splitter + ol matcher skip it.
+      // Scope: numbers >= 10 are ALWAYS a wrapped sentence here (a real
+      // list never enumerates a bare 10+ mid-line); numbers 1-9 are only
+      // escaped when the line is NOT a streamed run-on list (so a genuine
+      // "Options: 1. A 2. B 3. C" still becomes a real <ol>). Negative
+      // lookbehind for `\` so we don't double-escape on a re-run.
+      let out = rawLine.replace(
+        /(\S[^\n]*?)(?<!\\)\b(\d+)\.(\s)/g,
+        (_m, pre: string, num: string, ws: string) => {
+          const n = parseInt(num, 10);
+          if (n >= 10) return `${pre}${num}\\.${ws}`;
+          if (runOn) return _m; // genuine streamed list marker — keep
+          return `${pre}${num}\\.${ws}`;
+        },
+      );
+      // (a) LINE-START with a number >= 10 (e.g. a hard-wrapped "15." that
+      // landed at column 0 after the model wrapped a sentence). A real
+      // recommendation list enumerates 1,2,3… so it only reaches 10+ when
+      // the IMMEDIATELY-PRECEDING non-empty line is itself a list item
+      // (a genuine long list). If the previous line is prose / blank /
+      // absent, a leading 10+ is a wrapped sentence number → escape it.
+      // Small line-start digits (1-9) are always left as a real list.
+      out = out.replace(
+        /^(\s*)(\d+)\.(\s)/,
+        (m, lead: string, num: string, ws: string) => {
+          const n = parseInt(num, 10);
+          if (n < 10) return m; // genuine list item 1..9 — never touch
+          const prevIsListContext = isListLine(prevNonEmpty);
+          return prevIsListContext ? m : `${lead}${num}\\.${ws}`;
+        },
+      );
+      if (rawLine.trim()) prevNonEmpty = rawLine;
+      return out;
+    })
+    .join("\n");
+}
+
 // Block-level grouping: paragraphs, ordered lists, unordered lists,
 // headings. Consecutive list lines coalesce into one <ol>/<ul> so a
 // "1. … 2. … 3. …" run renders as a real numbered list, not a wall.
@@ -3452,10 +3669,15 @@ type MdBlock =
   | { t: "h"; level: number; text: string };
 
 function parseBlocks(src: string): MdBlock[] {
+  // FIX #22 — neutralise sentence-final / wrapped numbers ("...at 15.")
+  // BEFORE the run-on splitter below converts the space before them into a
+  // hard break and the ol matcher list-ifies them. Genuine 1./2./3.
+  // recommendation lists are untouched (see sanitizeStrayNumberedLines).
+  const guarded = sanitizeStrayNumberedLines(src);
   // Normalise newlines; also break a run-on "1. a 2. b 3. c" that arrived
   // on a single physical line into separate list lines so it still renders
   // as an ordered list (the model sometimes streams without hard breaks).
-  const normalised = src
+  const normalised = guarded
     .replace(/\r\n?/g, "\n")
     .replace(/\s(?=\d{1,2}\.\s)/g, "\n")
     .replace(/\s(?=[•]\s)/g, "\n");
@@ -3763,6 +3985,145 @@ function gradeColor(grade: string): string {
   return map[grade] || "bg-stone-400 text-white";
 }
 
+// FIX #21 — Reviews / claim-settlement cell for the in-chat COMPARE modal.
+// The compare modal previously showed POLICY DETAILS + premium but NO
+// reviews; the earlier Bug-3 fix only added the inline-card "Reviews:"
+// line. This cell is wired into PolicyCompareModal via renderReviewsFor
+// and reuses the SAME getInsurerReviews fetch + fields as the inline card
+// (letter_grade / value_0_100 / claim_settlement_ratio_pct / headline) so
+// the two surfaces stay consistent. Keyed per insurer_slug; one fetch per
+// column. ALWAYS renders a labelled state — loading / compiled / data —
+// never silently vanishes (#76 rule).
+function CompareReviewsCell({ insurerSlug }: { insurerSlug: string }) {
+  // Keyed-by-slug result map (mirrors CitedPolicyCards' `reviews[slug]`
+  // pattern, which is the lint-clean shape used elsewhere in this file):
+  // the effect ONLY calls the setter from inside the async .then/.catch
+  // callbacks — never synchronously in the effect body — so it does not
+  // trip `react-hooks/set-state-in-effect`. The displayed state for the
+  // current slug is derived from the map at render time.
+  const [byslug, setBySlug] = useState<
+    Record<string, InsurerReviews | null>
+  >({});
+  useEffect(() => {
+    let alive = true;
+    if (!insurerSlug) return;
+    if (insurerSlug in byslug) return;
+    getInsurerReviews(insurerSlug)
+      .then((r) => {
+        if (alive) setBySlug((p) => ({ ...p, [insurerSlug]: r }));
+      })
+      .catch(() => {
+        if (alive) setBySlug((p) => ({ ...p, [insurerSlug]: null }));
+      });
+    return () => {
+      alive = false;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [insurerSlug]);
+
+  // undefined → not yet fetched (loading); null → fetched-but-empty;
+  // object → data. Empty slug is treated as null (graceful missing).
+  const rv: InsurerReviews | null | undefined = !insurerSlug
+    ? null
+    : insurerSlug in byslug
+      ? byslug[insurerSlug]
+      : undefined;
+
+  if (rv === undefined) {
+    return (
+      <div
+        style={{
+          fontSize: 12,
+          color: "var(--muted-foreground)",
+          fontStyle: "italic",
+        }}
+      >
+        Loading insurer reputation…
+      </div>
+    );
+  }
+  if (rv === null) {
+    return (
+      <div
+        style={{
+          fontSize: 12,
+          color: "var(--muted-foreground)",
+          fontStyle: "italic",
+        }}
+      >
+        Reputation data being compiled for this insurer.
+      </div>
+    );
+  }
+  const s = rv.aggregate_score || {};
+  const cm = rv.claim_metrics || {};
+  const csr = cm.claim_settlement_ratio_pct;
+  const bits: string[] = [];
+  if (s.letter_grade) bits.push(s.letter_grade);
+  if (s.value_0_100 != null) bits.push(`${s.value_0_100}/100`);
+  if (csr != null) bits.push(`${csr}% claims settled`);
+  // If the reviews payload came back but every headline metric is empty,
+  // still say so explicitly rather than rendering a blank box.
+  if (bits.length === 0 && !s.headline) {
+    return (
+      <div
+        style={{
+          fontSize: 12,
+          color: "var(--muted-foreground)",
+          fontStyle: "italic",
+        }}
+      >
+        No published reputation metrics for this insurer yet.
+      </div>
+    );
+  }
+  return (
+    <div style={{ fontSize: 12.5, lineHeight: 1.5, color: "var(--foreground)" }}>
+      {bits.length > 0 && (
+        <div style={{ fontWeight: 600 }}>{bits.join(" · ")}</div>
+      )}
+      {s.headline && (
+        <div
+          style={{
+            marginTop: bits.length > 0 ? 4 : 0,
+            color: "var(--muted-foreground)",
+          }}
+        >
+          {s.headline}
+        </div>
+      )}
+      {csr != null && cm.claim_settlement_ratio_year && (
+        <div
+          style={{
+            marginTop: 4,
+            fontSize: 11,
+            color: "var(--muted-foreground)",
+          }}
+        >
+          Claim settlement ratio · FY {cm.claim_settlement_ratio_year}
+          {cm.source_irdai_url ? (
+            <>
+              {" · "}
+              <a
+                href={cm.source_irdai_url}
+                target="_blank"
+                rel="noopener noreferrer"
+                style={{
+                  color: "var(--primary)",
+                  textDecoration: "underline",
+                  textUnderlineOffset: 2,
+                }}
+              >
+                IRDAI source
+              </a>
+            </>
+          ) : null}
+        </div>
+      )}
+    </div>
+  );
+}
+
 // CitedPolicyCards — structured per-policy cards rendered BELOW the
 // assistant's prose reply. One card per cited policy with insurer logo,
 // policy name, scorecard grade + one-liner, source-PDF link, and a
@@ -4074,6 +4435,9 @@ function CitedPolicyCards({
               profile={scorecardProfile}
             />
           )}
+          renderReviewsFor={(insurerSlug) => (
+            <CompareReviewsCell insurerSlug={insurerSlug} />
+          )}
           onOpenMarketplace={onOpenMarketplace}
         />
       )}

frontend/src/components/PolicyCompareModal.tsx

@@ -233,6 +233,14 @@ export type PolicyCompareModalProps = {
   // B2 + B3 plug points. Both are optional; safe fallbacks render below.
   renderPremiumFor?: (policyId: string, policyName: string) => ReactNode;
   renderScorecardFor?: (policyId: string, policyName: string) => ReactNode;
+  // FIX #21 — insurer reviews / claim-settlement plug point, keyed by the
+  // citation's insurer_slug (reviews are per-insurer, not per-policy). The
+  // inline cited cards + the full detail modal both show a reviews section;
+  // this compare modal previously did NOT (user-flagged: "no Reviews /
+  // claim-settlement section here"). Optional — when unwired, a graceful
+  // "reputation data unavailable" line renders so the section never
+  // silently vanishes.
+  renderReviewsFor?: (insurerSlug: string) => ReactNode;
   // Profile hint for downstream personalized widgets (unused by the shell
   // itself; pass-through so widgets opened via renderXxxFor can read it).
   // Typed loosely (any) by contract; harness should narrow when wiring.
@@ -259,6 +267,7 @@ export default function PolicyCompareModal({
   onClose,
   renderPremiumFor,
   renderScorecardFor,
+  renderReviewsFor,
   profile: _profile,
   policyDataFor,
   onOpenMarketplace,
@@ -436,6 +445,7 @@ export default function PolicyCompareModal({
                     c.policy_id,
                     c.policy_name,
                   )}
+                  reviewsSlot={renderReviewsFor?.(c.insurer_slug)}
                   marketplacePolicy={policyDataFor?.(c.policy_id, c.policy_name)}
                   profile={_profile as SnapProfile}
                 />
@@ -489,12 +499,14 @@ function CompareColumn({
   citation,
   premiumSlot,
   scorecardSlot,
+  reviewsSlot,
   marketplacePolicy,
   profile,
 }: {
   citation: Citation;
   premiumSlot?: ReactNode;
   scorecardSlot?: ReactNode;
+  reviewsSlot?: ReactNode;
   marketplacePolicy?: MarketplacePolicy;
   profile?: SnapProfile;
 }) {
@@ -678,6 +690,19 @@ function CompareColumn({
         {premiumSlot ?? <PlaceholderWidget label="Premium calculator coming soon" />}
       </Section>
 
+      {/* FIX #21 — REVIEWS & CLAIM SETTLEMENT. The inline cited cards + the
+          full marketplace detail modal both surface insurer reputation /
+          claim-settlement; this compare modal omitted it (user-flagged).
+          The slot reuses the SAME getInsurerReviews fetch + fields as the
+          inline "Reviews:" line. Always render the Section so every column
+          carries it in the SAME position; the slot itself owns its
+          loading / missing state ("never silently vanish"). */}
+      <Section title="Reviews & claim settlement">
+        {reviewsSlot ?? (
+          <PlaceholderWidget label="Insurer reputation data unavailable" />
+        )}
+      </Section>
+
       {/* POLICY DETAILS expandable */}
       <PolicyDetails citation={citation} policy={marketplacePolicy} />
     </div>

tests/test_bug24_display_name_cleanup.py

@@ -0,0 +1,166 @@
+"""BUG #24 — user-facing policy_name cleanup for the HDFC ERGO Optima family.
+
+SYMPTOM
+-------
+A policy card / chat prose showed the product name
+`my:Optima Secure (older variant)` (insurer "HDFC ERGO"). The lowercase
+`my:` prefix reads as a typo / formatting error to users. The official
+product is "Optima Secure"; the "(older variant)" suffix is an INTENTIONAL
+KI-145 dedup disambiguator (1 IRDAI UIN = 1 marketplace card) that MUST be
+preserved.
+
+FIX
+---
+`backend.policy_identity.clean_display_policy_name()` — a small, central,
+display-only normaliser applied at every user-facing surface that emits a
+policy_name (marketplace card pass-1/pass-2 + aliases, /api/coverage
+sample names, chat citations, retrieve_policies chunks, get_policy_facts,
+build_scorecard → compare / single & bulk scorecard).
+
+INVARIANTS THIS LOCKS DOWN
+--------------------------
+1. The cleaned display name for the older-variant product is
+   "Optima Secure (older variant)" — no "my:", no duplicated "HDFC ERGO "
+   insurer label (the insurer is shown separately on the card), and the
+   "(older variant)" disambiguator is kept verbatim.
+2. TARGETED, NOT a blanket `my:` strip — `my:health Suraksha` and the
+   rest of HDFC ERGO's legitimate `my:health …` brand family are
+   returned UNCHANGED.
+3. Display-only — `policy_id`, normalised UIN, `product_key` and
+   `canonical_key` (KI-145 dedup identity) are NEVER derived from the
+   cleaned name, so policy_id resolution + 1-UIN-1-card dedup still work
+   exactly as before and the newer vs older Optima Secure siblings stay
+   two distinct cards.
+"""
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+from backend.policy_identity import (  # noqa: E402
+    canonical_key,
+    clean_display_policy_name,
+    normalize_uin,
+    product_key,
+)
+
+# The product at the centre of BUG #24.
+_OLD_VARIANT_PID = "hdfc-ergo__my-optima-secure-older-variant__wordings"
+_OLD_VARIANT_UIN = "HDFHLIP21016V012122"
+_NEW_PID = "hdfc-ergo__optima-secure"
+_NEW_UIN = "HDFHLIP25041V062425"
+
+
+class TestDisplayNameCleanup(unittest.TestCase):
+    # ---- the BUG is fixed -------------------------------------------------
+    def test_older_variant_my_prefix_removed_disambiguator_kept(self):
+        self.assertEqual(
+            clean_display_policy_name("my:Optima Secure (older variant)"),
+            "Optima Secure (older variant)",
+        )
+
+    def test_plain_my_optima_secure_cleaned(self):
+        self.assertEqual(
+            clean_display_policy_name("my:Optima Secure"),
+            "Optima Secure",
+        )
+
+    def test_duplicated_insurer_label_stripped(self):
+        # The card shows the insurer ("HDFC ERGO") separately, so the name
+        # must not duplicate it.
+        self.assertEqual(
+            clean_display_policy_name("HDFC ERGO my:Optima Secure"),
+            "Optima Secure",
+        )
+        self.assertEqual(
+            clean_display_policy_name(
+                "HDFC ERGO Optima Secure (Older / Legacy Variant)"
+            ),
+            "Optima Secure (Older / Legacy Variant)",
+        )
+
+    def test_no_lowercase_my_colon_remains_for_optima_family(self):
+        for raw in (
+            "my:Optima Secure (older variant)",
+            "my:Optima Secure",
+            "HDFC ERGO my:Optima Secure",
+        ):
+            self.assertNotIn("my:", clean_display_policy_name(raw))
+
+    # ---- TARGETED: my:health family is LEGITIMATE and untouched ----------
+    def test_my_health_family_is_NOT_altered(self):
+        legit = [
+            "my:health Suraksha",
+            "my:health Medisure Prime",
+            "my:health Sampoorna Suraksha",
+            "my:health Women Suraksha",
+            "my:health Medisure Prime Insurance",
+            "HDFC ERGO my:health Suraksha",  # not Optima → prefix stays
+        ]
+        for name in legit:
+            self.assertEqual(
+                clean_display_policy_name(name),
+                name,
+                f"legitimate HDFC ERGO brand name altered: {name!r}",
+            )
+
+    # ---- conservative / idempotent --------------------------------------
+    def test_already_clean_and_other_products_unchanged(self):
+        for name in (
+            "Optima Secure (older variant)",  # already clean
+            "Optima Restore",
+            "Optima Plus",
+            "Optima Enhance",
+            "Star Family Health Optima",
+            "Activ Secure - Cancer Secure",
+        ):
+            self.assertEqual(clean_display_policy_name(name), name)
+
+    def test_idempotent(self):
+        once = clean_display_policy_name("HDFC ERGO my:Optima Secure")
+        self.assertEqual(clean_display_policy_name(once), once)
+
+    def test_non_string_safe(self):
+        self.assertEqual(clean_display_policy_name(None), "")
+        self.assertEqual(clean_display_policy_name(123), 123)
+
+    # ---- HARD CONSTRAINT: identity / dedup UNCHANGED --------------------
+    def test_policy_id_uin_dedup_unchanged_by_display_cleanup(self):
+        chunk = {
+            "policy_id": _OLD_VARIANT_PID,
+            "policy_name": "my:Optima Secure (older variant)",
+            "uin_code": _OLD_VARIANT_UIN,
+        }
+        cleaned = dict(chunk)
+        cleaned["policy_name"] = clean_display_policy_name(
+            chunk["policy_name"]
+        )
+
+        # Dedup key is derived from UIN / policy_id, never from the name.
+        self.assertEqual(canonical_key(chunk), canonical_key(cleaned))
+        self.assertEqual(
+            canonical_key(cleaned), f"uin:{_OLD_VARIANT_UIN}"
+        )
+        self.assertEqual(
+            product_key(chunk["policy_id"]),
+            product_key(cleaned["policy_id"]),
+        )
+        self.assertEqual(
+            normalize_uin(chunk["uin_code"]), _OLD_VARIANT_UIN
+        )
+
+    def test_ki145_two_cards_preserved(self):
+        # The newer "Optima Secure" and the "(older variant)" have
+        # DIFFERENT UINs → KI-145 must keep them as two distinct cards.
+        newer = {"policy_id": _NEW_PID, "uin_code": _NEW_UIN}
+        older = {"policy_id": _OLD_VARIANT_PID, "uin_code": _OLD_VARIANT_UIN}
+        self.assertNotEqual(canonical_key(newer), canonical_key(older))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_get_policy_facts_grounding.py

@@ -0,0 +1,228 @@
+"""FIX #23 (2026-05-19) — faithfulness guard false "could not verify UIN"
+on get_policy_facts answers (REGRESSION from the get_policy_facts tool).
+
+SYMPTOM: a correct contextual comparison / recommendation that used
+`get_policy_facts` ended with:
+
+    "⚠️ One or more policy identifiers above could not be verified against
+     our records — please confirm the UIN with the insurer before relying
+     on it."
+
+…even though the answer was grounded.
+
+ROOT: `single_brain._verify_prose_grounding(reply_text,
+retrieved_chunks_all)` only treated `retrieve_policies` chunks as grounding.
+`get_policy_facts` returns
+`{"ok": True, "policies": [{policy_id, policy_name, insurer_slug, ...}]}`
+but those policies were NEVER appended to `retrieved_chunks_all`, so a
+policy NAME / UIN the model legitimately stated FROM get_policy_facts
+tripped the no-invented-numbers / UIN guard.
+
+FIX: in `handle_turn`'s `_execute_tool` loop, when the executed tool is
+`get_policy_facts` and `ok` is True, append each returned policy as a
+synthetic grounding entry into `retrieved_chunks_all`, mirroring the
+retrieve_policies chunk shape ({policy_id, policy_name, insurer_slug,
+uin_code, source_url, chunk_text}). The guard is NOT weakened for
+genuinely ungrounded names.
+
+These tests stub the two network seams (single_brain._gemini_call and
+brain_tools.get_policy_facts) and drive the real handle_turn so the
+grounding verifier runs for real.
+
+Run:
+    .venv/bin/python -m pytest -q tests/test_get_policy_facts_grounding.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import unittest
+import uuid
+from pathlib import Path
+from unittest import mock
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+from backend import brain_tools, single_brain  # noqa: E402
+
+# The exact transparency caveat handle_turn appends when
+# _verify_prose_grounding fails — the string this regression must NOT see
+# on a grounded get_policy_facts answer.
+_CAVEAT = "could not be verified against our records"
+
+# A UIN that matches single_brain._verify_prose_grounding's regex
+# (\b[A-Z]{3,}[A-Z0-9]{2,}V\d{5,7}\b) — i.e. the exact fabrication-class
+# string the guard flags when it is NOT present in any grounding entry.
+_UIN = "MAXHLIP21177V032122"
+
+
+def _run(coro):
+    return asyncio.new_event_loop().run_until_complete(coro)
+
+
+def _fc_part(name, args):
+    return {"functionCall": {"name": name, "args": args}}
+
+
+def _text_payload(text):
+    return {"candidates": [{"content": {"parts": [{"text": text}]}}]}
+
+
+def _tool_payload(parts):
+    return {"candidates": [{"content": {"parts": parts}}]}
+
+
+class _Harness(unittest.TestCase):
+    """Drives single_brain.handle_turn with _gemini_call scripted and
+    brain_tools.get_policy_facts stubbed to a deterministic payload."""
+
+    def setUp(self):
+        self._env = mock.patch.dict(
+            os.environ, {"GOOGLE_API_KEY": "test-key"}
+        )
+        self._env.start()
+        self._gemini_script: list = []
+        self._gpf_result: dict = {}
+
+        async def _fake_gemini(*_a, **_k):
+            if not self._gemini_script:
+                return _text_payload("(no more scripted turns)")
+            return self._gemini_script.pop(0)
+
+        def _fake_gpf(_session, policy_ids=None):
+            return self._gpf_result
+
+        self._gp = mock.patch.object(
+            single_brain, "_gemini_call", _fake_gemini
+        )
+        self._gpf = mock.patch.object(
+            brain_tools, "get_policy_facts", _fake_gpf
+        )
+        self._gp.start()
+        self._gpf.start()
+
+    def tearDown(self):
+        self._gpf.stop()
+        self._gp.stop()
+        self._env.stop()
+
+    def _session(self):
+        from backend.session_state import SessionState
+
+        return SessionState(session_id=f"t_{uuid.uuid4().hex[:8]}")
+
+
+class TestGetPolicyFactsGrounding(_Harness):
+    def test_named_policy_from_get_policy_facts_is_not_falsely_flagged(self):
+        """The model calls get_policy_facts, then names that policy AND
+        states its UIN in prose. Pre-FIX #23 the UIN was ungrounded (the
+        get_policy_facts policy was never in retrieved_chunks_all) → the
+        false ⚠️ caveat. Post-fix the policy is registered as grounding →
+        NO caveat."""
+        sess = self._session()
+        self._gpf_result = {
+            "ok": True,
+            "count": 1,
+            "policies": [
+                {
+                    "policy_id": "niva-bupa__reassure-3",
+                    "policy_name": "Niva Bupa ReAssure 3.0",
+                    "insurer_slug": "niva-bupa",
+                    "insurer_name": "Niva Bupa",
+                    "uin_code": _UIN,
+                    "claim_settlement_ratio_pct": 91.4,
+                    "complaints_per_10k_policies": 5.2,
+                    "scorecard_grade": "A",
+                    "claim_data_source_url": "https://irdai.gov.in/x",
+                }
+            ],
+        }
+        self._gemini_script = [
+            _tool_payload(
+                [
+                    _fc_part(
+                        "get_policy_facts",
+                        {"policy_ids": ["niva-bupa__reassure-3"]},
+                    )
+                ]
+            ),
+            _text_payload(
+                "Niva Bupa ReAssure 3.0 (UIN " + _UIN + ") has a strong "
+                "91.4% claim-settlement ratio and low complaints — a solid "
+                "pick on claim record."
+            ),
+        ]
+
+        r = _run(
+            single_brain.handle_turn(
+                sess, "How good is the ReAssure plan's claim record?"
+            )
+        )
+
+        self.assertNotIn(
+            _CAVEAT,
+            r.reply_text,
+            "grounded get_policy_facts answer must NOT get the false "
+            "'could not be verified' caveat",
+        )
+        self.assertTrue(
+            r.faithfulness_passed,
+            "faithfulness_passed must be True for a grounded "
+            "get_policy_facts answer",
+        )
+        self.assertIn("ReAssure 3.0", r.reply_text)
+
+    def test_guard_still_flags_a_genuinely_ungrounded_uin(self):
+        """Control: FIX #23 must NOT weaken the guard. A UIN that
+        get_policy_facts did NOT return (and no retrieve_policies chunk
+        supports) must STILL trip the caveat."""
+        sess = self._session()
+        # get_policy_facts returns policy A with its own UIN…
+        self._gpf_result = {
+            "ok": True,
+            "count": 1,
+            "policies": [
+                {
+                    "policy_id": "care__supreme",
+                    "policy_name": "Care Supreme",
+                    "insurer_slug": "care",
+                    "uin_code": "CARHLIP21001V010001",
+                    "claim_settlement_ratio_pct": 88.0,
+                }
+            ],
+        }
+        # …but the model invents a DIFFERENT, unreturned UIN in prose.
+        self._gemini_script = [
+            _tool_payload(
+                [
+                    _fc_part(
+                        "get_policy_facts",
+                        {"policy_ids": ["care__supreme"]},
+                    )
+                ]
+            ),
+            _text_payload(
+                "Care Supreme is great; also see plan UIN " + _UIN + " "
+                "which I recommend."
+            ),
+        ]
+
+        r = _run(
+            single_brain.handle_turn(sess, "Tell me about Care Supreme.")
+        )
+
+        self.assertIn(
+            _CAVEAT,
+            r.reply_text,
+            "a UIN that get_policy_facts did NOT return must still be "
+            "flagged — the guard must not be weakened",
+        )
+        self.assertFalse(r.faithfulness_passed)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_tts_full_natural_readout.py

@@ -209,17 +209,32 @@ class _FakeResp:
 
 
 class _FakeClient:
-    """Fake Sarvam TTS endpoint.
-
-    Records every chunk it is asked to synthesize and returns a WAV whose
-    frame count == len(text) so the concatenated audio length is a direct
-    proxy for 'how many characters were actually voiced'. Also asserts no
-    single request exceeds Bulbul v2's hard 1500-char limit — a regression
-    to single-shot (whole message in one call) fails LOUDLY here.
+    """Fake Sarvam TTS endpoint that simulates REAL Bulbul v2 behaviour.
+
+    Records every chunk it is asked to synthesize. Returns a WAV whose
+    frame count == len(voiced text) so the concatenated audio length is a
+    direct proxy for 'how many characters were actually voiced'.
+
+    BUG #19 fidelity: Sarvam v2 does NOT 4xx on an over-limit request — it
+    returns HTTP 200 and voices ONLY THE FIRST SENTENCE of anything past
+    its real (small) per-request limit (the operative limit is far below
+    the 1500-char documented cap). This mirrors the STT test's hard-limit
+    simulation (tests/test_stt_long_audio_chunking.py SARVAM_HARD_LIMIT_MS).
+    So the fix MUST keep every single request at/under the effective
+    ceiling; if it doesn't, the audio frames here collapse to the first
+    sentence and the full-readout assertions fail LOUDLY.
     """
 
     sent_texts: list[str] = []
-    HARD_LIMIT = 1500
+    # The operative single-request limit. Anything longer is silently
+    # voiced as ONLY its first sentence (HTTP 200, partial audio).
+    EFFECTIVE_LIMIT = _tts_char_ceiling("bulbul:v2")
+    # Frames synthesized per voiced char. Picked > 0.030 * 22050 (= 661.5)
+    # so a FULLY-voiced chunk clears the provider's ~30ms/char truncation
+    # guard, while a first-sentence-only (silently truncated) chunk stays
+    # confidently under it and the guard fires LOUDLY — matching real
+    # Sarvam audio density (~45ms/char here).
+    FRAMES_PER_CHAR = 1000
 
     def __init__(self, *a, **k):
         pass
@@ -232,12 +247,15 @@ class _FakeClient:
 
     async def post(self, url, headers=None, json=None, **k):
         text = json["text"]
-        assert len(text) <= self.HARD_LIMIT, (
-            f"chunk of {len(text)} chars exceeds Sarvam Bulbul v2's "
-            f"1500-char hard limit — would be silently truncated"
-        )
         _FakeClient.sent_texts.append(text)
-        wav = _make_wav(max(1, len(text)))
+        # Simulate Sarvam's silent first-sentence truncation: anything past
+        # the effective limit is voiced ONLY up to its first sentence end.
+        if len(text) > self.EFFECTIVE_LIMIT:
+            m = re.search(r"[.!?]\s", text)
+            voiced = text[: m.end()] if m else text[: self.EFFECTIVE_LIMIT]
+        else:
+            voiced = text
+        wav = _make_wav(max(1, len(voiced)) * self.FRAMES_PER_CHAR)
         return _FakeResp({"audios": [base64.b64encode(wav).decode()]})
 
 
@@ -311,21 +329,123 @@ def test_end_to_end_overlong_message_chunks_and_concatenates(patch_httpx):
     assert re.sub(r"\s+", "", " ".join(_FakeClient.sent_texts)) == re.sub(
         r"\s+", "", spoken
     )
-    # Gapless concatenated WAV: frames == sum of per-chunk frames.
+    # Gapless concatenated WAV: frames == sum of per-chunk frames (each
+    # chunk is <= the effective ceiling so it is FULLY voiced — the fake
+    # synthesizes FRAMES_PER_CHAR frames per voiced char).
     with wave.open(io.BytesIO(audio), "rb") as w:
         total = w.getnframes()
-    assert total == sum(len(t) for t in _FakeClient.sent_texts)
+    assert total == sum(
+        len(t) * _FakeClient.FRAMES_PER_CHAR for t in _FakeClient.sent_texts
+    )
 
 
 def test_short_reply_is_single_call_unchanged(patch_httpx):
-    """A sub-ceiling reply must take exactly ONE Sarvam call (no behaviour
-    change / no extra latency for the common case)."""
+    """A genuinely short (<~300 char) reply must take exactly ONE Sarvam
+    call (no behaviour change / no extra latency for the common case)."""
     spoken = tts_preprocess("Yes, that policy covers day-care procedures.")
+    assert len(spoken) < 300, len(spoken)
     tts = SarvamTTS()
     asyncio.run(tts.synthesize_with_mime(spoken, language_code="en-IN"))
     assert len(_FakeClient.sent_texts) == 1, _FakeClient.sent_texts
 
 
+# ---------------------------------------------------------------------------
+# BUG #19 (2026-05-19) — the LIVE symptom: a ~700-char recommendation reply
+# (preamble + 3 numbered policies + smoker caveat + closing question) was
+# voiced as ONLY its first sentence ("Thanks for providing all those
+# details, Rohit!", ~2s) because the code's 1500-char ceiling kept the
+# sentence-seam chunker from EVER engaging on a normal reply. With v2's
+# ceiling at 500 (effective ~300) it now splits into 2-3 chunks, each
+# fully voiced and concatenated.
+#
+# This test FAILS against the old 1500 ceiling: the whole 700-char reply
+# would be sent in ONE call, the fake (mirroring real Sarvam) voices only
+# its first sentence, and (a) the per-chunk truncation guard in
+# _synthesize_one raises, OR (b) the concatenated frame count collapses to
+# the first sentence. It PASSES after change #1 (ceiling -> 500).
+# ---------------------------------------------------------------------------
+RECOMMENDATION_REPLY = (
+    "Thanks for providing all those details, Rohit! Here are three plans "
+    "that fit a non-smoker wanting comprehensive family floater cover.\n"
+    "1. HDFC ERGO Optima Secure: a base cover that doubles from year two, "
+    "with no room-rent cap and day-one cover for day-care procedures.\n"
+    "2. Care Supreme by Care Health: an unlimited automatic recharge, a "
+    "no-claim bonus, and worldwide emergency cover.\n"
+    "3. Niva Bupa ReAssure: a lock-the-clock feature that freezes your "
+    "entry age for pricing, plus a forever refill benefit.\n"
+    "One caveat: if you ever take up smoking or tobacco, declare it at "
+    "renewal, since a non-disclosure can void a future claim. "
+    "Would you like me to compare the maternity and OPD add-ons across "
+    "these three so you can pick the best fit for your family?"
+)
+
+
+def test_bug19_recommendation_reply_synthesized_in_full(patch_httpx):
+    """A realistic ~700-char recommendation reply must be voiced IN FULL:
+    >1 chunk, each <= the effective v2 ceiling, the decoded PCM
+    concatenated to ~full length, and the 3rd policy name + closing
+    question reaching Sarvam. This is RED against the old 1500 ceiling
+    (single over-limit call -> first-sentence-only audio / guard raises)
+    and GREEN after change #1."""
+    spoken = tts_preprocess(RECOMMENDATION_REPLY, language="en")
+    # Realistic recommendation length band (the live symptom was 370-720
+    # chars). Critically it is WELL under the OLD 1500 ceiling, so the
+    # pre-fix code sent it in ONE over-real-limit call -> first-sentence
+    # only audio. The first sentence is the exact ~2s clip the user heard.
+    assert 370 <= len(spoken) <= 760, len(spoken)
+    assert len(spoken) < 1500  # pre-fix code never chunked this reply
+
+    ceiling = _tts_char_ceiling("bulbul:v2")
+    assert ceiling < 1500  # the bug: old code never chunked under 1300
+
+    tts = SarvamTTS()
+    audio, mime = asyncio.run(
+        tts.synthesize_with_mime(spoken, language_code="en-IN")
+    )
+    assert mime == "audio/wav"
+
+    # The reply is split into MULTIPLE Sarvam calls (the bug sent ONE),
+    # each within the effective ceiling so the fake voices it in FULL.
+    assert len(_FakeClient.sent_texts) >= 2, _FakeClient.sent_texts
+    for t in _FakeClient.sent_texts:
+        assert len(t) <= ceiling, (
+            f"chunk of {len(t)} chars > effective ceiling {ceiling} — "
+            f"Sarvam would silently voice only its first sentence"
+        )
+
+    # Every char reached Sarvam (nothing dropped at the seams).
+    assert re.sub(r"\s+", "", " ".join(_FakeClient.sent_texts)) == re.sub(
+        r"\s+", "", spoken
+    )
+    # The 3rd policy name and the closing question — content the live bug
+    # NEVER voiced — must be present in the chunks actually sent.
+    joined_low = " ".join(_FakeClient.sent_texts).lower()
+    assert "niva bupa" in joined_low, _FakeClient.sent_texts
+    assert "reassure" in joined_low, _FakeClient.sent_texts
+    # "OPD" is expanded to "out-patient" by tts_preprocess; assert the
+    # closing-question content (the bug never voiced this) survived.
+    assert "maternity and out-patient" in joined_low, _FakeClient.sent_texts
+    assert "best fit for your family" in joined_low, _FakeClient.sent_texts
+
+    # The concatenated WAV is the FULL readout, not the ~2s first
+    # sentence: frames == sum of per-chunk fully-voiced frames, which is
+    # FAR above the first-sentence-only collapse the bug produced.
+    with wave.open(io.BytesIO(audio), "rb") as w:
+        total_frames = w.getnframes()
+    expected_frames = sum(
+        len(t) * _FakeClient.FRAMES_PER_CHAR for t in _FakeClient.sent_texts
+    )
+    assert total_frames == expected_frames, (total_frames, expected_frames)
+    first_sentence_frames = (
+        len(re.match(r"[^.!?]*[.!?]", spoken).group(0))
+        * _FakeClient.FRAMES_PER_CHAR
+    )
+    assert total_frames > 3 * first_sentence_frames, (
+        f"{total_frames} frames — collapsed toward the ~2s "
+        f"first-sentence-only clip the bug produced"
+    )
+
+
 def test_http_error_on_any_chunk_propagates_loudly(patch_httpx, monkeypatch):
     """No silent truncation: if any chunk's Sarvam call fails, the error
     propagates so the boundary classifier surfaces a real tts_error_code."""