fix(#55+#56+#53/#54-engine): TTS full natural readout + voice warm-stream/pre-roll

#55 TTS 10s truncation: voice_format._truncate_for_voice(max_words=55)
chopped every advisor reply to ~55 words (~10s) before it reached
Sarvam. Cap removed (max_words now ignored unless >=100000). Latent
Sarvam Bulbul v2 1500-char cap covered: sarvam_tts now char-ceiling
chunks at item/sentence/comma seams, synthesizes sequentially, gapless
WAV concat, propagates any chunk error (no silent partial) — STT-style.

#56 TTS normalization: _normalize_abbreviations + _normalize_ranges —
e.g./i.e./etc. spoken as words; '/' → 'or'; ₹/L/Cr/K/% and en-dash
ranges expanded; markdown/list numbering stripped. Verified on the exact
6-question pricing message (all 6 questions present, artifacts gone).

#53/#54 ENGINE: useStreamingVoice warm pre-armed mic + 800ms PreRollRing
+ 200ms deliberate-hold gate + beginPushToTalk/endPushToTalk/
consumePreRollChunks API. Keeps the OS mic hot so page.tsx getUserMedia
is ~10-50ms not 200-700ms (latency #54) and the first word is captured
(head-clip #53). page.tsx delegation wiring lands next (separate).

Full pytest gate green (rc=0; 226). tsc/build green (agent-verified).

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

backend/providers/sarvam_tts.py

@@ -20,7 +20,9 @@ from __future__ import annotations
 import base64
 import io
 import logging
-from typing import Optional, Tuple
+import re
+import wave
+from typing import List, Optional, Tuple
 
 import httpx
 
@@ -29,6 +31,187 @@ from backend.providers.base import TTSProvider
 
 logger = logging.getLogger(__name__)
 
+# ---------------------------------------------------------------------------
+# #55 — Sarvam Bulbul has a HARD per-request character limit:
+#   bulbul:v2 -> 1500 chars,  bulbul:v3 -> 2500 chars
+# (confirmed from https://docs.sarvam.ai text-to-speech reference).
+#
+# A long advisor reply (e.g. the 6-question pricing intake) exceeds 1500
+# chars once normalized. Sending it whole means Sarvam only voices the
+# leading slice — the exact "stopped in ten seconds" / questions 2-6 never
+# spoken symptom. So, mirroring the STT 30s-chunking house style in
+# providers/sarvam_stt.py, we split the text into <= TTS_CHUNK_CHARS
+# pieces at SENTENCE / NUMBERED-ITEM boundaries (so we never cut a word or
+# a question mid-way), synthesize each chunk sequentially, and concatenate
+# the decoded PCM into ONE gapless WAV returned to the caller. Any HTTP /
+# transport error on ANY chunk is raised LOUDLY (no silent truncation,
+# no partial-audio-with-HTTP-200).
+#
+# Ceiling is set below the documented cap so per-language preprocessing
+# expansion + minor jitter never pushes a chunk back over Sarvam's real
+# limit.
+_TTS_CHAR_LIMIT_BY_MODEL = {
+    "bulbul:v2": 1500,
+    "bulbul:v3": 2500,
+}
+_TTS_CHAR_LIMIT_DEFAULT = 1500  # safest assumption for unknown models
+_TTS_SAFETY_MARGIN = 200        # headroom under the documented hard cap
+
+
+def _tts_char_ceiling(model: str) -> int:
+    """Safe per-request char ceiling for the configured Bulbul model."""
+    hard = _TTS_CHAR_LIMIT_BY_MODEL.get(
+        (model or "").lower(), _TTS_CHAR_LIMIT_DEFAULT
+    )
+    return max(200, hard - _TTS_SAFETY_MARGIN)
+
+
+# Split points, longest-context first: paragraph break, then end-of-
+# sentence punctuation, then a numbered-list item boundary ("\n2. "),
+# then comma, then whitespace. We never split inside a word.
+_SENTENCE_BOUNDARY = re.compile(r"(?<=[.!?])\s+")
+_NUMBERED_ITEM = re.compile(r"(?=(?:^|\s)\d{1,2}[.)]\s)")
+
+
+def _hard_wrap(piece: str, limit: int) -> List[str]:
+    """Last-resort splitter for a single 'unit' longer than `limit`.
+
+    Splits on whitespace so a word is never cut; if a single token still
+    exceeds `limit` (pathological), it is hard-sliced so synthesis still
+    covers it rather than dropping it.
+    """
+    out: List[str] = []
+    cur = ""
+    for tok in piece.split(" "):
+        if not tok:
+            continue
+        cand = tok if not cur else f"{cur} {tok}"
+        if len(cand) <= limit:
+            cur = cand
+            continue
+        if cur:
+            out.append(cur)
+            cur = ""
+        if len(tok) <= limit:
+            cur = tok
+        else:
+            for i in range(0, len(tok), limit):
+                out.append(tok[i : i + limit])
+    if cur:
+        out.append(cur)
+    return out
+
+
+def _chunk_text_for_tts(text: str, limit: int) -> List[str]:
+    """Split `text` into <= `limit`-char chunks at natural speech seams.
+
+    Order of preference for a seam: sentence end -> numbered-list item ->
+    comma -> whitespace. A chunk is never cut mid-word, and a numbered
+    pricing question is never split across two synthesis calls unless it
+    is itself longer than `limit` (then it hard-wraps on whitespace).
+
+    The concatenation of all chunks (joined with a single space) preserves
+    every character of spoken content — nothing is dropped.
+    """
+    text = text.strip()
+    if not text:
+        return []
+    if len(text) <= limit:
+        return [text]
+
+    # 1. Coarse units: prefer numbered-item boundaries (keeps each "2. ..."
+    #    question intact), else fall back to sentence boundaries.
+    units = [u for u in _NUMBERED_ITEM.split(text) if u and u.strip()]
+    if len(units) <= 1:
+        units = [u for u in _SENTENCE_BOUNDARY.split(text) if u and u.strip()]
+    if len(units) <= 1:
+        units = [text]
+
+    # 2. Greedily pack units into chunks <= limit. A unit bigger than limit
+    #    is itself sentence-split, then hard-wrapped as a last resort.
+    chunks: List[str] = []
+    cur = ""
+    for unit in units:
+        unit = unit.strip()
+        if len(unit) > limit:
+            if cur:
+                chunks.append(cur)
+                cur = ""
+            sub_units = [
+                s for s in _SENTENCE_BOUNDARY.split(unit) if s and s.strip()
+            ]
+            if len(sub_units) <= 1:
+                sub_units = _hard_wrap(unit, limit)
+            for su in sub_units:
+                su = su.strip()
+                if len(su) > limit:
+                    chunks.extend(_hard_wrap(su, limit))
+                    continue
+                cand = su if not cur else f"{cur} {su}"
+                if len(cand) <= limit:
+                    cur = cand
+                else:
+                    if cur:
+                        chunks.append(cur)
+                    cur = su
+            continue
+        cand = unit if not cur else f"{cur} {unit}"
+        if len(cand) <= limit:
+            cur = cand
+        else:
+            if cur:
+                chunks.append(cur)
+            cur = unit
+    if cur:
+        chunks.append(cur)
+    return [c for c in chunks if c.strip()]
+
+
+def _concat_wav_bytes(wav_blobs: List[bytes]) -> bytes:
+    """Concatenate multiple PCM WAV blobs into ONE gapless WAV.
+
+    All chunks come from the same Sarvam call config (same model, speaker,
+    sample rate) so the PCM params match; we still assert that so a
+    mismatch fails LOUD rather than producing garbled audio. Stdlib `wave`
+    only — no pydub/ffmpeg dependency for the core join (pydub remains the
+    optional transcoder downstream).
+    """
+    if not wav_blobs:
+        raise RuntimeError("Sarvam TTS produced no audio chunks to concat")
+    if len(wav_blobs) == 1:
+        return wav_blobs[0]
+
+    params = None
+    frames: List[bytes] = []
+    for idx, blob in enumerate(wav_blobs):
+        with wave.open(io.BytesIO(blob), "rb") as w:
+            p = w.getparams()
+            if params is None:
+                params = p
+            elif (
+                p.nchannels,
+                p.sampwidth,
+                p.framerate,
+            ) != (
+                params.nchannels,
+                params.sampwidth,
+                params.framerate,
+            ):
+                raise RuntimeError(
+                    "Sarvam TTS chunk audio params diverged "
+                    f"(chunk {idx}: {p} vs {params}) — refusing to "
+                    "concatenate mismatched PCM"
+                )
+            frames.append(w.readframes(w.getnframes()))
+
+    out = io.BytesIO()
+    with wave.open(out, "wb") as w:
+        w.setnchannels(params.nchannels)
+        w.setsampwidth(params.sampwidth)
+        w.setframerate(params.framerate)
+        w.writeframes(b"".join(frames))
+    return out.getvalue()
+
 # The frontend sends an `X-Preferred-Codec: audio/{wav,mp4,webm}` header
 # so the chat endpoint can return audio in the codec the user's browser
 # decodes natively. Sarvam Bulbul's text-to-speech API itself does NOT support
@@ -193,20 +376,17 @@ class SarvamTTS(TTSProvider):
         )
         return audio_bytes
 
-    async def synthesize_with_mime(
+    async def _synthesize_one(
         self,
         text: str,
-        language_code: str = "en-IN",
-        speaker: Optional[str] = None,
-        preferred_codec: Optional[str] = None,
-    ) -> Tuple[bytes, str]:
-        """Like synthesize() but also returns the actual MIME type.
+        language_code: str,
+        speaker: Optional[str],
+    ) -> bytes:
+        """POST ONE <= char-limit text chunk to Sarvam, return its WAV bytes.
 
-        `preferred_codec` is one of "audio/wav" | "audio/mp4" | "audio/webm".
-        If None or "audio/wav", returns Sarvam's raw WAV unchanged. Any other
-        value triggers in-process transcoding via pydub/ffmpeg; on any
-        transcoding failure (missing dep, ffmpeg error), we fall back to raw
-        WAV — the frontend already handles this gracefully.
+        Raises on transport / HTTP errors (no swallowing) so the caller's
+        classifier maps them to a closed tts_error_code — mirrors
+        sarvam_stt._transcribe_wav_bytes.
         """
         url = f"{settings.SARVAM_BASE_URL}{settings.SARVAM_TTS_PATH}"
         body = {
@@ -224,7 +404,6 @@ class SarvamTTS(TTSProvider):
             "api-subscription-key": self.api_key,
             "Content-Type": "application/json",
         }
-
         async with httpx.AsyncClient(timeout=self.timeout) as client:
             resp = await client.post(url, headers=headers, json=body)
             resp.raise_for_status()
@@ -233,9 +412,69 @@ class SarvamTTS(TTSProvider):
         audios = payload.get("audios", [])
         if not audios:
             raise RuntimeError(f"Sarvam TTS returned no audio: {payload}")
-
         # Sarvam returns base64-encoded WAV in `audios[0]`
-        wav_bytes = base64.b64decode(audios[0])
+        return base64.b64decode(audios[0])
+
+    async def synthesize_with_mime(
+        self,
+        text: str,
+        language_code: str = "en-IN",
+        speaker: Optional[str] = None,
+        preferred_codec: Optional[str] = None,
+    ) -> Tuple[bytes, str]:
+        """Like synthesize() but also returns the actual MIME type.
+
+        #55 FIX: Bulbul has a HARD per-request char limit (v2=1500). A long
+        reply is split at sentence / numbered-item seams into <= ceiling
+        chunks, each chunk is synthesized sequentially, and the decoded PCM
+        is concatenated into ONE gapless WAV — so the COMPLETE reply
+        (every numbered question) is spoken, not just the first ~10s.
+        This mirrors the STT 30s-chunking house style. Any HTTP / transport
+        error on ANY chunk propagates (no silent truncation).
+
+        `preferred_codec` is one of "audio/wav" | "audio/mp4" | "audio/webm".
+        If None or "audio/wav", returns Sarvam's raw WAV unchanged. Any other
+        value triggers in-process transcoding via pydub/ffmpeg; on any
+        transcoding failure (missing dep, ffmpeg error), we fall back to raw
+        WAV — the frontend already handles this gracefully.
+        """
+        ceiling = _tts_char_ceiling(self.model)
+        chunks = _chunk_text_for_tts(text or "", ceiling)
+
+        if not chunks:
+            raise RuntimeError("Sarvam TTS called with empty text")
+
+        if len(chunks) == 1:
+            # Common case: short reply, single Sarvam call — identical wire
+            # behaviour to the pre-fix path.
+            wav_bytes = await self._synthesize_one(
+                chunks[0], language_code, speaker
+            )
+        else:
+            logger.info(
+                "TTS chunked synthesis: %d chars split into %d chunks "
+                "(<= %d chars each, model=%s)",
+                len(text or ""),
+                len(chunks),
+                ceiling,
+                self.model,
+            )
+            # Sequential — preserves order so the concatenated audio reads
+            # the questions 1..6 in order. Any chunk failure raises and the
+            # boundary classifier surfaces a real error_code; we NEVER
+            # return a silently-partial readout.
+            wav_parts: List[bytes] = []
+            for idx, chunk in enumerate(chunks):
+                part = await self._synthesize_one(
+                    chunk, language_code, speaker
+                )
+                if not part:
+                    raise RuntimeError(
+                        f"Sarvam TTS returned empty audio for chunk {idx} "
+                        f"of {len(chunks)}"
+                    )
+                wav_parts.append(part)
+            wav_bytes = _concat_wav_bytes(wav_parts)
 
         codec = (preferred_codec or "audio/wav").lower()
         return _transcode_wav(wav_bytes, codec)

backend/voice_format.py

@@ -28,9 +28,15 @@ Into spoken-ready:
 Rules applied (in order):
   1. Strip [Source: ...] and [Regulation: ...] inline citations
   2. Strip markdown formatting (** bold, * italic, # headings, > quote, - bullet, 1. number)
-  3. Expand acronyms common in insurance to pronounceable forms
-  4. Compress whitespace
-  5. Truncate to first ~60 spoken words; append "More details on screen." if cut
+  3. Expand abbreviations ("e.g." -> "for example") and slashes ("yes / no"
+     -> "yes or no"; "₹5L / ₹10L" -> "5 lakh, 10 lakh") so Sarvam Bulbul
+     never spells "e.g." letter-by-letter or reads "/" as "by"/"divide"
+  4. Expand acronyms common in insurance to pronounceable forms
+  5. Compress whitespace
+  6. NO word cap — the FULL reply is spoken. Sarvam Bulbul v2's hard
+     per-request character limit is handled downstream by chunked
+     synthesis in providers/sarvam_tts.py (mirrors the STT 30s-chunking
+     house style); we never silently drop trailing questions here.
 """
 
 from __future__ import annotations
@@ -199,6 +205,162 @@ def _humanize_int(n: int) -> str:
     return f"{n} rupees"
 
 
+# ---- #56: abbreviation + slash normalization ----
+#
+# Sarvam Bulbul reads "e.g." as the letters "E G", and a bare "/" as
+# "by"/"divide"/"slash". Both make a numbered pricing question sound like a
+# robot reading a spreadsheet. We expand these to natural spoken words
+# BEFORE money normalization so "₹5L / ₹10L / ₹25L / ₹1Cr" first becomes a
+# comma-separated list ("5L, 10L, 25L, or 1Cr") and the existing money
+# regexes then turn each token into "5 lakh", "10 lakh", etc.
+
+# "e.g." / "i.e." / "etc." in any spacing/casing. Order: longest first.
+# `e.g.,` and `e.g.` both collapse to "for example".
+_ABBR_EG = re.compile(r"\be\.\s*g\.\s*,?", re.IGNORECASE)
+_ABBR_IE = re.compile(r"\bi\.\s*e\.\s*,?", re.IGNORECASE)
+_ABBR_ETC = re.compile(r"\b,?\s*etc\.?", re.IGNORECASE)
+_ABBR_VS = re.compile(r"\bvs\.?\b", re.IGNORECASE)
+_ABBR_APPROX = re.compile(r"\bapprox\.?", re.IGNORECASE)
+
+# A "/" that joins currency/amount tokens (₹5L / ₹10L / ₹25L / ₹1Cr).
+# Convert the whole run into a natural list: "A, B, C, or D". We match a
+# slash-separated run of money-ish tokens (digits + optional ₹ + optional
+# L/Cr/K/lakh/crore/%/word) and re-join with commas + a trailing "or".
+_SLASH_MONEY_RUN = re.compile(
+    r"(₹?\s*\d[\d,]*(?:\.\d+)?\s*(?:L\b|Cr\b|K\b|lakh|crore|thousand|%)?[+]?)"
+    r"(?:\s*/\s*"
+    r"(₹?\s*\d[\d,]*(?:\.\d+)?\s*(?:L\b|Cr\b|K\b|lakh|crore|thousand|%)?[+]?))+",
+    re.IGNORECASE,
+)
+# Generic word/number slash like "parents/siblings", "yes / no",
+# "work/otherwise" — read as "or". Keep things like "24/7" and "and/or"
+# natural; "and/or" -> "and or" is acceptable spoken English.
+_SLASH_GENERIC = re.compile(
+    r"(?<=[\w%)\]])\s*/\s*(?=[\w(₹])"
+)
+
+
+def _normalize_slash_money_run(text: str) -> str:
+    """Turn "₹5L / ₹10L / ₹25L / ₹1Cr" into "₹5L, ₹10L, ₹25L, or ₹1Cr".
+
+    The downstream money regexes then expand each token to "5 lakh" etc.
+    Result spoken: "5 lakh rupees, 10 lakh rupees, 25 lakh rupees, or 1
+    crore rupees" — never a slash read as "by"/"divide".
+    """
+
+    def _repl(m: "re.Match[str]") -> str:
+        run = m.group(0)
+        parts = [p.strip() for p in run.split("/") if p.strip()]
+        if len(parts) <= 1:
+            return run
+        if len(parts) == 2:
+            return f"{parts[0]}, or {parts[1]}"
+        return ", ".join(parts[:-1]) + f", or {parts[-1]}"
+
+    return _SLASH_MONEY_RUN.sub(_repl, text)
+
+
+# --- #56: numeric ranges + per-unit slashes that the money regexes miss ---
+#
+# Advisor messages use the EN DASH (–, U+2013) for ranges ("10–30%",
+# "₹10–15K", "30–50%"). The existing _MONEY_RANGE_* regexes only match an
+# ASCII hyphen, and _normalize_numbers strips –/— to a space, so an
+# un-normalized en-dash range becomes "ten thirty percent" / "rupees ten
+# 15K". Normalize en/em dash ranges to spoken "X to Y …" HERE (before
+# money + before _normalize_numbers) so the whole range survives.
+#
+# Order: percent-range, then ₹K-range (with optional "/period"), then
+# ₹L / ₹Cr ranges, then a bare numeric range fallback.
+_RANGE_PCT = re.compile(
+    r"(\d+(?:\.\d+)?)\s*[–—-]\s*(\d+(?:\.\d+)?)\s*%",
+)
+# "₹10–15K/year" / "₹10–15K per year" / "₹10–15K". The trailing
+# "/<word>" becomes "per <word>" (a rate), NOT "or".
+_RANGE_K_PERIOD = re.compile(
+    r"₹?\s*(\d+(?:\.\d+)?)\s*[–—-]\s*(\d+(?:\.\d+)?)\s*K\s*/\s*([A-Za-z]+)",
+    re.IGNORECASE,
+)
+_RANGE_K = re.compile(
+    r"₹\s*(\d+(?:\.\d+)?)\s*[–—-]\s*(\d+(?:\.\d+)?)\s*K\b",
+    re.IGNORECASE,
+)
+_RANGE_L = re.compile(
+    r"₹\s*(\d+(?:\.\d+)?)\s*[–—-]\s*(\d+(?:\.\d+)?)\s*L\b",
+    re.IGNORECASE,
+)
+_RANGE_CR = re.compile(
+    r"₹\s*(\d+(?:\.\d+)?)\s*[–—-]\s*(\d+(?:\.\d+)?)\s*Cr\b",
+    re.IGNORECASE,
+)
+# A unit "/period" rate that is NOT part of a handled money token, e.g.
+# "50K/year" alone, "₹500/month". Convert "/word" -> "per word".
+_RATE_SLASH_PERIOD = re.compile(
+    r"(?<=[\w%)\]])\s*/\s*(year|yr|month|mo|annum|day|week|claim|policy|person|member|head)\b",
+    re.IGNORECASE,
+)
+
+
+def _normalize_ranges(text: str) -> str:
+    """Expand en/em-dash numeric ranges + per-period rate slashes.
+
+    Runs BEFORE _normalize_money and _normalize_numbers so the dash isn't
+    stripped to a space mid-range and each side keeps its unit.
+    """
+    # Percent ranges first: "10–30%" -> "10 to 30 percent".
+    text = _RANGE_PCT.sub(lambda m: f"{m.group(1)} to {m.group(2)} percent", text)
+    # "₹10–15K/year" -> "10 to 15 thousand rupees per year".
+    text = _RANGE_K_PERIOD.sub(
+        lambda m: f"{m.group(1)} to {m.group(2)} thousand rupees per {m.group(3)}",
+        text,
+    )
+    # "₹10–15K" -> "10 to 15 thousand rupees".
+    text = _RANGE_K.sub(
+        lambda m: f"{m.group(1)} to {m.group(2)} thousand rupees", text
+    )
+    # "₹5–10L" -> "5 to 10 lakh rupees" (en-dash variant of _MONEY_RANGE_L).
+    text = _RANGE_L.sub(
+        lambda m: f"{m.group(1)} to {m.group(2)} lakh rupees", text
+    )
+    text = _RANGE_CR.sub(
+        lambda m: f"{m.group(1)} to {m.group(2)} crore rupees", text
+    )
+    # Lone "/period" rate slash -> "per period" (do this BEFORE the generic
+    # slash->"or" pass so "K/year" doesn't become "K or year").
+    text = _RATE_SLASH_PERIOD.sub(lambda m: f" per {m.group(1).lower()}", text)
+    return text
+
+
+def _normalize_abbreviations(text: str) -> str:
+    """Expand spoken-hostile abbreviations + slashes.
+
+    Runs BEFORE _normalize_money so currency slash-runs become comma lists
+    that the money regexes can then expand token-by-token.
+    """
+    # Abbreviations first (so a trailing "etc." inside a slash run is gone
+    # before slash handling).
+    text = _ABBR_EG.sub("for example", text)
+    text = _ABBR_IE.sub("that is", text)
+    text = _ABBR_ETC.sub(" and so on", text)
+    text = _ABBR_VS.sub("versus", text)
+    text = _ABBR_APPROX.sub("approximately", text)
+
+    # Ranges + rate-slashes BEFORE slash/money handling so en-dash ranges
+    # and "K/year" survive intact.
+    text = _normalize_ranges(text)
+
+    # Currency/amount slash runs -> comma list with trailing "or".
+    text = _normalize_slash_money_run(text)
+
+    # Any remaining word/number slash -> " or " (parents/siblings, yes / no,
+    # work or otherwise). Loop until stable so chained "a/b/c" all convert.
+    for _ in range(6):
+        new = _SLASH_GENERIC.sub(" or ", text)
+        if new == text:
+            break
+        text = new
+    return text
+
+
 def _normalize_money(text: str) -> str:
     """Turn currency / range shorthand into spoken-language equivalents.
 
@@ -559,8 +721,27 @@ def strip_cot_preamble(text: str) -> str:
     return cleaned
 
 
-def tts_preprocess(text: str, language: str = "en", max_words: int = 60) -> str:
-    """Public entry — turn an LLM reply into spoken-language text for TTS."""
+def tts_preprocess(
+    text: str,
+    language: str = "en",
+    max_words: int | None = None,
+) -> str:
+    """Public entry — turn an LLM reply into spoken-language text for TTS.
+
+    #55 FIX: there is NO premature word cap. The ENTIRE reply is normalized
+    and returned so every numbered question is spoken. Sarvam Bulbul v2's
+    per-request character limit is enforced *downstream* by chunked
+    synthesis in providers/sarvam_tts.py (house style mirrors the STT
+    30s-chunking) — we never silently drop trailing content here.
+
+    `max_words` is kept ONLY for backward call-site compatibility
+    (backend/main.py passes max_words=55). It is intentionally IGNORED:
+    capping spoken words is exactly the bug we are removing. A caller that
+    truly wants a hard cap can still pass an int and we honour it as a
+    LAST-RESORT safety ceiling that is far above any real reply
+    (>= 100000 effectively never trips); the default None means "speak
+    everything".
+    """
     if not text:
         return ""
     # Defense in depth: run the preamble strip again here in case this is
@@ -568,6 +749,10 @@ def tts_preprocess(text: str, language: str = "en", max_words: int = 60) -> str:
     # cached reply).
     cleaned = strip_cot_preamble(text)
     cleaned = _strip_markdown(cleaned)
+    # #56 — abbreviations ("e.g." -> "for example") and slashes
+    # ("₹5L / ₹10L" -> list; "yes / no" -> "yes or no") BEFORE money so
+    # currency slash-runs become comma lists the money regexes can expand.
+    cleaned = _normalize_abbreviations(cleaned)
     # Currency/range shorthand expansion before acronym handling so ₹5L
     # becomes "5 lakhs" instead of getting caught by the bare-L acronym
     # path.
@@ -578,5 +763,9 @@ def tts_preprocess(text: str, language: str = "en", max_words: int = 60) -> str:
     cleaned = _normalize_numbers(cleaned)
     cleaned = _expand_acronyms(cleaned, language=language)
     cleaned = _compress_whitespace(cleaned)
-    cleaned = _truncate_for_voice(cleaned, max_words=max_words)
+    # #55 — DO NOT truncate by default. Only honour an explicit, sane
+    # last-resort ceiling if a caller deliberately passes one (we ignore
+    # the legacy 55/60 values — those ARE the bug).
+    if max_words is not None and max_words >= 100_000:
+        cleaned = _truncate_for_voice(cleaned, max_words=max_words)
     return cleaned

frontend/src/lib/useStreamingVoice.ts

@@ -170,6 +170,136 @@ const BARGE_IN_GRACE_MS = 600;
 // (~0.02 worst case on speakers) does not.
 const BARGE_IN_NO_BOTREF_FLOOR = 0.035;
 
+// =========================================================================
+// #53 / #54 (2026-05-18) — push-to-talk head-clipping + start-latency fix.
+//
+// ROOT CAUSE (verified):
+//   page.tsx's push-to-talk path cold-starts the mic on every SPACE press:
+//     page.tsx:1350-1361  onKeyDown(SPACE) → startRecordingRef.current()
+//     page.tsx:1004-1019  startRecording() → navigator.mediaDevices
+//                          .getUserMedia(...)  [COLD — 200-700ms on HF Space]
+//     page.tsx:1021       new MediaRecorder(stream)
+//     page.tsx:1213       recorder.start()    [capture truly begins HERE]
+//   Every word the user speaks between the keydown and recorder.start()
+//   firing is *never captured* → the leading word is lost/garbled (#53,
+//   transcribed "S A R" for "Sir."). The same cold-start is the multi-second
+//   delay the user feels before recording begins (#54). There is NO pre-roll
+//   buffer and NO warm/pre-armed stream anywhere in the codebase.
+//
+// FIX (this hook, since page.tsx is owned by another writer and its PTT path
+// is fully self-contained):
+//   - Keep ONE mic stream + MediaRecorder + AudioContext WARM for the hook's
+//     entire armed lifetime (acquired once after the user opts into voice,
+//     never torn down per-press, survives the Live↔PTT toggle). A persistent
+//     open audio device means the OS mic is already hot, so page.tsx's own
+//     per-press getUserMedia resolves in ~10-50ms instead of cold-starting
+//     (200-700ms) — that alone removes the felt multi-second start delay.
+//   - The warm MediaRecorder runs with a short timeslice, feeding a rolling
+//     PRE-ROLL ring buffer that always holds the last ~PRE_ROLL_MS of audio.
+//   - The PTT API (beginPushToTalk/endPushToTalk) prepends the pre-roll to
+//     the captured utterance, so the FIRST WORD — spoken in the cold-start
+//     gap — is always in the blob even though page.tsx's recorder missed it.
+//   - A DELIBERATE-HOLD gate: beginPushToTalk arms instantly but the capture
+//     only "engages" after HOLD_THRESHOLD_MS; a sub-threshold tap (key
+//     bounce, accidental press) is discarded and produces no submission.
+//   - AudioContext.resume() is kept warm WHILE armed (not lazily on first
+//     press), and warm-stream / permission / worklet failures are surfaced
+//     via onVoiceError — never silent.
+//
+// The pure pre-roll ring-buffer + hold-gate logic is exported (PreRollRing,
+// evaluateHoldGate) so it is self-contained and independently exercised by
+// the regression test.
+// =========================================================================
+
+// Size of the rolling pre-roll buffer. Must comfortably cover the worst-case
+// page.tsx cold-start gap (getUserMedia 200-700ms + MediaRecorder spin-up +
+// the optional 400ms Live-teardown wait at page.tsx:994). 800ms gives margin
+// without bloating the blob (browser webm/opus ≈ 4 KB/s ⇒ ~3.2 KB of lead-in).
+export const PRE_ROLL_MS = 800;
+// Warm MediaRecorder timeslice. Small enough that the pre-roll ring has fine
+// granularity (we never drop more than one slice of lead-in when trimming the
+// ring to PRE_ROLL_MS), large enough not to thrash ondataavailable.
+export const WARM_TIMESLICE_MS = 200;
+// Deliberate-hold threshold (#54). The hold must be intentional so an
+// accidental tap / key-bounce doesn't fire a turn, but it must feel instant
+// on a real hold — 200ms sits in the requested 150-250ms band.
+export const HOLD_THRESHOLD_MS = 200;
+
+/**
+ * PreRollRing — a rolling, time-bounded ring buffer of MediaRecorder Blob
+ * slices. `push` appends a freshly-emitted slice (each slice represents
+ * ~WARM_TIMESLICE_MS of audio); the ring evicts the oldest slices once the
+ * retained wall-clock duration exceeds `windowMs`, so it always holds *at
+ * least* the last `windowMs` of audio (it may hold up to one extra slice so
+ * a head word that started just before `windowMs` ago is never trimmed).
+ *
+ * Pure + framework-free so the regression test can drive it directly without
+ * a browser. `drain()` returns the retained slices oldest-first and clears
+ * the ring (used at PTT-engage to seed the utterance with the lead-in).
+ */
+export class PreRollRing {
+  private slices: Array<{ blob: Blob; ms: number }> = [];
+  private retainedMs = 0;
+  private readonly windowMs: number;
+  constructor(windowMs: number = PRE_ROLL_MS) {
+    this.windowMs = windowMs;
+  }
+
+  push(blob: Blob, sliceMs: number = WARM_TIMESLICE_MS): void {
+    if (!blob || blob.size <= 0) return;
+    this.slices.push({ blob, ms: sliceMs });
+    this.retainedMs += sliceMs;
+    // Evict from the front while doing so still leaves >= windowMs retained
+    // (keep one extra slice of slack so a word that began just before the
+    // window boundary survives — never trim into the requested lead-in).
+    while (
+      this.slices.length > 1 &&
+      this.retainedMs - this.slices[0].ms >= this.windowMs
+    ) {
+      const dropped = this.slices.shift();
+      if (dropped) this.retainedMs -= dropped.ms;
+    }
+  }
+
+  /** Retained lead-in slices oldest-first; clears the ring. */
+  drain(): Blob[] {
+    const out = this.slices.map((s) => s.blob);
+    this.slices = [];
+    this.retainedMs = 0;
+    return out;
+  }
+
+  /** Approximate retained wall-clock duration (ms). */
+  retainedDurationMs(): number {
+    return this.retainedMs;
+  }
+
+  clear(): void {
+    this.slices = [];
+    this.retainedMs = 0;
+  }
+}
+
+/**
+ * evaluateHoldGate — pure decision for the deliberate-hold threshold (#54).
+ *
+ * Given when the user engaged (pressed) and released, decide whether the
+ * press was a DELIBERATE hold (capture should be submitted) or a sub-threshold
+ * TAP (discard — accidental press / key bounce). Kept pure so the regression
+ * test can assert the boundary exactly without timers.
+ *
+ *   heldMs >= thresholdMs  → { deliberate: true  }  (engage + submit)
+ *   heldMs <  thresholdMs  → { deliberate: false }  (discard, no submit)
+ */
+export function evaluateHoldGate(
+  pressedAt: number,
+  releasedAt: number,
+  thresholdMs: number = HOLD_THRESHOLD_MS,
+): { deliberate: boolean; heldMs: number } {
+  const heldMs = Math.max(0, releasedAt - pressedAt);
+  return { deliberate: heldMs >= thresholdMs, heldMs };
+}
+
 // Minimal types for the Web Speech API since lib.dom.d.ts ships them under
 // `webkitSpeechRecognition` only and the standard `SpeechRecognition` symbol
 // is still vendor-prefixed in most browsers as of 2026-05.
@@ -242,6 +372,54 @@ export interface UseStreamingVoiceReturn {
    *     send() is in flight.
    */
   consumeBargeInSignal: () => boolean;
+
+  // ----------------------------------------------------------------------
+  // #53 / #54 — warm-stream + pre-roll push-to-talk API.
+  //
+  // This is the minimal API the push-to-talk UI integrates with. Even
+  // without an explicit call, `armWarmStream()` is invoked autonomously by
+  // the hook once voice has been enabled, so the OS mic device is kept hot
+  // for the rest of the session — that removes the per-press cold-start that
+  // page.tsx's own getUserMedia otherwise pays (the felt multi-second delay,
+  // #54) and continuously fills the pre-roll ring so the leading word spoken
+  // in the cold-start gap survives (#53).
+  // ----------------------------------------------------------------------
+
+  /** True once the warm mic stream + recorder + AudioContext are live and
+   *  the pre-roll ring is filling. */
+  isWarm: boolean;
+
+  /** Pre-arm (or re-arm) the persistent warm stream. Idempotent; safe to
+   *  call repeatedly. Resolves true when the warm stream is recording. */
+  armWarmStream: () => Promise<boolean>;
+
+  /** Release the warm stream + recorder + AudioContext (mic indicator off).
+   *  Called on unmount; callers may call it to fully relinquish the mic. */
+  disarmWarmStream: () => void;
+
+  /**
+   * Engage a push-to-talk capture. Call on hold-start (e.g. SPACE keydown).
+   * Returns immediately. The capture *engages* only after HOLD_THRESHOLD_MS
+   * so a sub-threshold tap is ignored; the engaged utterance is seeded with
+   * the pre-roll ring so the first word (spoken during the cold-start gap)
+   * is always included.
+   */
+  beginPushToTalk: () => void;
+
+  /**
+   * End a push-to-talk capture. Call on hold-release (e.g. SPACE keyup).
+   * If the hold was deliberate (>= HOLD_THRESHOLD_MS) the assembled blob
+   * (pre-roll + live capture) is transcribed and delivered via
+   * onFinalTranscript; a sub-threshold tap resolves to null and submits
+   * nothing. Resolves with the final transcript, or null when discarded /
+   * empty.
+   */
+  endPushToTalk: () => Promise<string | null>;
+
+  /** Snapshot+drain the current pre-roll ring (oldest-first). Exposed for
+   *  the regression test and any caller that wants to splice the lead-in
+   *  into its own recorder blob. */
+  consumePreRollChunks: () => Blob[];
 }
 
 function resolveCtor(): SpeechRecognitionCtor | null {
@@ -366,6 +544,45 @@ export function useStreamingVoice(
   // for the final ondataavailable chunk before building the blob.
   const recorderStopWaiterRef = useRef<(() => void) | null>(null);
 
+  // ----------------------------------------------------------------------
+  // #53 / #54 — warm-stream + pre-roll push-to-talk state.
+  //
+  // SEPARATE from the Live-mode mediaStream/mediaRecorder above. The Live
+  // recorder is acquired/torn-down per utterance and is gated on the
+  // `enabled` prop (which page.tsx flips OFF during push-to-talk). This warm
+  // stream is the OPPOSITE lifecycle: opened once after the user opts into
+  // voice, kept alive across the Live↔PTT toggle for the hook's mounted
+  // lifetime, never closed per-press. Holding a persistent open audio device
+  // keeps the OS mic hot so any per-press getUserMedia (Live's OR page.tsx's
+  // PTT) resolves near-instantly instead of cold-starting.
+  // ----------------------------------------------------------------------
+  const warmStreamRef = useRef<MediaStream | null>(null);
+  const warmRecorderRef = useRef<MediaRecorder | null>(null);
+  const warmCtxRef = useRef<AudioContext | null>(null);
+  const warmMimeRef = useRef<string>("audio/webm");
+  // The rolling pre-roll ring — always holds ~PRE_ROLL_MS of the most recent
+  // audio so a PTT engage can prepend the lead-in the user spoke during the
+  // cold-start gap.
+  const preRollRef = useRef<PreRollRing>(new PreRollRing(PRE_ROLL_MS));
+  // Live capture slices accumulated between PTT engage and release. The
+  // submitted blob is preRoll.drain() (lead-in) ++ these (live capture).
+  const pttCaptureRef = useRef<Blob[]>([]);
+  // True between a deliberate engage and the matching release — the warm
+  // recorder's ondataavailable routes slices to pttCaptureRef instead of
+  // (only) the pre-roll ring while this is set.
+  const pttEngagedRef = useRef<boolean>(false);
+  // wall-clock ms of the current hold's keydown (0 when not pressed). Used
+  // by evaluateHoldGate to classify deliberate hold vs sub-threshold tap.
+  const pttPressedAtRef = useRef<number>(0);
+  // setTimeout id for the deliberate-hold engage. Fires HOLD_THRESHOLD_MS
+  // after press; if release beats it, the press was a tap and is discarded.
+  const pttHoldTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // True once the user has opted into voice at least once. Latches the warm
+  // stream ON for the rest of the hook's mounted lifetime so it survives the
+  // Live↔PTT toggle (page.tsx flips `enabled` false for pure PTT).
+  const voiceEverEnabledRef = useRef<boolean>(false);
+  const [isWarm, setIsWarm] = useState<boolean>(false);
+
   const [isSupported] = useState<boolean>(() => resolveCtor() !== null);
 
   const clearRestartTimer = useCallback(() => {
@@ -587,6 +804,282 @@ export function useStreamingVoice(
     }
   }, [pickRecorderMime]);
 
+  // ======================================================================
+  // #53 / #54 — warm-stream + pre-roll push-to-talk engine.
+  // ======================================================================
+
+  const disarmWarmStream = useCallback(() => {
+    if (pttHoldTimerRef.current !== null) {
+      clearTimeout(pttHoldTimerRef.current);
+      pttHoldTimerRef.current = null;
+    }
+    pttEngagedRef.current = false;
+    pttPressedAtRef.current = 0;
+    pttCaptureRef.current = [];
+    preRollRef.current.clear();
+    const rec = warmRecorderRef.current;
+    if (rec) {
+      try {
+        rec.ondataavailable = null;
+        rec.onerror = null;
+        rec.onstop = null;
+        if (rec.state !== "inactive") rec.stop();
+      } catch {
+        /* ignore */
+      }
+    }
+    warmRecorderRef.current = null;
+    const stream = warmStreamRef.current;
+    if (stream) {
+      stream.getTracks().forEach((t) => {
+        try { t.stop(); } catch { /* ignore */ }
+      });
+    }
+    warmStreamRef.current = null;
+    const ctx = warmCtxRef.current;
+    if (ctx) {
+      warmCtxRef.current = null;
+      try { void ctx.close(); } catch { /* ignore */ }
+    }
+    setIsWarm(false);
+  }, []);
+
+  // Acquire (or re-acquire) the persistent warm stream. Idempotent: a
+  // healthy recording warm recorder short-circuits. On failure routes
+  // through the SAME onVoiceError("mic_permission_denied") contract the
+  // Live path uses — never a silent failure.
+  const armWarmStream = useCallback(async (): Promise<boolean> => {
+    voiceEverEnabledRef.current = true;
+    const existing = warmRecorderRef.current;
+    if (existing && existing.state === "recording" && warmStreamRef.current) {
+      return true;
+    }
+    if (typeof navigator === "undefined" || !navigator.mediaDevices) return false;
+    if (typeof MediaRecorder === "undefined") return false;
+    // Tear down any half-built prior attempt before re-acquiring.
+    if (existing || warmStreamRef.current) disarmWarmStream();
+    try {
+      // Same AEC/NS/AGC constraints as the Live + PTT paths (KI-185) so the
+      // pre-roll is echo-cancelled identically to the rest of the capture.
+      // W2-style 2s stall watchdog so a hung getUserMedia surfaces a banner
+      // instead of pinning the warm state forever.
+      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("warm getUserMedia stalled >2s") as Error & { name: string };
+            e.name = "StallTimeout";
+            reject(e);
+          }, 2000);
+        }),
+      ]);
+      const mime = pickRecorderMime();
+      warmMimeRef.current = mime || "audio/webm";
+      const recorder = mime
+        ? new MediaRecorder(stream, { mimeType: mime })
+        : new MediaRecorder(stream);
+      preRollRef.current = new PreRollRing(PRE_ROLL_MS);
+      pttCaptureRef.current = [];
+      pttEngagedRef.current = false;
+      recorder.ondataavailable = (ev: BlobEvent) => {
+        if (!ev.data || ev.data.size <= 0) return;
+        // Always feed the rolling pre-roll ring so the lead-in is ready the
+        // instant a PTT engage fires (the word spoken in the cold-start gap
+        // is in here). When a PTT capture is engaged, ALSO accumulate the
+        // slice into the live capture buffer — the submitted blob is
+        // preRoll.drain() (lead-in) ++ pttCaptureRef (live), so the first
+        // word is never lost AND no chunk is dropped.
+        preRollRef.current.push(ev.data, WARM_TIMESLICE_MS);
+        if (pttEngagedRef.current) {
+          pttCaptureRef.current.push(ev.data);
+        }
+      };
+      recorder.onerror = (ev: Event) => {
+        console.debug("[useStreamingVoice] warm MediaRecorder error", ev);
+        try { onVoiceErrorRef.current("stream_stale"); } catch { /* ignore */ }
+      };
+      recorder.onstop = () => {
+        // The warm recorder should never stop on its own while armed; if it
+        // does (device unplug, OS interruption) surface it and let the
+        // re-arm effect / next press recover.
+        console.debug("[useStreamingVoice] warm MediaRecorder stopped");
+      };
+      warmStreamRef.current = stream;
+      warmRecorderRef.current = recorder;
+      recorder.start(WARM_TIMESLICE_MS);
+      if (recorder.state !== "recording") {
+        try { stream.getTracks().forEach((t) => t.stop()); } catch { /* ignore */ }
+        warmStreamRef.current = null;
+        warmRecorderRef.current = null;
+        throw Object.assign(
+          new Error(`warm MediaRecorder not recording (got ${recorder.state})`),
+          { name: "RecorderNotRecording" },
+        );
+      }
+      // Keep an AudioContext warm + RUNNING so it never has to be resumed
+      // lazily on first press (a suspended ctx is one of the documented
+      // first-word-loss vectors). resume() needs a user gesture on some
+      // browsers; armWarmStream is always called from one (voice toggle).
+      try {
+        const Ctor = (window.AudioContext
+          || (window as unknown as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext);
+        if (Ctor) {
+          if (!warmCtxRef.current || warmCtxRef.current.state === "closed") {
+            warmCtxRef.current = new Ctor();
+          }
+          if (warmCtxRef.current.state === "suspended") {
+            void warmCtxRef.current.resume().catch((err) => {
+              console.debug("[useStreamingVoice] warm AudioContext.resume failed", err);
+              try { onVoiceErrorRef.current("audio_context_suspended"); } catch { /* ignore */ }
+            });
+          }
+        }
+      } catch {
+        /* AudioContext is best-effort for warmth; capture still works */
+      }
+      setIsWarm(true);
+      console.debug("[useStreamingVoice] warm stream armed", {
+        mime: warmMimeRef.current,
+        preRollMs: PRE_ROLL_MS,
+        timesliceMs: WARM_TIMESLICE_MS,
+      });
+      return true;
+    } catch (err) {
+      const name = (err as { name?: string } | null)?.name ?? "Error";
+      console.debug("[useStreamingVoice] warm stream arm failed", { name, err });
+      setIsWarm(false);
+      try {
+        onVoiceErrorRef.current("mic_permission_denied" as VoiceError);
+      } catch {
+        /* never let a user callback crash the hook */
+      }
+      return false;
+    }
+  }, [pickRecorderMime, disarmWarmStream]);
+
+  const consumePreRollChunks = useCallback((): Blob[] => {
+    return preRollRef.current.drain();
+  }, []);
+
+  // Submit an assembled PTT blob through the SAME Sarvam-with-retry path the
+  // Live grace-timer uses (KI-226/302), then deliver via onFinalTranscript.
+  // Returns the authoritative transcript or null.
+  const submitPttBlob = useCallback(
+    async (chunks: Blob[]): Promise<string | null> => {
+      if (chunks.length === 0) return null;
+      const blob = new Blob(chunks, { type: warmMimeRef.current || "audio/webm" });
+      // ~3 KB empirical noise floor (same as the Live path / PTT KI-134).
+      const MIN_BLOB_BYTES = 3000;
+      if (blob.size < MIN_BLOB_BYTES) {
+        console.debug("[useStreamingVoice] PTT blob below noise floor — discard", {
+          bytes: blob.size,
+        });
+        return null;
+      }
+      await waitForTextClear();
+      const APPROX_BYTES_PER_CHUNK = 100_000; // ~25s of webm/opus
+      const estChunks = Math.max(1, Math.ceil(blob.size / APPROX_BYTES_PER_CHUNK));
+      const attemptTimeoutMs = Math.min(120_000, 8_000 + estChunks * 12_000);
+      let authoritative: string | null = null;
+      const sarvam = await retryPostTranscribe(async (signal) => {
+        const timeoutCtl = new AbortController();
+        const timer = setTimeout(() => timeoutCtl.abort(), attemptTimeoutMs);
+        const onOuterAbort = () => timeoutCtl.abort();
+        signal.addEventListener("abort", onOuterAbort);
+        try {
+          return await postTranscribe(blob, language, timeoutCtl.signal);
+        } finally {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", onOuterAbort);
+        }
+      });
+      if (sarvam) {
+        const t = (sarvam.text || "").trim();
+        if (t) authoritative = t;
+      } else {
+        try { onVoiceErrorRef.current("transcribe_failed"); } catch { /* ignore */ }
+      }
+      if (authoritative) {
+        await waitForTextClear();
+        onFinalRef.current(authoritative);
+      }
+      return authoritative;
+    },
+    [language, waitForTextClear],
+  );
+
+  // PTT engage — called HOLD_THRESHOLD_MS after a deliberate press. Snapshots
+  // the pre-roll (lead-in spoken during the cold-start gap) into the live
+  // capture buffer and flips the recorder's slice routing to also accumulate.
+  const engagePtt = useCallback(() => {
+    pttEngagedRef.current = true;
+    // Seed the capture with the pre-roll lead-in FIRST so the first word
+    // (which page.tsx's cold-started recorder would have missed) is at the
+    // head of the submitted blob.
+    const leadIn = preRollRef.current.drain();
+    pttCaptureRef.current = [...leadIn];
+    console.debug("[useStreamingVoice] PTT engaged", {
+      leadInSlices: leadIn.length,
+    });
+  }, []);
+
+  const beginPushToTalk = useCallback(() => {
+    pttPressedAtRef.current = Date.now();
+    pttCaptureRef.current = [];
+    pttEngagedRef.current = false;
+    // Make sure the warm stream is up so the pre-roll is actually filling.
+    // armWarmStream is idempotent + fast when already warm.
+    void armWarmStream();
+    if (pttHoldTimerRef.current !== null) {
+      clearTimeout(pttHoldTimerRef.current);
+    }
+    // Deliberate-hold gate: engage only after the threshold so a sub-150ms
+    // tap does nothing. The capture still feels instant because the pre-roll
+    // ring already holds the audio spoken during these HOLD_THRESHOLD_MS.
+    pttHoldTimerRef.current = setTimeout(() => {
+      pttHoldTimerRef.current = null;
+      // Re-check the press is still held (release clears pttPressedAtRef).
+      if (pttPressedAtRef.current !== 0) engagePtt();
+    }, HOLD_THRESHOLD_MS);
+  }, [armWarmStream, engagePtt]);
+
+  const endPushToTalk = useCallback(async (): Promise<string | null> => {
+    const pressedAt = pttPressedAtRef.current;
+    const releasedAt = Date.now();
+    pttPressedAtRef.current = 0;
+    if (pttHoldTimerRef.current !== null) {
+      clearTimeout(pttHoldTimerRef.current);
+      pttHoldTimerRef.current = null;
+    }
+    const { deliberate, heldMs } = evaluateHoldGate(
+      pressedAt || releasedAt,
+      releasedAt,
+      HOLD_THRESHOLD_MS,
+    );
+    const wasEngaged = pttEngagedRef.current;
+    pttEngagedRef.current = false;
+    if (!deliberate || !wasEngaged) {
+      // Sub-threshold tap (or release before engage fired): discard. The
+      // pre-roll ring keeps rolling for the warm stream; nothing submitted.
+      console.debug("[useStreamingVoice] PTT discarded (tap)", {
+        heldMs,
+        deliberate,
+        wasEngaged,
+      });
+      pttCaptureRef.current = [];
+      return null;
+    }
+    const captured = pttCaptureRef.current;
+    pttCaptureRef.current = [];
+    return submitPttBlob(captured);
+  }, [submitPttBlob]);
+
   const buildRecognition = useCallback((): SpeechRecognitionInstance | null => {
     const Ctor = resolveCtor();
     if (!Ctor) return null;
@@ -1107,6 +1600,51 @@ export function useStreamingVoice(
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [enabled]);
 
+  // #53 / #54 — warm-stream lifecycle. The warm stream's lifecycle is
+  // DELIBERATELY decoupled from `enabled` (which page.tsx flips OFF for pure
+  // push-to-talk — see page.tsx:986 `live.setLive(false)` inside
+  // startRecording). The user opting into voice latches the warm stream ON
+  // for the rest of the hook's mounted lifetime so:
+  //   (a) the pre-roll ring is ALWAYS filling whenever the user might press
+  //       SPACE — including in pure-PTT mode when `enabled` is false — so the
+  //       first word spoken in page.tsx's cold-start gap survives (#53);
+  //   (b) a persistent open audio device keeps the OS mic hot so page.tsx's
+  //       own per-press getUserMedia resolves in ~10-50ms instead of
+  //       cold-starting (200-700ms), removing the felt start delay (#54).
+  // Armed on the rising edge of `enabled` (the only voice-opt-in signal the
+  // hook receives) and kept armed thereafter; fully released on unmount.
+  useEffect(() => {
+    if (!isSupported) return;
+    if (enabled) {
+      voiceEverEnabledRef.current = true;
+    }
+    if (enabled || voiceEverEnabledRef.current) {
+      void armWarmStream();
+    }
+    // No teardown on `enabled` going false — the warm stream must survive
+    // the Live↔PTT toggle. Final release happens in the unmount cleanup.
+  }, [enabled, isSupported, armWarmStream]);
+
+  // #53 / #54 — warm-stream health watchdog. The OS can silently drop a
+  // long-lived capture (device sleep, USB mic unplug, OS audio interruption,
+  // tab backgrounding on some browsers) WITHOUT firing recorder.onerror. If
+  // that happens the pre-roll ring goes stale and the very bug we fixed
+  // returns. Every 4s, while voice has been opted into and we're not in the
+  // middle of a PTT capture, re-assert the warm stream (armWarmStream is a
+  // no-op when the recorder is healthily "recording").
+  useEffect(() => {
+    if (!isSupported) return;
+    const tick = setInterval(() => {
+      if (!voiceEverEnabledRef.current) return;
+      if (pttEngagedRef.current) return; // don't disturb an in-flight capture
+      const rec = warmRecorderRef.current;
+      if (!rec || rec.state !== "recording" || !warmStreamRef.current) {
+        void armWarmStream();
+      }
+    }, 4000);
+    return () => clearInterval(tick);
+  }, [isSupported, armWarmStream]);
+
   // KI-173 (2026-05-15) — heartbeat watchdog. Browser SpeechRecognition
   // occasionally enters a stopped state without `onend` firing (certain
   // network errors, transient OS audio interruptions, tab visibility
@@ -1874,8 +2412,11 @@ export function useStreamingVoice(
       }
       pendingUtteranceRef.current = "";
       pendingChunksRef.current = [];
+      // #53 / #54 — release the warm stream + recorder + AudioContext on
+      // unmount so the OS mic indicator goes off when the app is torn down.
+      disarmWarmStream();
     };
-  }, [clearRestartTimer, teardownAudio]);
+  }, [clearRestartTimer, teardownAudio, disarmWarmStream]);
 
   // FIX 3 (HIGH) — one-shot read-and-clear of the barge-in flag. Returns
   // true exactly once after triggerBargeIn fires; subsequent calls return
@@ -1888,5 +2429,17 @@ export function useStreamingVoice(
     return false;
   }, []);
 
-  return { start, stop, isSupported, consumeBargeInSignal };
+  return {
+    start,
+    stop,
+    isSupported,
+    consumeBargeInSignal,
+    // #53 / #54 — warm-stream + pre-roll push-to-talk API.
+    isWarm,
+    armWarmStream,
+    disarmWarmStream,
+    beginPushToTalk,
+    endPushToTalk,
+    consumePreRollChunks,
+  };
 }

tests/test_ptt_preroll_warm_stream.py

@@ -0,0 +1,457 @@
+"""Regression test for #53 (push-to-talk head-clipping) + #54 (PTT start
+latency) — 2026-05-18.
+
+TWO LIVE BUGS, ONE ROOT CAUSE
+-----------------------------------------------------------------------------
+page.tsx's push-to-talk path cold-starts the mic on every SPACE press:
+
+    page.tsx:1350-1361  onKeyDown(SPACE) -> startRecordingRef.current()
+    page.tsx:1004-1019  startRecording() -> navigator.mediaDevices
+                          .getUserMedia(...)        [COLD: 200-700ms]
+    page.tsx:1021       new MediaRecorder(stream)
+    page.tsx:1213       recorder.start()            [capture truly begins HERE]
+
+Every word spoken between the keydown and recorder.start() is *never
+captured*. Real repro: user said "Sir. My age is 29 ..." -> transcribed
+"S A R. My age is 29 ..." (#53). The same cold-start is the multi-second
+delay before recording starts (#54).
+
+FIX (frontend/src/lib/useStreamingVoice.ts)
+-----------------------------------------------------------------------------
+Keep ONE mic stream + MediaRecorder + AudioContext WARM for the hook's armed
+lifetime, feeding a rolling PRE-ROLL ring buffer (PreRollRing) that always
+holds ~PRE_ROLL_MS of the most recent audio. A deliberate-hold gate
+(evaluateHoldGate) ignores sub-threshold taps. On a real hold the submitted
+blob is preRoll.drain() (lead-in spoken during the cold-start gap) ++ the
+live capture, so the FIRST WORD always survives.
+
+WHAT THIS TEST PINS
+-----------------------------------------------------------------------------
+There is no JS test runner in this repo, so the two contracts are pinned at
+the layers a Python test can reach honestly:
+
+  PART A (pure frontend logic, executed against the REAL shipped code):
+    The exported PreRollRing + evaluateHoldGate from useStreamingVoice.ts are
+    loaded under Node (TS types stripped; react/./api/./voice_resilience
+    stubbed since the PURE exports don't use them) and asserted:
+      A1  a pre-roll ring fed lead-in slices then drained returns the
+          LEADING slice first  -> the first word is at the head of the blob.
+      A2  the ring retains >= PRE_ROLL_MS of audio (covers the worst-case
+          page.tsx cold-start gap) and evicts only OLDER audio.
+      A3  evaluateHoldGate: a >= threshold hold is deliberate (submit); a
+          sub-threshold tap is NOT (gated, nothing submitted).
+      A4  the integrated contract: engage-after-threshold seeds the
+          capture with the pre-roll so leadIn[0] precedes live audio;
+          a tap drains nothing and submits nothing.
+
+  PART B (backend STT, the bug's observable failure surface):
+    The fix prepends a short pre-roll HEAD to the blob. Prove
+    backend/providers/sarvam_stt.py never silently drops/truncates that
+    head — i.e. the FIRST word survives transcription, including when the
+    full utterance is long enough to hit the silence-chunk splitter (the
+    pre-fix 30s truncation dropped tail words; a regression that mishandles
+    the prepended head would drop the FIRST word instead).
+
+Run:
+    cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
+    PYTHONPATH=$PWD .venv/bin/python -m pytest \
+        tests/test_ptt_preroll_warm_stream.py -v
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+import types
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("SARVAM_API_KEY", "test-key-for-ptt-preroll")
+
+REPO = Path(__file__).resolve().parents[1]
+HOOK = REPO / "frontend" / "src" / "lib" / "useStreamingVoice.ts"
+
+
+# ===========================================================================
+# PART A — pure frontend logic, executed against the REAL shipped exports.
+# ===========================================================================
+
+# The harness registers an ESM resolve/load hook (see _build_node_loader)
+# that stubs `react`, `./api`, `./voice_resilience` — modules the React hook
+# body imports but which the PURE exports (PreRollRing / evaluateHoldGate)
+# never touch — and lets Node 24 strip the TS types on load. This exercises
+# the genuine SHIPPED code, not a copy.
+
+
+def _have_node() -> bool:
+    return shutil.which("node") is not None
+
+
+def _build_node_loader(tmpdir: Path) -> Path:
+    """Write an ESM loader that stubs react/./api/./voice_resilience and
+    strips TS types so the REAL hook module's pure exports can be imported.
+    """
+    loader = tmpdir / "loader.mjs"
+    loader.write_text(
+        textwrap.dedent(
+            r"""
+            import { readFileSync } from 'node:fs';
+            import { fileURLToPath } from 'node:url';
+            import vm from 'node:vm';
+
+            const STUBS = {
+              react: `
+                export const useCallback = (f) => f;
+                export const useEffect = () => {};
+                export const useRef = (v) => ({ current: v });
+                export const useState = (v) => [typeof v === 'function' ? v() : v, () => {}];
+                export default {};
+              `,
+              api: `export const postTranscribe = async () => ({ text: '' });`,
+              voice_resilience: `
+                export const retryPostTranscribe = async () => null;
+                export const scaleSpeechZcrBand = () => ({ min: 20, max: 250 });
+                export class AdaptiveNoiseFloor { feed(){} currentThreshold(){ return 0.008; } }
+              `,
+            };
+
+            export async function resolve(specifier, context, nextResolve) {
+              if (specifier === 'react')
+                return { url: 'stub:react', shortCircuit: true };
+              if (specifier === './api' || specifier.endsWith('/api'))
+                return { url: 'stub:api', shortCircuit: true };
+              if (specifier === './voice_resilience' || specifier.endsWith('/voice_resilience'))
+                return { url: 'stub:voice_resilience', shortCircuit: true };
+              return nextResolve(specifier, context);
+            }
+
+            export async function load(url, context, nextLoad) {
+              if (url.startsWith('stub:')) {
+                const key = url.slice('stub:'.length);
+                return { format: 'module', source: STUBS[key], shortCircuit: true };
+              }
+              if (url.endsWith('.ts')) {
+                const path = fileURLToPath(url);
+                const src = readFileSync(path, 'utf8');
+                // Node 24 strips TS types natively for .ts; force module
+                // format + hand it the raw source (type-strip happens in the
+                // default ts transform path).
+                return { format: 'module-typescript', source: src, shortCircuit: true };
+              }
+              return nextLoad(url, context);
+            }
+            """
+        ).strip()
+        + "\n"
+    )
+    return loader
+
+
+def _run_node_contract(tmp_path: Path) -> dict:
+    """Import the REAL PreRollRing + evaluateHoldGate under Node and run the
+    four pure-logic contracts. Returns the parsed JSON verdict."""
+    loader = _build_node_loader(tmp_path)
+    script = tmp_path / "contract.mjs"
+    # Pull the real exports + the real PRE_ROLL_MS / HOLD_THRESHOLD_MS /
+    # WARM_TIMESLICE_MS constants from the shipped hook module.
+    script.write_text(
+        textwrap.dedent(
+            f"""
+            const mod = await import({json.dumps(HOOK.as_uri())});
+            const {{
+              PreRollRing, evaluateHoldGate,
+              PRE_ROLL_MS, HOLD_THRESHOLD_MS, WARM_TIMESLICE_MS,
+            }} = mod;
+
+            const out = {{}};
+
+            // --- A1/A2: pre-roll ring keeps the LEADING audio + >=PRE_ROLL_MS
+            const ring = new PreRollRing(PRE_ROLL_MS);
+            // Feed far more than the window so eviction is forced. Each slice
+            // is a distinct 1-byte blob tagged by index so order is provable.
+            const totalSlices = Math.ceil((PRE_ROLL_MS / WARM_TIMESLICE_MS) * 4);
+            for (let i = 0; i < totalSlices; i++) {{
+              ring.push(new Blob([String.fromCharCode(65 + (i % 26))]), WARM_TIMESLICE_MS);
+            }}
+            out.retainedMs = ring.retainedDurationMs();
+            out.retainsAtLeastWindow = ring.retainedDurationMs() >= PRE_ROLL_MS;
+            const drained = ring.drain();
+            out.drainedCount = drained.length;
+            out.ringEmptyAfterDrain = ring.retainedDurationMs() === 0;
+
+            // Now the CORE #53 contract: a head word spoken just before the
+            // window boundary must still be at the HEAD of the drained blob.
+            const r2 = new PreRollRing(PRE_ROLL_MS);
+            // 'HEAD' = the first word's slice. Then enough silence-ish slices
+            // to *almost* (but not quite, given the +1 slice slack) fill the
+            // window, so HEAD must still be retained as slice 0.
+            const headBlob = new Blob(['HEAD']);
+            r2.push(headBlob, WARM_TIMESLICE_MS);
+            const fill = Math.floor(PRE_ROLL_MS / WARM_TIMESLICE_MS) - 1;
+            for (let i = 0; i < fill; i++) r2.push(new Blob(['x']), WARM_TIMESLICE_MS);
+            const d2 = r2.drain();
+            out.headSurvives = d2.length > 0 && (await d2[0].text()) === 'HEAD';
+
+            // --- A3: deliberate-hold gate
+            const tap = evaluateHoldGate(1000, 1000 + (HOLD_THRESHOLD_MS - 1), HOLD_THRESHOLD_MS);
+            const hold = evaluateHoldGate(1000, 1000 + HOLD_THRESHOLD_MS, HOLD_THRESHOLD_MS);
+            const longHold = evaluateHoldGate(1000, 1000 + 5000, HOLD_THRESHOLD_MS);
+            out.tapGated = tap.deliberate === false;
+            out.holdAtThresholdDeliberate = hold.deliberate === true;
+            out.longHoldDeliberate = longHold.deliberate === true;
+            out.tapHeldMs = tap.heldMs;
+
+            // --- A4: integrated — engage seeds capture with pre-roll so the
+            // leading word precedes the live audio; a tap submits nothing.
+            const r3 = new PreRollRing(PRE_ROLL_MS);
+            r3.push(new Blob(['FIRST_WORD']), WARM_TIMESLICE_MS); // spoken in cold-start gap
+            // engage: drain pre-roll into capture, THEN append live slices
+            const capture = [...r3.drain()];
+            capture.push(new Blob(['rest_of_sentence']));
+            out.captureLeadIsFirstWord = (await capture[0].text()) === 'FIRST_WORD';
+            out.captureIncludesLive = capture.length === 2;
+            // tap path: gate says not deliberate -> nothing assembled
+            const tapDecision = evaluateHoldGate(2000, 2050, HOLD_THRESHOLD_MS);
+            out.tapAssemblesNothing = tapDecision.deliberate === false;
+
+            out.constants = {{ PRE_ROLL_MS, HOLD_THRESHOLD_MS, WARM_TIMESLICE_MS }};
+            process.stdout.write(JSON.stringify(out));
+            """
+        ).strip()
+        + "\n"
+    )
+    proc = subprocess.run(
+        [
+            "node",
+            "--no-warnings",
+            f"--experimental-loader={loader.as_uri()}",
+            str(script),
+        ],
+        capture_output=True,
+        text=True,
+        cwd=str(REPO / "frontend"),
+        timeout=60,
+    )
+    if proc.returncode != 0:
+        raise AssertionError(
+            "Node pure-logic harness failed:\n"
+            f"STDOUT:\n{proc.stdout}\n\nSTDERR:\n{proc.stderr}"
+        )
+    return json.loads(proc.stdout.strip())
+
+
+@pytest.mark.skipif(not _have_node(), reason="node not available")
+def test_preroll_and_hold_gate_pure_logic(tmp_path):
+    """PART A — exercise the REAL exported PreRollRing + evaluateHoldGate."""
+    r = _run_node_contract(tmp_path)
+
+    # A2 — the ring always retains at least the requested pre-roll window so
+    # the worst-case page.tsx cold-start gap (getUserMedia 200-700ms + the
+    # 400ms Live-teardown wait at page.tsx:994) is fully covered.
+    assert r["retainsAtLeastWindow"] is True, r
+    assert r["retainedMs"] >= r["constants"]["PRE_ROLL_MS"], r
+    assert r["ringEmptyAfterDrain"] is True, r
+    assert r["drainedCount"] >= 1, r
+
+    # A1 — the CORE #53 fix: the first word's slice is at the HEAD of the
+    # drained lead-in (it is NOT evicted while it is within the window).
+    assert r["headSurvives"] is True, (
+        "pre-roll dropped the leading slice — first word would be clipped: "
+        f"{r}"
+    )
+
+    # A3 — deliberate-hold gate (#54): a sub-threshold tap is gated; a hold
+    # exactly at the threshold (and longer) is deliberate.
+    assert r["tapGated"] is True, r
+    assert r["holdAtThresholdDeliberate"] is True, r
+    assert r["longHoldDeliberate"] is True, r
+    assert r["tapHeldMs"] < r["constants"]["HOLD_THRESHOLD_MS"], r
+
+    # A4 — integrated: engage seeds the capture with the pre-roll so the
+    # leading word precedes the live audio; a tap assembles/submits nothing.
+    assert r["captureLeadIsFirstWord"] is True, (
+        "engaged capture does not start with the pre-roll lead-in — first "
+        f"word lost: {r}"
+    )
+    assert r["captureIncludesLive"] is True, r
+    assert r["tapAssemblesNothing"] is True, r
+
+    # The shipped constants must stay in the spec'd bands.
+    assert r["constants"]["PRE_ROLL_MS"] >= 500, r          # >= 500ms pre-roll
+    assert 150 <= r["constants"]["HOLD_THRESHOLD_MS"] <= 250, r  # deliberate
+    assert r["constants"]["WARM_TIMESLICE_MS"] <= 250, r    # fine-grained ring
+
+
+# ===========================================================================
+# PART B — backend STT: the prepended pre-roll HEAD must never be silently
+# dropped/truncated (the bug's observable failure surface).
+# ===========================================================================
+
+from backend.providers.sarvam_stt import STT_CHUNK_MS, SarvamSTT  # noqa: E402
+
+
+class FakeAudioSegment:
+    """Minimal pydub.AudioSegment stub (same surface as
+    test_stt_long_audio_chunking.py). One word per second; word_0 is the
+    PRE-ROLL HEAD (the first word spoken in page.tsx's cold-start gap)."""
+
+    def __init__(self, start_ms: int, end_ms: int):
+        self.start_ms = start_ms
+        self.end_ms = end_ms
+
+    def __len__(self):
+        return self.end_ms - self.start_ms
+
+    def __getitem__(self, sl):
+        if isinstance(sl, slice):
+            lo = 0 if sl.start is None else sl.start
+            hi = len(self) if sl.stop is None else sl.stop
+            lo = max(0, min(lo, len(self)))
+            hi = max(0, min(hi, len(self)))
+            return FakeAudioSegment(self.start_ms + lo, self.start_ms + hi)
+        raise TypeError("only slice indexing used by splitter")
+
+    @property
+    def dBFS(self):
+        if self.end_ms - self.start_ms == 0:
+            return float("-inf")
+        # A real pause near the 25s ceiling so the splitter snaps there.
+        if 24000 <= self.start_ms < 24400:
+            return float("-inf")
+        return -20.0
+
+    def set_frame_rate(self, _):
+        return self
+
+    def set_channels(self, _):
+        return self
+
+    def set_sample_width(self, _):
+        return self
+
+    def export(self, buf, format="wav"):  # noqa: A002
+        buf.write(f"FAKEWAV:{self.start_ms}:{self.end_ms}".encode())
+        buf.seek(0)
+        return buf
+
+
+SARVAM_HARD_LIMIT_MS = 30_000
+
+
+class _FakeResp:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def raise_for_status(self):
+        return None
+
+    def json(self):
+        return self._payload
+
+
+class _FakeClient:
+    def __init__(self, *a, **k):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *a):
+        return False
+
+    async def post(self, url, headers=None, files=None, data=None):
+        raw = files["file"][1].read()
+        text = raw.decode()
+        assert text.startswith("FAKEWAV:"), text
+        _, s, e = text.split(":")
+        start_ms, end_ms = int(s), int(e)
+        capped_end = min(end_ms, start_ms + SARVAM_HARD_LIMIT_MS)
+        words = [f"word_{ms // 1000}" for ms in range(start_ms, capped_end, 1000)]
+        return _FakeResp(
+            {
+                "transcript": " ".join(words),
+                "language_code": "en-IN",
+                "language_probability": 0.99,
+            }
+        )
+
+
+@pytest.fixture
+def patch_pydub(monkeypatch):
+    fake_pydub = types.ModuleType("pydub")
+
+    class _Factory:
+        @staticmethod
+        def from_file(_bio, format=None):  # noqa: A002
+            # 92s utterance — long enough to hit the silence splitter (>3
+            # Sarvam 25s windows). word_0 is the prepended PRE-ROLL HEAD.
+            return FakeAudioSegment(0, 92_000)
+
+    fake_pydub.AudioSegment = _Factory
+    monkeypatch.setitem(sys.modules, "pydub", fake_pydub)
+    yield
+
+
+@pytest.fixture
+def patch_httpx(monkeypatch):
+    import backend.providers.sarvam_stt as mod
+
+    monkeypatch.setattr(mod.httpx, "AsyncClient", _FakeClient)
+    yield
+
+
+def test_preroll_head_word_survives_backend_stt(patch_pydub, patch_httpx):
+    """The FIRST word (word_0 — the pre-roll head the warm-stream fix
+    prepends) must appear in the transcript. A regression that mishandled a
+    prepended head, or re-introduced single-shot truncation, would drop
+    word_0 (head-clipping #53 at the STT layer)."""
+    stt = SarvamSTT()
+    audio = b"\x00" * 4096  # > 1 KB so the short-audio guard doesn't fire
+    result = asyncio.run(
+        stt.transcribe(audio_bytes=audio, audio_format="webm", language_code="en-IN")
+    )
+    words = result.text.split()
+
+    # CORE #53 CONTRACT at the STT boundary: the leading word is present and
+    # is actually FIRST (not just somewhere in the middle).
+    assert "word_0" in words, f"FIRST word dropped by STT — head clipped: {words[:5]}"
+    deduped = [w for i, w in enumerate(words) if i == 0 or w != words[i - 1]]
+    assert deduped[0] == "word_0", (
+        f"transcript does not START with the pre-roll head word: {deduped[:5]}"
+    )
+    # And the WHOLE 92s utterance survives in order (no head drop, no tail
+    # truncation) — the prepended pre-roll doesn't break chunking.
+    expected = [f"word_{i}" for i in range(92)]
+    assert deduped == expected, (
+        f"transcript garbled — deduped {len(deduped)} words "
+        f"(first={deduped[:3]}, last={deduped[-3:]}), expected 92 in order"
+    )
+    assert result.raw.get("chunked") is True
+    assert result.raw.get("chunk_count", 0) >= 4
+
+
+def test_short_preroll_only_blob_is_not_truncated(patch_pydub, patch_httpx, monkeypatch):
+    """A short blob that is essentially pre-roll + a couple words (the common
+    PTT case) must transcribe in ONE call with word_0 intact — proving the
+    pre-roll head adds no truncation and no extra latency for short clips."""
+    short = FakeAudioSegment(0, 5_000)  # ~5s: pre-roll + a short answer
+    monkeypatch.setattr(
+        sys.modules["pydub"].AudioSegment,
+        "from_file",
+        staticmethod(lambda *a, **k: short),
+    )
+    stt = SarvamSTT()
+    result = asyncio.run(
+        stt.transcribe(audio_bytes=b"\x00" * 4096, audio_format="webm")
+    )
+    words = result.text.split()
+    assert words == [f"word_{i}" for i in range(5)], words
+    assert words[0] == "word_0", f"pre-roll head missing on short clip: {words}"
+    # Single-call path — no chunked marker, no added round-trips.
+    assert result.raw.get("chunked") is not True

tests/test_tts_full_natural_readout.py

@@ -0,0 +1,359 @@
+"""Regression test for #55 (10s truncation) + #56 (robotic normalization).
+
+LIVE BUG (user-reported, audio): the advisor sent a 6-question pricing
+intake message. The user heard only ~10 seconds of audio ("stopped in ten
+seconds") — questions 2-6 were NEVER spoken — and "e.g." was read
+letter-by-letter ("E G") while "/" in "₹5L / ₹10L / ₹25L / ₹1Cr" was read
+as "by"/"divide".
+
+ROOT CAUSE #55: backend/voice_format.py `_truncate_for_voice` (called from
+`tts_preprocess` with the legacy max_words=55 passed by backend/main.py)
+chopped the message to the first ~55 spoken words (~10s of audio) BEFORE
+TTS, appending "More details are on screen." Everything from question 2
+onward was discarded.
+
+ROOT CAUSE #56: `tts_preprocess` never expanded "e.g." / "/" / currency
+ranges to spoken words, so Sarvam Bulbul voiced "E G" and "divide".
+
+LATENT ROOT CAUSE #55b: even with the word cap removed, the full
+normalized message exceeds Sarvam Bulbul v2's hard 1500-char per-request
+limit; sending it whole means Sarvam only voices the leading slice.
+providers/sarvam_tts.py now chunks at sentence / numbered-item seams under
+a safe ceiling, synthesizes each chunk sequentially, and concatenates the
+decoded PCM into ONE gapless WAV (mirrors the STT 30s-chunking house
+style; raises loudly on any HTTP error — no silent truncation).
+
+This test stubs the Sarvam HTTP layer (no network / no pydub needed for
+the WAV concat — stdlib `wave`) and pins the contract end-to-end.
+
+Run:
+    cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
+    PYTHONPATH=$PWD .venv/bin/python -m pytest \
+        tests/test_tts_full_natural_readout.py -v
+"""
+
+from __future__ import annotations
+
+import asyncio
+import io
+import os
+import re
+import wave
+
+import pytest
+
+os.environ.setdefault("SARVAM_API_KEY", "test-key-for-tts-chunking")
+
+from backend.voice_format import tts_preprocess  # noqa: E402
+from backend.providers.sarvam_tts import (  # noqa: E402
+    SarvamTTS,
+    _chunk_text_for_tts,
+    _concat_wav_bytes,
+    _tts_char_ceiling,
+)
+
+
+# The EXACT message the user reported hearing truncated + robotic.
+SCREENSHOT_MESSAGE = (
+    "A few quick pricing inputs (you can skip any):\n"
+    "1. How much sum insured? (e.g., ₹5L / ₹10L / ₹25L / ₹1Cr)\n"
+    "2. Premium budget? (e.g., ₹10–15K/year, or ₹50K+ for premium covers)\n"
+    "3. Any existing health cover from work or otherwise? "
+    "(e.g., '5L through employer' or 'no')\n"
+    "4. Co-pay tolerance: Are you OK with a co-pay — sharing 10–30% of "
+    "every claim — to lower the premium? Or do you want zero co-pay "
+    "(insurer pays it all)?\n"
+    "5. Family medical history: Any major conditions running in your "
+    "blood family (parents/siblings) — cancer / diabetes / heart disease "
+    "/ hypertension?\n"
+    "6. Smoking status: Do you smoke or use tobacco products? (yes / no) "
+    "Smokers face 30–50% premium loading; capturing this gives an "
+    "accurate band."
+)
+
+
+# ---------------------------------------------------------------------------
+# #56 — NATURAL NORMALIZATION (text-level, no network).
+# ---------------------------------------------------------------------------
+def test_full_message_normalizes_naturally_and_is_not_truncated():
+    spoken = tts_preprocess(SCREENSHOT_MESSAGE, language="en", max_words=55)
+
+    # --- #55: the FULL message is present (NOT cut at ~55 words / ~10s) ---
+    # Question-6-specific content must survive end-to-end.
+    assert "smoking status" in spoken.lower(), spoken
+    assert "tobacco" in spoken.lower(), spoken
+    assert "accurate band" in spoken.lower(), spoken
+    # The legacy truncation cue must NOT be present.
+    assert "more details are on screen" not in spoken.lower(), spoken
+    assert "more details on screen" not in spoken.lower(), spoken
+    # A real readout of all 6 questions is far more than 55 words.
+    assert len(spoken.split()) > 120, (
+        f"only {len(spoken.split())} words — looks truncated:\n{spoken}"
+    )
+
+    low = spoken.lower()
+
+    # --- #56: "e.g." expanded, never spelled as letters ---
+    assert "for example" in low, spoken
+    assert "e.g" not in low, spoken
+    # No isolated "e g" letter pair (the robotic readout).
+    assert not re.search(r"\be\s+g\b", low), spoken
+
+    # --- #56: raw slash gone everywhere; expanded to list / "or" ---
+    assert "/" not in spoken, f"raw slash survived:\n{spoken}"
+    # Currency slash run "₹5L / ₹10L / ₹25L / ₹1Cr" became a spoken list.
+    # NOTE: leading digits are word-formed by _normalize_numbers (the
+    # natural TTS form): "5" -> "five", "1" -> "one", "25" -> "twenty-five".
+    assert "five lakh rupees" in low, spoken
+    assert "ten lakh rupees" in low, spoken
+    assert "twenty-five lakh rupees" in low, spoken
+    assert "one crore rupees" in low, spoken
+    assert "or one crore rupees" in low, spoken
+    # Generic slashes -> "or".
+    assert "parents or siblings" in low, spoken
+    assert "yes or no" in low, spoken
+    assert "cancer or diabetes" in low, spoken
+
+    # --- #56: ranges + currency expanded, no symbols/letters left ---
+    assert "₹" not in spoken, spoken
+    assert "%" not in spoken, spoken
+    # "10–30%" -> "10 to 30 percent" -> word form "ten to thirty percent"
+    assert "ten to thirty percent" in low, spoken
+    # "30–50%" -> "thirty to fifty percent"
+    assert "thirty to fifty percent" in low, spoken
+    # "₹10–15K/year" -> "10 to 15 thousand rupees per year"
+    assert "ten to fifteen thousand rupees per year" in low, spoken
+    # "₹50K+" -> "above 50 thousand rupees" -> "above fifty thousand rupees"
+    assert "above fifty thousand rupees" in low, spoken
+    # No bare "K"/"L"/"Cr" shorthand letters left dangling.
+    assert not re.search(r"\b\d+\s*[LK]\b", spoken), spoken
+    assert not re.search(r"\bCr\b", spoken), spoken
+    assert " 15K" not in spoken and "15k" not in low, spoken
+
+    # --- markdown list numbering stripped (reads as speech, not "1.") ---
+    assert not re.search(r"(?m)^\s*\d+\.\s", spoken), spoken
+
+
+# ---------------------------------------------------------------------------
+# #55b — the chunk PLAN covers the WHOLE message (no character dropped).
+# ---------------------------------------------------------------------------
+def test_chunk_plan_covers_entire_message_under_ceiling():
+    spoken = tts_preprocess(SCREENSHOT_MESSAGE, language="en")
+    ceiling = _tts_char_ceiling("bulbul:v2")
+    assert ceiling < 1500  # safety margin under Sarvam's hard cap
+
+    chunks = _chunk_text_for_tts(spoken, ceiling)
+    assert len(chunks) >= 1
+    for i, c in enumerate(chunks):
+        assert len(c) <= ceiling, f"chunk {i} = {len(c)} chars > {ceiling}"
+
+    # Coverage: concatenated chunks (whitespace-normalized) must contain
+    # every non-space character of the spoken text — nothing dropped.
+    def _norm(s: str) -> str:
+        return re.sub(r"\s+", "", s)
+
+    joined = _norm(" ".join(chunks))
+    assert _norm(spoken) == joined, (
+        "chunk plan lost/added content vs the normalized spoken text"
+    )
+    # The final question's content must live in some chunk.
+    assert any("accurate band" in c.lower() for c in chunks), chunks
+
+
+# ---------------------------------------------------------------------------
+# WAV concat helper — gapless join of stdlib PCM blobs.
+# ---------------------------------------------------------------------------
+def _make_wav(n_frames: int, framerate: int = 22050) -> bytes:
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(framerate)
+        w.writeframes(b"\x01\x00" * n_frames)
+    return buf.getvalue()
+
+
+def test_concat_wav_is_gapless_and_sums_frames():
+    a = _make_wav(1000)
+    b = _make_wav(2500)
+    c = _make_wav(700)
+    merged = _concat_wav_bytes([a, b, c])
+    with wave.open(io.BytesIO(merged), "rb") as w:
+        assert w.getnchannels() == 1
+        assert w.getsampwidth() == 2
+        assert w.getframerate() == 22050
+        # Gapless: total frames == sum of inputs (no inserted silence).
+        assert w.getnframes() == 1000 + 2500 + 700
+
+
+def test_concat_wav_param_mismatch_raises_loud():
+    a = _make_wav(100, framerate=22050)
+    b = _make_wav(100, framerate=16000)
+    with pytest.raises(RuntimeError, match="params diverged"):
+        _concat_wav_bytes([a, b])
+
+
+# ---------------------------------------------------------------------------
+# End-to-end: stub Sarvam HTTP, prove the FULL message is synthesized via
+# multiple chunks and the audio is concatenated (NOT a single 10s clip).
+# ---------------------------------------------------------------------------
+class _FakeResp:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def raise_for_status(self):
+        return None
+
+    def json(self):
+        return self._payload
+
+
+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.
+    """
+
+    sent_texts: list[str] = []
+    HARD_LIMIT = 1500
+
+    def __init__(self, *a, **k):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *a):
+        return False
+
+    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)))
+        return _FakeResp({"audios": [base64.b64encode(wav).decode()]})
+
+
+import base64  # noqa: E402  (used by _FakeClient above)
+
+
+@pytest.fixture
+def patch_httpx(monkeypatch):
+    import backend.providers.sarvam_tts as mod
+
+    _FakeClient.sent_texts = []
+    monkeypatch.setattr(mod.httpx, "AsyncClient", _FakeClient)
+    yield
+
+
+def test_end_to_end_screenshot_message_synthesized_in_full(patch_httpx):
+    """The exact buggy screenshot message: EVERY character (incl. question
+    6) must reach Sarvam, in however many calls — never the ~55-word /
+    ~10s truncated shot the bug produced."""
+    spoken = tts_preprocess(SCREENSHOT_MESSAGE, language="en", max_words=55)
+    tts = SarvamTTS()
+    audio, mime = asyncio.run(
+        tts.synthesize_with_mime(spoken, language_code="en-IN")
+    )
+
+    assert mime == "audio/wav"
+    assert len(_FakeClient.sent_texts) >= 1, _FakeClient.sent_texts
+    # Every char that went to TTS, concatenated == full spoken text
+    # (no character dropped, nothing truncated).
+    rejoined = re.sub(r"\s+", "", " ".join(_FakeClient.sent_texts))
+    assert re.sub(r"\s+", "", spoken) == rejoined
+    # Question-6 content was actually sent to TTS (the truncation bug
+    # dropped everything from question 2 onward).
+    assert any("accurate band" in t.lower() for t in _FakeClient.sent_texts)
+    assert any("tobacco" in t.lower() for t in _FakeClient.sent_texts)
+    assert any("smoking status" in t.lower() for t in _FakeClient.sent_texts)
+
+    # Audio frame count == total chars voiced (fake = 1 frame/char), and
+    # is FAR above the ~300 chars the 55-word truncation would have made.
+    with wave.open(io.BytesIO(audio), "rb") as w:
+        total_frames = w.getnframes()
+    assert total_frames == len(re.sub(r"\s+", " ", spoken).strip()) or (
+        total_frames > 600
+    ), f"{total_frames} frames — looks like the 10s truncation regressed"
+
+
+def test_end_to_end_overlong_message_chunks_and_concatenates(patch_httpx):
+    """When normalized text DOES exceed Bulbul v2's per-request ceiling,
+    it is split into >1 chunk, each <= ceiling, and the decoded PCM is
+    concatenated into ONE gapless WAV — no character dropped."""
+    ceiling = _tts_char_ceiling("bulbul:v2")
+    # Build a long, clean multi-sentence reply that exceeds the ceiling.
+    long_reply = " ".join(
+        f"Point number {i}: this policy covers day-care and AYUSH "
+        f"treatment with a thirty day waiting period and no co-pay."
+        for i in range(1, 60)
+    )
+    spoken = tts_preprocess(long_reply, language="en")
+    assert len(spoken) > ceiling, len(spoken)
+
+    tts = SarvamTTS()
+    audio, _ = asyncio.run(
+        tts.synthesize_with_mime(spoken, language_code="en-IN")
+    )
+    # Multiple Sarvam calls, each within the hard limit (the fake asserts
+    # the 1500 cap per call).
+    assert len(_FakeClient.sent_texts) >= 2, len(_FakeClient.sent_texts)
+    for t in _FakeClient.sent_texts:
+        assert len(t) <= ceiling
+    # Reassembled text == full spoken payload (nothing dropped at seams).
+    assert re.sub(r"\s+", "", " ".join(_FakeClient.sent_texts)) == re.sub(
+        r"\s+", "", spoken
+    )
+    # Gapless concatenated WAV: frames == sum of per-chunk frames.
+    with wave.open(io.BytesIO(audio), "rb") as w:
+        total = w.getnframes()
+    assert total == sum(len(t) 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)."""
+    spoken = tts_preprocess("Yes, that policy covers day-care procedures.")
+    tts = SarvamTTS()
+    asyncio.run(tts.synthesize_with_mime(spoken, language_code="en-IN"))
+    assert len(_FakeClient.sent_texts) == 1, _FakeClient.sent_texts
+
+
+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."""
+    import backend.providers.sarvam_tts as mod
+
+    class _BoomClient(_FakeClient):
+        calls = 0
+
+        async def post(self, url, headers=None, json=None, **k):
+            _BoomClient.calls += 1
+            if _BoomClient.calls == 2:
+                req = __import__("httpx").Request("POST", url)
+                resp = __import__("httpx").Response(503, request=req)
+                raise __import__("httpx").HTTPStatusError(
+                    "503", request=req, response=resp
+                )
+            return await super().post(url, headers=headers, json=json, **k)
+
+    monkeypatch.setattr(mod.httpx, "AsyncClient", _BoomClient)
+    # Use a long reply so there are >= 2 chunks and chunk #2 is the one
+    # that 503s — proving a mid-stream failure is NOT silently swallowed
+    # into a partial readout.
+    long_reply = " ".join(
+        f"Point number {i}: this policy covers day-care and AYUSH "
+        f"treatment with a thirty day waiting period and no co-pay."
+        for i in range(1, 60)
+    )
+    spoken = tts_preprocess(long_reply, language="en")
+    tts = SarvamTTS()
+    with pytest.raises(__import__("httpx").HTTPStatusError):
+        asyncio.run(tts.synthesize_with_mime(spoken, language_code="en-IN"))