fix(chat+marketplace+voice): KI-145 + KI-148 + KI-149 + KI-150 bundle

Five fixes from the live-test feedback cycle, all converged into one
rebuild.

KI-145 final (166 marketplace cards) — replaced strict-UIN merge with
field-comparison rule. Same UIN + <2 decision-critical diffs (copay, PED
waiting, maternity coverage+waiting, room rent, restoration, NCB,
post-hospitalization) -> merge as alias. Same UIN + 2+ material diffs ->
keep as separate card (true sub-variants). Result: ProHealth Prime +
Protect, Reassure 3, ICICI Elevate, Activ Assure Diamond and 18 others
correctly emit as standalone cards. 166 cards = 137 extracted-dedup
+ 29 curated standalone (variants + non-UIN-match).

KI-148 (TTS pronunciation) — voice_format.py tts_preprocess now expands
'15k' -> '15 thousand rupees', '1L' -> '1 lakh rupees', '1cr' ->
'1 crore rupees', '15-30k' -> '15 to 30 thousand rupees', '60k+' ->
'above 60 thousand rupees'. Context-gated so '10K marathon' stays
untouched. Stops the bot from reading '₹15k' as 'fifteen k'.

KI-149 (budget + income parser) — needs_finder.py budget and
income_band Questions had no parser; bare numerals like '30000' or
phrases like 'I maximum 30000 I can pay' returned None, the LLM bailed,
orchestrator re-asked the same question. Added _parse_inr_amount +
_parse_budget_band + _parse_income_band helpers; attached as parser= on
both Questions. fact_find_normalizer.py _keyword_normalize delegates
to the same helpers so the LLM brain's greedy capture path also picks
up bare-number budgets. Handles k/lakh/L/cr, ranges, '+' upper buckets,
'maximum X', 'around X', 'I can pay X'.

KI-150 (max_tokens) — fact_find_brain.py was calling llm_fast.chat
with max_tokens=420. System prompt's contract requires prose (~250 tok)
+ <FF>...</FF> trailer (~80 tok) + safety margin. Verbose multi-slot
replies got truncated mid-prose before the trailer, parser failed,
canonical fallback fired, user saw scripted prompt_en (the 'robotic
language' complaint). Bumped 420 -> 700 at both call sites. Inside the
25s outer wait_for budget.

Verified localhost after restart:
/api/policies/all .total = 166, .insurers_indexed = 20
/api/chat with 'I am Rohit, 29' returns conversational nim-chain
reply at 13s, not scripted fallback
tts_preprocess samples all expand correctly to natural speech
budget parser captures 'I maximum 30000 I can pay' -> 30k_60k

No DATASET_CACHE_BUST bump — none of these touch the Chroma corpus.

backend/fact_find_brain.py

@@ -459,7 +459,12 @@ async def drive_fact_find(
     llm_fast = get_fast_brain_llm()
     try:
         result = await asyncio.wait_for(
-            llm_fast.chat(messages=messages, temperature=0.6, max_tokens=420),
+            # KI-150 (2026-05-15) — bumped 420 → 700. Diagnosis showed the
+            # contract requires prose (~250 tok) + <FF>...</FF> trailer
+            # (~80 tok); 420 truncated verbose multi-slot replies before
+            # the trailer, parser failed, canonical fallback fired, user
+            # saw scripted prompt_en (the "robotic language" complaint).
+            llm_fast.chat(messages=messages, temperature=0.6, max_tokens=700),
             timeout=_TIMEOUT_S,
         )
     except asyncio.TimeoutError:
@@ -475,7 +480,8 @@ async def drive_fact_find(
         llm_heavy = get_brain_llm()
         try:
             result = await asyncio.wait_for(
-                llm_heavy.chat(messages=messages, temperature=0.6, max_tokens=420),
+                # KI-150 — same bump on escalation path for consistency.
+                llm_heavy.chat(messages=messages, temperature=0.6, max_tokens=700),
                 timeout=_TIMEOUT_S_ESCALATION,
             )
         except asyncio.TimeoutError:

backend/fact_find_normalizer.py

@@ -168,19 +168,12 @@ def _keyword_normalize(question_id: str, raw_text: str) -> Any:
             return "self"
 
     elif question_id == "income_band":
-        import re as _re
-        if _re.search(r"(more than|above|over|>=?|>)\s*25", s) or "25l+" in s or "25 lakh+" in s:
-            return "25L+"
-        m = _re.search(r"(\d+(?:\.\d+)?)\s*(?:l|lakh|lac)", s)
-        if m:
-            val = float(m.group(1))
-            if val >= 25: return "25L+"
-            if val >= 10: return "10L-25L"
-            if val >= 5:  return "5L-10L"
-            return "under_5L"
-        if "10-25" in s or "10l-25l" in s: return "10L-25L"
-        if "5-10"  in s or "5l-10l"  in s: return "5L-10L"
-        if "under 5" in s or "<5" in s or "below 5" in s: return "under_5L"
+        # KI-149 (2026-05-15) — delegate to needs_finder._parse_income_band so
+        # bare digits ("500000"), "thousand"/"grand"/"k" suffixes, and "₹"
+        # prefixes all parse identically here AND in the GRAPH parser used by
+        # `record_answer`. Single source of truth.
+        from backend.needs_finder import _parse_income_band
+        return _parse_income_band(raw_text)
 
     elif question_id == "primary_goal":
         if any(k in s for k in ["first policy", "first one", "first time", "first buy", "new policy", "buying my first"]):
@@ -208,22 +201,13 @@ def _keyword_normalize(question_id: str, raw_text: str) -> Any:
         if "tier 3" in s or "tier3" in s or "village" in s or "small town" in s: return "tier3"
 
     elif question_id == "budget":
-        import re as _re
-        if "60k+" in s or ">60k" in s or "more than 60" in s or "above 60" in s:
-            return "60k+"
-        if "30-60" in s or "30k_60k" in s or "30k-60k" in s:
-            return "30k_60k"
-        if "15-30" in s or "15k_30k" in s or "15k-30k" in s:
-            return "15k_30k"
-        if "under 15" in s or "<15" in s or "below 15" in s or "under_15" in s:
-            return "under_15k"
-        m = _re.search(r"(\d+)\s*k", s)
-        if m:
-            v = int(m.group(1))
-            if v >= 60: return "60k+"
-            if v >= 30: return "30k_60k"
-            if v >= 15: return "15k_30k"
-            return "under_15k"
+        # KI-149 (2026-05-15) — delegate to needs_finder._parse_budget_band so
+        # "I maximum 30000 I can pay" / "30 thousand" / "₹30,000" / "30 grand"
+        # / bare "30000" all parse the same way the GRAPH parser does. The
+        # keyword path used to require a "k" suffix and lost bare-digit
+        # answers (user reported re-ask bug on live HF Space).
+        from backend.needs_finder import _parse_budget_band
+        return _parse_budget_band(raw_text)
 
     elif question_id == "health_conditions":
         if any(p in s for p in ["none", "no condition", "nothing", "no pre-exist", "no health", "no chronic"]):

backend/main.py

@@ -633,6 +633,11 @@ async def coverage():
 
     direct_parent_cov: dict[str, str] = {}
     curated_canonical_ids_cov: list[str] = []
+    # KI-145 — curated entries that failed the material-diffs gate (same UIN
+    # or source-PDF as a pass-1 card but >= 2 decision-critical fields
+    # disagree). These must emit as standalone pass-2 cards so the coverage
+    # policy_count stays in lockstep with /api/policies/all.
+    ki145_variant_curated_ids_cov: set[str] = set()
 
     # Phase B — walk curated entries deterministically (sorted by policy_id).
     for curated_pid, cdata in sorted(curated_facts.items()):
@@ -657,24 +662,31 @@ async def coverage():
             # VARIANT and stays as its own card. Pure RENAME (< 2 diffs)
             # falls through to the alias-merge as before.
             candidate = uin_to_parent_cov[curated_uin]
-            ext_data = extracted_data_cov.get(candidate, {})
-            if _ki145_material_diffs(cdata, ext_data) < 2:
+            # Candidate may be extracted OR curated — fall back to curated
+            # facts when no extracted JSON exists, so the diff has real data.
+            cand_data = extracted_data_cov.get(candidate) or curated_facts.get(candidate, {})
+            if _ki145_material_diffs(cdata, cand_data) < 2:
                 parent_id = candidate
+            else:
+                ki145_variant_curated_ids_cov.add(curated_pid)
         elif curated_uin:
+            # New UIN — claim it. KI-145 spec: UIN unmatched against any
+            # extracted parent = standalone. Flag so pass-2 emits even if
+            # policy_id is a prefix of a seen extracted id.
             uin_to_parent_cov[curated_uin] = curated_pid
+            ki145_variant_curated_ids_cov.add(curated_pid)
 
-        if parent_id is None:
-            # KI-142 — fall back to source_pdf gate when UIN doesn't match
-            # any prior claimant (curated UIN may be more accurate than
-            # extracted; multi-variant PDFs naturally share one filing).
+        if parent_id is None and not curated_uin:
+            # KI-142 (preserved): source-PDF fallback only when curated entry
+            # has NO UIN. When UIN is present but unmatched, KI-145 spec
+            # mandates standalone — PDF coincidence cannot override.
             fb_parent = _source_pdf_to_policy_id(cdata.get("_primary_source_pdf"))
             if fb_parent and fb_parent in extracted_stems_cov and fb_parent != curated_pid:
-                # KI-145 — same material-diff gate on the source-PDF path so
-                # multi-variant PDFs don't drag genuinely different products
-                # onto the first claimant via source-PDF coincidence.
                 ext_data = extracted_data_cov.get(fb_parent, {})
                 if _ki145_material_diffs(cdata, ext_data) < 2:
                     parent_id = fb_parent
+                else:
+                    ki145_variant_curated_ids_cov.add(curated_pid)
 
         if parent_id:
             direct_parent_cov[curated_pid] = parent_id
@@ -752,7 +764,11 @@ async def coverage():
             continue  # permutation alias
         if curated_pid in seen_policy_ids:
             continue
-        if any(eid.startswith(curated_pid + "__") for eid in seen_policy_ids):
+        # KI-145 — bypass the startswith dedup for genuine variants (same
+        # UIN/source-PDF as a pass-1 card but materially different fields).
+        # Otherwise variant cards would be silently dropped here.
+        if curated_pid not in ki145_variant_curated_ids_cov \
+                and any(eid.startswith(curated_pid + "__") for eid in seen_policy_ids):
             continue
         # KI-141 — skip curated entries that have already been collapsed into
         # a pass-1 parent's alias list.
@@ -765,14 +781,24 @@ async def coverage():
         # Curated entries don't have a __doctype suffix, so use the full
         # policy_id as the product_key.
         pkey = curated_pid
-        if pkey in seen_product_keys:
+        # KI-145 — variants share product_key with their pass-1 sibling
+        # (different doctype-stripped stems are identical). Allow them past
+        # this dedup so coverage policy_count = marketplace card count.
+        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
         url = data.get("source_pdf_url", "")
         if slug not in by_insurer:
             by_insurer[slug] = {"products": set(), "names": [], "chunks": 0, "aliases": 0}
-        by_insurer[slug]["products"].add(pkey)
+        # KI-145 — variants share pkey with a pass-1 sibling, so adding the
+        # bare pkey to the set would be a no-op (set semantics). Tag variant
+        # pkeys with a suffix in the counting set so the per-insurer count
+        # increments by 1, matching the marketplace card count.
+        if curated_pid in ki145_variant_curated_ids_cov:
+            by_insurer[slug]["products"].add(f"{pkey}__ki145variant")
+        else:
+            by_insurer[slug]["products"].add(pkey)
         # KI-142 — accumulate alias count for curated parents (curated entries
         # that themselves became the claimant of a new UIN, with later curated
         # siblings aliasing onto them).
@@ -1628,6 +1654,13 @@ async def policies_all(session_id: Optional[str] = None):
     # ultimate extracted parent.
     direct_parent: dict[str, str] = {}
     curated_canonical_ids: list[str] = []
+    # KI-145 — curated entries whose UIN matched a candidate parent but
+    # failed the material-diffs gate (>= 2 decision-critical fields disagree
+    # with the parent's extracted JSON). These are genuine variants that
+    # must emit as standalone cards in pass 2 even when their policy_id is
+    # a prefix of a seen extracted policy_id (the old startswith-skip would
+    # otherwise drop them silently).
+    ki145_variant_curated_ids: set[str] = set()
 
     # Phase B — walk curated entries deterministically (sorted by policy_id).
     for curated_policy_id, cdata in sorted(curated_facts.items()):
@@ -1662,28 +1695,35 @@ async def policies_all(session_id: Optional[str] = None):
             # 2+ disagree on non-null values, treat as a VARIANT and keep
             # this curated entry as its own card. < 2 = pure rename → merge.
             candidate = uin_to_parent[curated_uin]
-            ext_data = extracted_data.get(candidate, {})
-            if _ki145_material_diffs(cdata, ext_data) < 2:
+            # Candidate may be an extracted stem OR a previously-claimed
+            # curated entry. Look up extracted JSON first; fall back to the
+            # candidate's curated facts so the diff has real data to compare.
+            cand_data = extracted_data.get(candidate) or curated_facts.get(candidate, {})
+            if _ki145_material_diffs(cdata, cand_data) < 2:
                 parent_id = candidate
+            else:
+                ki145_variant_curated_ids.add(curated_policy_id)
         elif curated_uin:
             # New UIN — this curated entry becomes the claimant so any
-            # later curated sibling with the same UIN aliases onto it.
+            # later curated sibling with the same UIN aliases onto it. Per
+            # KI-145 spec ("if UIN doesn't match any extracted parent →
+            # treat as standalone"), also flag this entry so pass-2 emits
+            # it even when its policy_id is a prefix of a seen extracted id.
             uin_to_parent[curated_uin] = curated_policy_id
+            ki145_variant_curated_ids.add(curated_policy_id)
 
         if parent_id is None and not curated_uin:
-            # KI-142 (user rule, 2026-05-15): source-PDF fallback only fires
-            # when the curated entry has NO UIN at all. If UIN exists but
-            # doesn't match any extracted parent, they're different
-            # regulator-filed products and must stay as separate cards —
-            # source-PDF coincidence (multi-variant wordings) does NOT merge.
+            # KI-142 (preserved): source-PDF fallback only fires for curated
+            # entries with NO UIN. When UIN is present but unmatched, the
+            # KI-145 spec mandates standalone — source-PDF coincidence MUST
+            # NOT override the UIN-mismatch signal.
             fb_parent = _source_pdf_to_policy_id(cdata.get("_primary_source_pdf"))
             if fb_parent and fb_parent in extracted_stems and fb_parent != curated_policy_id:
-                # KI-145 — apply the same material-diffs gate so multi-variant
-                # PDFs without UIN coverage don't drag genuinely different
-                # products into the parent card.
                 ext_data = extracted_data.get(fb_parent, {})
                 if _ki145_material_diffs(cdata, ext_data) < 2:
                     parent_id = fb_parent
+                else:
+                    ki145_variant_curated_ids.add(curated_policy_id)
 
         if parent_id:
             direct_parent[curated_policy_id] = parent_id
@@ -1824,8 +1864,13 @@ async def policies_all(session_id: Optional[str] = None):
             continue
         if curated_policy_id in seen_policy_ids:
             continue
-        # Also skip if any extracted ID matches with a suffix
-        if any(eid.startswith(curated_policy_id + "__") for eid in seen_policy_ids):
+        # Also skip if any extracted ID matches with a suffix — UNLESS this
+        # curated entry was classified as a KI-145 variant (same UIN/source-PDF
+        # as a pass-1 card but materially different decision-critical fields).
+        # Variants MUST surface as their own marketplace card; the legacy
+        # startswith dedup would otherwise drop them silently.
+        if curated_policy_id not in ki145_variant_curated_ids \
+                and any(eid.startswith(curated_policy_id + "__") for eid in seen_policy_ids):
             continue
         # KI-141 — skip curated entries that have already been collapsed onto
         # a pass-1 parent card via the aliases mechanism (e.g. Activ One →

backend/needs_finder.py

@@ -76,6 +76,127 @@ def _always(p: Profile) -> bool:
     return True
 
 
+# ----------------------------------------------------------------------------
+# KI-149 (2026-05-15) — free-text INR amount parser for budget + income.
+# User said "I maximum 30000 I can pay" → bot re-asked budget because no
+# parser was attached to the budget Question and the LLM brain failed to
+# capture it. Bare digits ("30000"), "30 thousand", "30 grand", "₹30,000",
+# "1 lakh", "1.5L" must all map cleanly to a rupee amount.
+# ----------------------------------------------------------------------------
+
+def _parse_inr_amount(text: str) -> Optional[int]:
+    """Extract an INR amount in rupees from free text.
+
+    Handles:
+      - "30000", "30,000", "₹30,000", "Rs 30000", "rs. 30000"
+      - "30k", "30 k", "30K"
+      - "30 thousand", "30 grand"
+      - "1 lakh", "1.5 lakh", "1L", "1.5L", "1 lac"
+      - "1 crore", "1cr"
+      - strips fluff: "maximum 30000", "I can pay 30000", "around 25000"
+      - tolerates per-year qualifiers: "/year", "per year", "p.a."
+
+    Returns the integer rupee amount, or None if no number is recognisable.
+    """
+    if not text:
+        return None
+    s = str(text).lower().strip()
+    # Strip currency symbols + thousands separators so "₹30,000" parses.
+    s = s.replace("₹", " ").replace("rs.", " ").replace("rs", " ")
+    s = s.replace(",", "")
+    # Crore (highest unit first so longer alternation wins).
+    m = re.search(r"(\d+(?:\.\d+)?)\s*(?:cr|crore|crores)\b", s)
+    if m:
+        try:
+            return int(float(m.group(1)) * 10_000_000)
+        except ValueError:
+            return None
+    # Lakh / lac.
+    m = re.search(r"(\d+(?:\.\d+)?)\s*(?:l(?:akh|ac)?s?)\b", s)
+    if m:
+        try:
+            return int(float(m.group(1)) * 100_000)
+        except ValueError:
+            return None
+    # Thousand / grand / k.
+    m = re.search(r"(\d+(?:\.\d+)?)\s*(?:thousand|grand|k)\b", s)
+    if m:
+        try:
+            return int(float(m.group(1)) * 1_000)
+        except ValueError:
+            return None
+    # Bare digit run — pick the largest number-like token (handles
+    # "maximum 30000", "around 25000", "I can pay 30000").
+    nums = re.findall(r"\d+(?:\.\d+)?", s)
+    if nums:
+        try:
+            return int(float(max(nums, key=lambda x: float(x))))
+        except ValueError:
+            return None
+    return None
+
+
+def _parse_budget_band(text: str) -> Optional[str]:
+    """Map free-text budget text → one of under_15k / 15k_30k / 30k_60k / 60k+.
+
+    KI-149 (2026-05-15). Falls back to range hints ("15-30k", "30 to 60k")
+    before delegating to `_parse_inr_amount` for a single number.
+    """
+    if not text:
+        return None
+    s = str(text).lower()
+    # Explicit bucket hints first — order matters (more specific wins).
+    if re.search(r"60\s*k\s*\+|>\s*60|more\s+than\s+60|above\s+60|over\s+60", s):
+        return "60k+"
+    if re.search(r"30\s*[-to]+\s*60\s*k?|30k\s*[-_]\s*60k|30\s*to\s*60", s):
+        return "30k_60k"
+    if re.search(r"15\s*[-to]+\s*30\s*k?|15k\s*[-_]\s*30k|15\s*to\s*30", s):
+        return "15k_30k"
+    if re.search(r"under\s*15|less\s+than\s+15|below\s+15|<\s*15", s):
+        return "under_15k"
+    # Single amount → bucket.
+    amt = _parse_inr_amount(s)
+    if amt is None:
+        return None
+    if amt < 15_000:
+        return "under_15k"
+    if amt < 30_000:
+        return "15k_30k"
+    if amt < 60_000:
+        return "30k_60k"
+    return "60k+"
+
+
+def _parse_income_band(text: str) -> Optional[str]:
+    """Map free-text income text → one of under_5L / 5L-10L / 10L-25L / 25L+.
+
+    KI-149 (2026-05-15). Same approach as `_parse_budget_band`: explicit
+    bucket hints first, then a single rupee amount → bucket.
+    """
+    if not text:
+        return None
+    s = str(text).lower()
+    if re.search(r"25\s*l\s*\+|>\s*25|more\s+than\s+25|above\s+25|over\s+25", s):
+        return "25L+"
+    if re.search(r"10\s*[-to]+\s*25\s*l?|10l\s*[-_]\s*25l|10\s*to\s*25", s):
+        return "10L-25L"
+    if re.search(r"5\s*[-to]+\s*10\s*l?|5l\s*[-_]\s*10l|5\s*to\s*10", s):
+        return "5L-10L"
+    if re.search(r"under\s*5|less\s+than\s+5|below\s+5|<\s*5", s):
+        return "under_5L"
+    amt = _parse_inr_amount(s)
+    if amt is None:
+        return None
+    # Income is parsed in rupees; 5 lakh = 500_000.
+    if amt < 500_000:
+        return "under_5L"
+    if amt < 1_000_000:
+        return "5L-10L"
+    if amt < 2_500_000:
+        return "10L-25L"
+    return "25L+"
+
+
 GRAPH: list[Question] = [
     Question(
         id="name",
@@ -106,6 +227,7 @@ GRAPH: list[Question] = [
         prompt_hi="सालाना आय — ₹5L से कम, ₹5-10L, ₹10-25L, या ₹25L+? (हम सिर्फ sum insured size suggest करने के लिए पूछते हैं।)",
         field="income_band",
         is_core=True,
+        parser=_parse_income_band,
     ),
     Question(
         id="existing_cover",
@@ -157,6 +279,7 @@ GRAPH: list[Question] = [
         prompt_hi="Premium के लिए सालाना — ₹15k से कम, ₹15-30k, ₹30-60k, या ₹60k+? (अगर थोड़ा ज़्यादा budget बेहतर protection देगा, बताऊंगा।)",
         field="budget_band",
         is_core=True,
+        parser=_parse_budget_band,
     ),
 ]
 

backend/voice_format.py

@@ -77,6 +77,11 @@ ACRONYMS = {
 # letter-by-letter. The user said "₹25L+" was being spoken as "two five L
 # plus". Order in `_normalize_money` matters: handle RANGES first, then
 # PLUS-SUFFIXES, then bare unit-suffixes, then standalone "+".
+#
+# KI-148 (2026-05-15) — extended to cover `k` (thousand), word-forms
+# (`1 lakh`, `1 crore`), `+` suffix → "above", and bare numerics like
+# `30000` → "30 thousand", `1,00,000` → "1 lakh". `k` is currency-gated to
+# avoid breaking "10K marathon".
 _MONEY_RANGE_L = re.compile(
     r"₹?\s*(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)\s*L\b",
     re.IGNORECASE,
@@ -91,9 +96,113 @@ _MONEY_L = re.compile(r"₹?\s*(\d+(?:\.\d+)?)\s*L\b", re.IGNORECASE)
 _MONEY_CR = re.compile(r"₹?\s*(\d+(?:\.\d+)?)\s*Cr\b", re.IGNORECASE)
 _MONEY_RS_PREFIX = re.compile(r"\bRs\.?\s*", re.IGNORECASE)
 _MONEY_RUPEE_SYMBOL = re.compile(r"₹\s*(\d)")
+
+# --- KI-148: word-form lakh/crore (e.g. "1 lakh", "5 crores") ---
+# Normalize to a canonical "<n> lakh rupees" / "<n> crore rupees" so the
+# downstream `L`/`Cr` regexes don't re-process them. Optional ₹ prefix.
+_MONEY_WORD_LAKH = re.compile(
+    r"₹?\s*(\d+(?:\.\d+)?)\s*lakhs?\b",
+    re.IGNORECASE,
+)
+_MONEY_WORD_CRORE = re.compile(
+    r"₹?\s*(\d+(?:\.\d+)?)\s*crores?\b",
+    re.IGNORECASE,
+)
+
+# --- KI-148: `k` (thousand) shorthand, currency-gated ---
+# Match `₹15k`, `₹15-30k`, `₹15k-30k`, `60k+`. Three contexts qualify as
+# currency: (a) ₹ prefix, (b) adjacent to another currency token (handled
+# by ordering — list-context like "₹15k, 30k, 60k+" gets ₹ on the first
+# token then the rest cascade), (c) followed by rupee/premium/budget/
+# income/sum-insured. We pre-scan and tag list-context k's by injecting
+# ₹ before bare k-numbers that sit in a comma/dash list with a ₹-prefixed
+# sibling. Simplest approach: run ₹-prefixed patterns first, then a
+# context-aware second pass.
+_MONEY_RANGE_K_BOTH = re.compile(
+    r"₹\s*(\d+(?:\.\d+)?)\s*k\s*-\s*(\d+(?:\.\d+)?)\s*k\b",
+    re.IGNORECASE,
+)
+_MONEY_RANGE_K = re.compile(
+    r"₹\s*(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)\s*k\b",
+    re.IGNORECASE,
+)
+_MONEY_PLUS_K = re.compile(r"₹?\s*(\d+(?:\.\d+)?)\s*k\s*\+", re.IGNORECASE)
+_MONEY_K_PREFIXED = re.compile(r"₹\s*(\d+(?:\.\d+)?)\s*k\b", re.IGNORECASE)
+# Bare `Nk` (no ₹) — only expand if followed by a currency-context word.
+_MONEY_K_CONTEXT = re.compile(
+    r"\b(\d+(?:\.\d+)?)\s*k\b(?=[\s,]*(?:rupee|premium|budget|income|sum insured))",
+    re.IGNORECASE,
+)
+# Comma/`or`-list cascade: once a list contains "<digits> thousand rupees",
+# subsequent bare "Nk" tokens in the same list segment inherit currency.
+# We approximate by running this AFTER the first pass: any bare `Nk` that
+# sits within 60 chars after a "thousand rupees" or "lakh rupees" token is
+# treated as currency.
+_MONEY_K_LIST_CASCADE = re.compile(
+    r"((?:thousand|lakh|crore) rupees[^.?!]{0,60}?)\b(\d+(?:\.\d+)?)\s*k\b",
+    re.IGNORECASE,
+)
+
+# --- KI-148: bare-number expansion (Indian + standard formatting) ---
+# Indian comma format: `1,00,000` → "1 lakh", `15,00,000` → "15 lakh".
+# Standard format: `2,500,000` → "25 lakh". Plain 4-5 digit: `30000` →
+# "30 thousand". Context-gated to currency to avoid butchering "30000 km".
+_MONEY_INDIAN_LAKH_COMMA = re.compile(
+    r"₹?\s*(\d{1,2}(?:,\d{2})+,\d{3})\b"
+)
+_MONEY_STD_COMMA = re.compile(
+    r"₹?\s*(\d{1,3}(?:,\d{3})+)\b"
+)
+_MONEY_BARE_THOUSANDS = re.compile(
+    r"₹\s*(\d{4,7})\b"
+)
+
 # Bare year ranges like "29-32" or "24/7" — leave alone; TTS handles dashes.
 
 
+def _expand_indian_comma_number(s: str) -> str:
+    """Convert `1,00,000` → "1 lakh", `15,00,000` → "15 lakh",
+    `1,00,00,000` → "1 crore". Indian system: rightmost 3 digits, then
+    pairs."""
+    digits = s.replace(",", "")
+    try:
+        n = int(digits)
+    except ValueError:
+        return s
+    return _humanize_int(n)
+
+
+def _expand_standard_comma_number(s: str) -> str:
+    """Convert `2,500,000` → "25 lakh", `30,000` → "30 thousand"."""
+    digits = s.replace(",", "")
+    try:
+        n = int(digits)
+    except ValueError:
+        return s
+    return _humanize_int(n)
+
+
+def _humanize_int(n: int) -> str:
+    """Render an integer rupee amount as a spoken Indian-English phrase."""
+    if n >= 10_000_000 and n % 100_000 == 0:
+        cr = n // 10_000_000
+        rem_lakh = (n % 10_000_000) // 100_000
+        if rem_lakh == 0:
+            return f"{cr} crore rupees"
+        return f"{cr} crore {rem_lakh} lakh rupees"
+    if n >= 100_000 and n % 1_000 == 0:
+        lakh = n // 100_000
+        return f"{lakh} lakh rupees"
+    if n >= 1_000 and n % 1_000 == 0:
+        return f"{n // 1_000} thousand rupees"
+    if n >= 100_000:
+        # Not a clean lakh — fall back to "X point Y lakh"
+        return f"{n / 100_000:.1f} lakh rupees".replace(".0 ", " ")
+    if n >= 1_000:
+        return f"{n / 1_000:.1f} thousand rupees".replace(".0 ", " ")
+    return f"{n} rupees"
+
+
 def _normalize_money(text: str) -> str:
     """Turn currency / range shorthand into spoken-language equivalents.
 
@@ -104,12 +213,73 @@ def _normalize_money(text: str) -> str:
       "₹2Cr"     → "2 crores"
       "Rs. 5000" → "rupees 5000"
     """
-    text = _MONEY_RANGE_L.sub(lambda m: f"{m.group(1)} to {m.group(2)} lakhs", text)
-    text = _MONEY_RANGE_CR.sub(lambda m: f"{m.group(1)} to {m.group(2)} crores", text)
-    text = _MONEY_PLUS_L.sub(lambda m: f"{m.group(1)} lakhs or more", text)
-    text = _MONEY_PLUS_CR.sub(lambda m: f"{m.group(1)} crores or more", text)
-    text = _MONEY_L.sub(lambda m: f"{m.group(1)} lakhs", text)
-    text = _MONEY_CR.sub(lambda m: f"{m.group(1)} crores", text)
+    # KI-148: word-form lakh/crore FIRST so "₹15 lakh" / "1 crore" become
+    # canonical "<n> lakh rupees" / "<n> crore rupees" and downstream regexes
+    # don't double-process them.
+    text = _MONEY_WORD_CRORE.sub(lambda m: f"{m.group(1)} crore rupees", text)
+    text = _MONEY_WORD_LAKH.sub(lambda m: f"{m.group(1)} lakh rupees", text)
+
+    # KI-148: `k` handling — ranges first, plus second, then prefixed bare.
+    text = _MONEY_RANGE_K_BOTH.sub(
+        lambda m: f"{m.group(1)} to {m.group(2)} thousand rupees", text
+    )
+    text = _MONEY_RANGE_K.sub(
+        lambda m: f"{m.group(1)} to {m.group(2)} thousand rupees", text
+    )
+    # PLUS_K must be currency-gated: ₹ prefix OR cascade context. We do a
+    # split-pass: prefixed ₹...k+ first, then unprefixed Nk+ that appears
+    # after a "thousand rupees"/"lakh rupees" anchor (list-cascade).
+    text = re.sub(
+        r"₹\s*(\d+(?:\.\d+)?)\s*k\s*\+",
+        lambda m: f"above {m.group(1)} thousand rupees",
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = _MONEY_K_PREFIXED.sub(
+        lambda m: f"{m.group(1)} thousand rupees", text
+    )
+    # List-cascade pass: bare "Nk" tokens that sit in a list after an
+    # already-expanded currency token. Run twice to catch chained items.
+    for _ in range(3):
+        new = _MONEY_K_LIST_CASCADE.sub(
+            lambda m: f"{m.group(1)}{m.group(2)} thousand rupees", text
+        )
+        if new == text:
+            break
+        text = new
+    # Also handle "+suffix" bare tokens that gained currency via cascade.
+    text = re.sub(
+        r"((?:thousand|lakh|crore) rupees[^.?!]{0,60}?)\b(\d+(?:\.\d+)?)\s*k\s*\+",
+        lambda m: f"{m.group(1)}above {m.group(2)} thousand rupees",
+        text,
+        flags=re.IGNORECASE,
+    )
+    # Explicit currency-context bare `Nk` (followed by rupee/premium/etc).
+    text = _MONEY_K_CONTEXT.sub(
+        lambda m: f"{m.group(1)} thousand rupees", text
+    )
+
+    # Existing L / Cr handling (lakh / crore short-suffix).
+    text = _MONEY_RANGE_L.sub(lambda m: f"{m.group(1)} to {m.group(2)} lakh rupees", text)
+    text = _MONEY_RANGE_CR.sub(lambda m: f"{m.group(1)} to {m.group(2)} crore rupees", text)
+    text = _MONEY_PLUS_L.sub(lambda m: f"above {m.group(1)} lakh rupees", text)
+    text = _MONEY_PLUS_CR.sub(lambda m: f"above {m.group(1)} crore rupees", text)
+    text = _MONEY_L.sub(lambda m: f"{m.group(1)} lakh rupees", text)
+    text = _MONEY_CR.sub(lambda m: f"{m.group(1)} crore rupees", text)
+
+    # KI-148: bare-number expansion (only ₹-prefixed or comma-formatted).
+    # Indian format `1,00,000` first (longest match), then standard
+    # `2,500,000`, then bare ₹30000.
+    text = _MONEY_INDIAN_LAKH_COMMA.sub(
+        lambda m: _expand_indian_comma_number(m.group(1)), text
+    )
+    text = _MONEY_STD_COMMA.sub(
+        lambda m: _expand_standard_comma_number(m.group(1)), text
+    )
+    text = _MONEY_BARE_THOUSANDS.sub(
+        lambda m: _humanize_int(int(m.group(1))), text
+    )
+
     text = _MONEY_RS_PREFIX.sub("rupees ", text)
     text = _MONEY_RUPEE_SYMBOL.sub(r"rupees \1", text)
     return text