fix(fact-find): LLM-normalize answers + reject non-answers + safe readback

Three live-product bugs (D-021/22/23 follow-up):

1. dependents/income_band/primary_goal/location_tier/budget_band/
health_conditions had NO parsers in needs_finder.py → raw text was
stored verbatim. Frontend's enum-button comparison never matched,
so the Profile sidebar showed nothing selected even when chat had
captured the answer.

2. STT-failure templates ("Sorry, I couldn't hear that clearly. Please
try again.") were recorded as the user's answer to the in-flight
question, then the bot silently moved on with garbage.

3. health_conditions stored as a string (not list) caused
readback_summary to character-split via ", ".join(str) → output
"conditions: d, i, f, f, e, r, e, n, c, e, , i, n, t, o, ..."

Fix in three layers:

[A] backend/fact_find_normalizer.py — new module.
is_valid_answer(text)
Rejects empty, < 2-char, or known failure-template strings.
normalize_answer(question_id, raw_text) -> async
Fast-path regex for age/parents_age/existing_cover (with crore/
lakh/k/digits handling). LLM-mapped (NIM Llama-3.3-70B @ temp 0)
for enum + list fields. Returns None on ambiguous input → caller
re-asks the same question.

[B] backend/orchestrator.py — fact-find branch rewired.
On receiving an awaited answer:
- Skip recording if is_valid_answer() fails (STT garbage).
- Call normalize_answer() to map free-text → schema enum.
- Apply normalized value via session.update_profile_field() so
the Profile sidebar's enum-button comparison matches.
- On any failure, KEEP awaiting_question_id and re-ask with
opener "Sorry, I didn't catch that. Let me ask again — ".
Brain tag: needs_finder::reask_clarify.

[C] backend/needs_finder.py — readback_summary defensive list check.
isinstance(hc, str) → wrap as [hc] before join. Prevents the
character-split symptom even if a stale session still has a
string in profile.health_conditions.

Unit tests passed for the pure-Python paths (12/12 _parse_existing_cover
variants incl. "5L", "30k", "1.5 crore", "₹500000"). LLM enum mapping
will be verified live after the HF Space rebuild lands.

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

backend/fact_find_normalizer.py

@@ -0,0 +1,294 @@
+"""LLM-based normalizer for fact-find answers.
+
+Translates raw natural-language user replies into the schema values expected
+by `backend/needs_finder.py::Profile`. Plus a non-answer detector that skips
+recording when the input is an STT failure template, empty, or off-topic.
+
+This fixes two symptoms surfaced in production on 2026-05-14:
+
+1. Free-text answers being stored verbatim instead of mapped to enums.
+   Example: user said "for now, just me" → stored as
+   `dependents="Um, for now, just me."` instead of `dependents="self"`.
+   The frontend Profile panel's enum-button comparison then never matches,
+   so the sidebar shows no selected option even though chat captured it.
+
+2. STT-failure fallback messages (or empty transcripts) being recorded as
+   the user's answer to the in-flight question. The next question silently
+   moves on with garbage.
+
+Architecture:
+  - `is_valid_answer(text)` — cheap guard that filters non-answers BEFORE
+    any LLM call.
+  - `normalize_answer(question_id, raw)` — async; fast-path regex for
+    numeric fields (age, parents_age, existing_cover); LLM call (NIM
+    Llama-3.3-70B at temperature 0) for enum and list fields.
+  - Returns None when the input can't be mapped → the orchestrator should
+    NOT clear `awaiting_question_id` so the bot re-asks the same question
+    (the "ask me again" behavior the human asked for).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import Any
+
+# ----------------------------------------------------------------------------
+# Field schema — what each fact-find question expects after normalization.
+# Question IDs must match `backend/needs_finder.py::GRAPH[i].id` exactly.
+# ----------------------------------------------------------------------------
+
+_FIELD_SCHEMA: dict[str, dict] = {
+    "age": {"type": "int", "min": 1, "max": 120},
+    "dependents": {
+        "type": "enum",
+        "values": [
+            "self",
+            "self+spouse",
+            "self+spouse+kids",
+            "self+parents",
+            "self+spouse+kids+parents",
+        ],
+    },
+    "income_band": {
+        "type": "enum",
+        "values": ["under_5L", "5L-10L", "10L-25L", "25L+"],
+    },
+    "existing_cover": {"type": "int", "min": 0, "max": 100_000_000},
+    "primary_goal": {
+        "type": "enum",
+        "values": ["first_buy", "upgrade", "compare_specific", "tax_planning"],
+    },
+    "location": {
+        "type": "enum",
+        "values": ["metro", "tier1", "tier2", "tier3"],
+    },
+    "parents_age": {"type": "int", "min": 30, "max": 120},
+    "health_conditions": {
+        "type": "list",
+        "common_values": ["diabetes", "hypertension", "thyroid", "asthma", "heart", "cancer"],
+    },
+    "budget": {
+        "type": "enum",
+        "values": ["under_15k", "15k_30k", "30k_60k", "60k+"],
+    },
+}
+
+# Non-answer fingerprints — these strings will skip the LLM and the recording.
+_NON_ANSWER_PATTERNS = [
+    "sorry, i couldn't hear",
+    "couldn't hear that clearly",
+    "transcribe error",
+    "transcribe failed",
+    "stt failed",
+    "no audio",
+    "[transcription failed]",
+    "please try again",
+]
+
+
+def is_valid_answer(text: str) -> bool:
+    """Return False when text is empty, too short, or a known failure template."""
+    if not text or not text.strip():
+        return False
+    s = text.strip().lower()
+    if len(s) < 2:
+        return False
+    if any(p in s for p in _NON_ANSWER_PATTERNS):
+        return False
+    return True
+
+
+async def normalize_answer(question_id: str, raw_text: str) -> Any:
+    """Map natural-language `raw_text` to the schema value for `question_id`.
+
+    Returns:
+      - parsed value (int / enum string / list[str]) on success
+      - None when the answer can't be confidently mapped (caller should re-ask)
+    """
+    if not is_valid_answer(raw_text):
+        return None
+
+    schema = _FIELD_SCHEMA.get(question_id)
+    if schema is None:
+        # Unknown question id — defensive pass-through
+        return raw_text.strip() or None
+
+    # Fast paths — no LLM needed for plain integers / cover-amount parsing.
+    if question_id in ("age", "parents_age"):
+        return _parse_int(raw_text, schema)
+    if question_id == "existing_cover":
+        return _parse_existing_cover(raw_text)
+
+    # Enum + list fields — let the LLM map natural language to canonical value.
+    return await _llm_normalize(question_id, raw_text, schema)
+
+
+# ----------------------------------------------------------------------------
+# Fast-path parsers (no LLM)
+# ----------------------------------------------------------------------------
+
+def _parse_int(text: str, schema: dict) -> int | None:
+    digits = "".join(c for c in str(text) if c.isdigit())
+    if not digits:
+        return None
+    try:
+        v = int(digits[:3])
+    except ValueError:
+        return None
+    if v < schema.get("min", 0) or v > schema.get("max", 9_999):
+        return None
+    return v
+
+
+def _parse_existing_cover(text: str) -> int | None:
+    """Handle "no" / "none" / "5 lakh" / "₹500000" / "5L" / "haven't got any" / "30k"."""
+    s = text.lower().strip()
+    # Negative answers map to 0 (no existing cover).
+    if re.search(r"\b(no|none|nothing|zero|nope|nah|haven'?t|don'?t)\b", s):
+        return 0
+
+    # Look for a number followed by a unit suffix (digit-attached OR separated).
+    # crore > lakh > thousand priority so longer units win the alternation.
+    cr_match = re.search(r"(\d+(?:\.\d+)?)\s*(?:cr|crore|crores)\b", s)
+    if cr_match:
+        try:
+            return int(float(cr_match.group(1)) * 10_000_000)
+        except ValueError:
+            return None
+    lakh_match = re.search(r"(\d+(?:\.\d+)?)\s*(?:l(?:akh|ac)?s?)\b", s)
+    if lakh_match:
+        try:
+            return int(float(lakh_match.group(1)) * 100_000)
+        except ValueError:
+            return None
+    k_match = re.search(r"(\d+(?:\.\d+)?)\s*k\b", s)
+    if k_match:
+        try:
+            return int(float(k_match.group(1)) * 1_000)
+        except ValueError:
+            return None
+
+    # Plain digit-only amount (e.g., "500000").
+    digits = "".join(c for c in text if c.isdigit())
+    if not digits:
+        return None
+    try:
+        amount = int(digits[:7])
+    except ValueError:
+        return None
+    if amount < 0 or amount > 100_000_000:
+        return None
+    return amount
+
+
+# ----------------------------------------------------------------------------
+# LLM-backed normalizer for enum + list fields
+# ----------------------------------------------------------------------------
+
+_LLM_SYSTEM_TEMPLATE = """You map a user's natural-language answer to a structured value.
+
+Question ID: {qid}
+Expected schema: {schema}
+
+Rules:
+1. If type=enum, return EXACTLY one of the allowed values (a JSON string), or null if no clear match.
+2. If type=list, return a JSON array of canonical lowercase condition strings. For "no", "none", "nothing" → [].
+3. If the user clearly didn't answer the question (off-topic, asking back, gibberish), return null.
+4. Output ONLY the JSON value — no prose, no code fences, no <think> blocks.
+
+Examples for guidance:
+- dependents enum, user "just me" → "self"
+- dependents enum, user "me and my wife" → "self+spouse"
+- dependents enum, user "I want coverage for my parents too" → "self+parents"
+- income_band enum, user "around 18 lakhs" → "10L-25L"
+- income_band enum, user "more than 25 lakhs" → "25L+"
+- primary_goal enum, user "I'm buying my first one" → "first_buy"
+- primary_goal enum, user "want to compare HDFC and ICICI" → "compare_specific"
+- location enum, user "Bangalore" → "metro"
+- location enum, user "Patna" → "tier2"
+- budget enum, user "around 20k a year" → "15k_30k"
+- health_conditions list, user "none" → []
+- health_conditions list, user "diabetes and BP" → ["diabetes", "hypertension"]
+- health_conditions list, user "I have asthma" → ["asthma"]
+"""
+
+
+async def _llm_normalize(question_id: str, raw_text: str, schema: dict) -> Any:
+    from backend.providers.base import ChatMessage
+    from backend.providers.nvidia_nim_llm import NvidiaNimLLM
+
+    sys_msg = _LLM_SYSTEM_TEMPLATE.format(qid=question_id, schema=json.dumps(schema))
+    user_msg = f'User said: "{raw_text[:600]}"\n\nReturn the JSON value.'
+
+    try:
+        llm = NvidiaNimLLM(model="meta/llama-3.3-70b-instruct")
+        result = await llm.chat(
+            messages=[
+                ChatMessage(role="system", content=sys_msg),
+                ChatMessage(role="user", content=user_msg),
+            ],
+            temperature=0.0,
+            max_tokens=120,
+        )
+        raw = (result.text or "").strip()
+    except Exception as e:
+        logging.warning(
+            "fact_find_normalizer LLM call failed (qid=%s, raw=%r): %s",
+            question_id, raw_text[:80], e,
+        )
+        return None
+
+    # Strip <think> blocks and code fences that some models add despite instructions.
+    if "<think>" in raw and "</think>" in raw:
+        raw = raw.split("</think>", 1)[1].strip()
+    if raw.startswith("```"):
+        raw = "\n".join(l for l in raw.split("\n") if not l.startswith("```")).strip()
+    if not raw or raw.lower() == "null":
+        return None
+
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError:
+        # Some models return bare strings without JSON quoting; tolerate.
+        if schema["type"] == "enum" and raw.strip('"') in schema["values"]:
+            return raw.strip('"')
+        return None
+
+    return _validate(parsed, schema)
+
+
+def _validate(value: Any, schema: dict) -> Any:
+    """Type + enum + bounds check. Returns None on failure."""
+    t = schema.get("type")
+
+    if t == "enum":
+        if isinstance(value, str) and value in schema["values"]:
+            return value
+        return None
+
+    if t == "int":
+        if isinstance(value, bool):
+            return None
+        try:
+            v = int(value)
+        except (TypeError, ValueError):
+            return None
+        if v < schema.get("min", -1_000_000_000) or v > schema.get("max", 1_000_000_000):
+            return None
+        return v
+
+    if t == "list":
+        if not isinstance(value, list):
+            return None
+        cleaned = [str(x).strip().lower() for x in value if x and isinstance(x, (str, int))]
+        cleaned = [c for c in cleaned if c]
+        return cleaned  # [] is a valid answer (= "no conditions")
+
+    if t == "bool":
+        if isinstance(value, bool):
+            return value
+        return None
+
+    return value

backend/needs_finder.py

@@ -218,7 +218,15 @@ def readback_summary(profile: Profile) -> str:
     if profile.parents_age_max:
         bits.append(f"parents up to age {profile.parents_age_max}")
     if profile.health_conditions:
-        bits.append(f"conditions: {', '.join(profile.health_conditions)}")
+        hc = profile.health_conditions
+        # Defensive: if a string accidentally landed here, wrap it so we don't
+        # split it character-by-character in the join. Production hit this on
+        # 2026-05-14 — a verbatim STT transcript was stored as a string, then
+        # ', '.join(str) emitted "d, i, f, f, e, r, e, n, c, e, ...".
+        if isinstance(hc, str):
+            hc = [hc] if hc.strip() else []
+        if hc:
+            bits.append(f"conditions: {', '.join(str(c) for c in hc)}")
     if profile.budget_band:
         bits.append(f"budget {profile.budget_band}")
     return "; ".join(bits) if bits else "(no profile yet)"

backend/orchestrator.py

@@ -161,21 +161,58 @@ async def handle_turn(
     treat_as_fact_find = (intent == "fact_find" and not session.free_form_session) or in_fact_find_continuation
 
     if treat_as_fact_find:
-        # If we were awaiting an answer, parse + record it before picking next Q.
+        # If we were awaiting an answer, normalize + record it before picking next Q.
+        # Uses backend/fact_find_normalizer.py to map free-text → schema enums.
+        # If the input is a non-answer (STT failure / empty / gibberish), or the
+        # LLM can't confidently map it, we DON'T clear awaiting_question_id so
+        # the bot re-asks the same question rather than silently moving on.
+        ambiguous_or_failed = False
         if session.awaiting_question_id:
-            session.record_user_answer(user_text)
+            from backend.fact_find_normalizer import is_valid_answer, normalize_answer
+            qid = session.awaiting_question_id
+            if not is_valid_answer(user_text):
+                ambiguous_or_failed = True
+            else:
+                try:
+                    normalized = await normalize_answer(qid, user_text)
+                except Exception:
+                    normalized = None
+                if normalized is None:
+                    ambiguous_or_failed = True
+                else:
+                    # Apply the normalized value to the right Profile field.
+                    q_obj = next((q for q in __import__('backend.needs_finder', fromlist=['GRAPH']).GRAPH if q.id == qid), None)
+                    if q_obj is not None:
+                        session.update_profile_field(q_obj.field, normalized)
+                        if qid not in session.profile.asked:
+                            session.profile.asked.append(qid)
+                        session.set_awaiting(None)
+                    else:
+                        ambiguous_or_failed = True
+
+        # If the answer didn't normalize, pick the SAME question again (re-ask
+        # with a gentle clarifier) instead of moving on with garbage.
+        if ambiguous_or_failed and session.awaiting_question_id:
+            q = next((qq for qq in __import__('backend.needs_finder', fromlist=['GRAPH']).GRAPH if qq.id == session.awaiting_question_id), None)
+        else:
+            q = next_question(session.profile, language=language)
 
-        q = next_question(session.profile, language=language)
         if q is not None:
             session.set_awaiting(q.id)
-            if in_fact_find_continuation:
+            if ambiguous_or_failed:
+                opener_en = "Sorry, I didn't catch that. Let me ask again — "
+                opener_hi = "माफ़ कीजिए, समझ नहीं आया। दोबारा पूछता हूँ — "
+            elif in_fact_find_continuation:
                 opener_en = "Got it. "
                 opener_hi = "ठीक है। "
             else:
                 opener_en = "Happy to help. " if not user_text.lower().strip().startswith(("hi", "hello")) else "Hi! "
                 opener_hi = "मदद के लिए तैयार हूँ। "
             reply = (opener_hi + q.prompt_hi) if language == "indic" else (opener_en + q.prompt_en)
-            brain_tag = "needs_finder::fact_find_continue" if in_fact_find_continuation else "needs_finder::fact_find_start"
+            if ambiguous_or_failed:
+                brain_tag = "needs_finder::reask_clarify"
+            else:
+                brain_tag = "needs_finder::fact_find_continue" if in_fact_find_continuation else "needs_finder::fact_find_start"
         else:
             # Fact-find complete — produce a profile readback + invite next step
             from backend.needs_finder import readback_summary