Deploy: Stack A (NIM brain + Maverick judge + Sarvam voice). D-019.

.pytest_cache/v/cache/nodeids

@@ -1,4 +1,18 @@
 [
+  "tests/test_bug107_108_109_110_factfind.py::TestBug107NoCitationsOnFactFind::test_recommendation_turn_with_complete_profile_still_cites",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug107NoCitationsOnFactFind::test_speculative_retrieve_then_clarifying_question_has_no_cards",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug108PartialAnswerReask::test_explicit_skip_bypasses_the_reask_gate",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug108PartialAnswerReask::test_explicit_skip_resolves_the_whole_bundle",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug108PartialAnswerReask::test_partial_answer_triggers_one_shot_reask_then_proceeds",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug108PartialAnswerReask::test_skip_phrase_detector",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug108PartialAnswerReask::test_unresolved_bundle_includes_family_medical_history",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug109BudgetBandPersistence::test_canonical_band_passes_through",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug109BudgetBandPersistence::test_numeric_string_maps_to_band",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug109BudgetBandPersistence::test_numeric_value_maps_to_band",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug109BudgetBandPersistence::test_save_profile_field_persists_band_not_raw",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug109BudgetBandPersistence::test_unparseable_returns_none_not_raw",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug110FamilyHistoryInPlan::test_family_history_is_in_the_bundle_questions",
+  "tests/test_bug107_108_109_110_factfind.py::TestBug110FamilyHistoryInPlan::test_system_prompt_asks_family_medical_history",
   "tests/test_bug69_71_conversation_logic.py::TestBug69EndToEnd::test_fallback_path_when_name_only_missing_is_not_a_no_match",
   "tests/test_bug69_71_conversation_logic.py::TestBug69EndToEnd::test_name_requested_early_and_missing_name_not_a_no_match",
   "tests/test_bug69_71_conversation_logic.py::TestBug69NameFirstDeterministic::test_canonical_slot_order_puts_name_first",

40-data/llm_health.json

@@ -1,45 +1,45 @@
 {
-  "updated_at": "2026-05-16T12:56:33Z",
+  "updated_at": "2026-05-16T13:17:20Z",
   "models": {
     "qwen/qwen3-next-80b-a3b-instruct": {
       "model": "qwen/qwen3-next-80b-a3b-instruct",
       "status": "healthy",
-      "last_success_at": "2026-05-16T12:56:33Z",
-      "last_failure_at": "2026-05-16T12:51:28Z",
+      "last_success_at": "2026-05-16T13:17:20Z",
+      "last_failure_at": "2026-05-16T13:12:18Z",
       "last_error": null,
       "last_status_code": null,
-      "latency_ms": 640,
+      "latency_ms": 467,
       "consecutive_failures": 0,
-      "tested_at": "2026-05-16T12:56:33Z",
+      "tested_at": "2026-05-16T13:17:20Z",
       "probe_history": [
         {
           "ok": true,
-          "latency_ms": 660,
-          "ts": "2026-05-16T12:35:52Z",
+          "latency_ms": 640,
+          "ts": "2026-05-16T12:56:33Z",
           "src": "probe"
         },
         {
-          "ok": true,
-          "latency_ms": 1745,
-          "ts": "2026-05-16T12:40:55Z",
+          "ok": false,
+          "latency_ms": 8061,
+          "ts": "2026-05-16T13:01:51Z",
           "src": "probe"
         },
         {
-          "ok": true,
-          "latency_ms": 4868,
-          "ts": "2026-05-16T12:46:10Z",
+          "ok": false,
+          "latency_ms": 8070,
+          "ts": "2026-05-16T13:07:09Z",
           "src": "probe"
         },
         {
           "ok": false,
-          "latency_ms": 8075,
-          "ts": "2026-05-16T12:51:28Z",
+          "latency_ms": 8065,
+          "ts": "2026-05-16T13:12:18Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 640,
-          "ts": "2026-05-16T12:56:33Z",
+          "latency_ms": 467,
+          "ts": "2026-05-16T13:17:20Z",
           "src": "probe"
         }
       ],
@@ -89,42 +89,42 @@
     "mistralai/mistral-large-3-675b-instruct-2512": {
       "model": "mistralai/mistral-large-3-675b-instruct-2512",
       "status": "healthy",
-      "last_success_at": "2026-05-16T12:56:33Z",
-      "last_failure_at": "2026-05-16T12:51:28Z",
+      "last_success_at": "2026-05-16T13:17:20Z",
+      "last_failure_at": "2026-05-16T13:01:51Z",
       "last_error": null,
       "last_status_code": null,
-      "latency_ms": 717,
+      "latency_ms": 379,
       "consecutive_failures": 0,
-      "tested_at": "2026-05-16T12:56:33Z",
+      "tested_at": "2026-05-16T13:17:20Z",
       "probe_history": [
         {
           "ok": true,
-          "latency_ms": 676,
-          "ts": "2026-05-16T12:35:52Z",
+          "latency_ms": 717,
+          "ts": "2026-05-16T12:56:33Z",
           "src": "probe"
         },
         {
-          "ok": true,
-          "latency_ms": 739,
-          "ts": "2026-05-16T12:40:55Z",
+          "ok": false,
+          "latency_ms": 8061,
+          "ts": "2026-05-16T13:01:51Z",
           "src": "probe"
         },
         {
-          "ok": false,
-          "latency_ms": 8003,
-          "ts": "2026-05-16T12:46:10Z",
+          "ok": true,
+          "latency_ms": 897,
+          "ts": "2026-05-16T13:07:09Z",
           "src": "probe"
         },
         {
-          "ok": false,
-          "latency_ms": 8065,
-          "ts": "2026-05-16T12:51:28Z",
+          "ok": true,
+          "latency_ms": 638,
+          "ts": "2026-05-16T13:12:18Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 717,
-          "ts": "2026-05-16T12:56:33Z",
+          "latency_ms": 379,
+          "ts": "2026-05-16T13:17:20Z",
           "src": "probe"
         }
       ],
@@ -138,42 +138,42 @@
     "nvidia/llama-3.3-nemotron-super-49b-v1.5": {
       "model": "nvidia/llama-3.3-nemotron-super-49b-v1.5",
       "status": "healthy",
-      "last_success_at": "2026-05-16T12:56:33Z",
-      "last_failure_at": "2026-05-16T12:25:35Z",
+      "last_success_at": "2026-05-16T13:17:20Z",
+      "last_failure_at": "2026-05-16T13:07:09Z",
       "last_error": null,
       "last_status_code": null,
-      "latency_ms": 412,
+      "latency_ms": 307,
       "consecutive_failures": 0,
-      "tested_at": "2026-05-16T12:56:33Z",
+      "tested_at": "2026-05-16T13:17:20Z",
       "probe_history": [
         {
           "ok": true,
-          "latency_ms": 359,
-          "ts": "2026-05-16T12:35:52Z",
+          "latency_ms": 412,
+          "ts": "2026-05-16T12:56:33Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 380,
-          "ts": "2026-05-16T12:40:55Z",
+          "latency_ms": 314,
+          "ts": "2026-05-16T13:01:51Z",
           "src": "probe"
         },
         {
-          "ok": true,
-          "latency_ms": 354,
-          "ts": "2026-05-16T12:46:10Z",
+          "ok": false,
+          "latency_ms": 8002,
+          "ts": "2026-05-16T13:07:09Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 306,
-          "ts": "2026-05-16T12:51:28Z",
+          "latency_ms": 374,
+          "ts": "2026-05-16T13:12:18Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 412,
-          "ts": "2026-05-16T12:56:33Z",
+          "latency_ms": 307,
+          "ts": "2026-05-16T13:17:20Z",
           "src": "probe"
         }
       ],
@@ -295,42 +295,42 @@
     "meta/llama-4-maverick-17b-128e-instruct": {
       "model": "meta/llama-4-maverick-17b-128e-instruct",
       "status": "healthy",
-      "last_success_at": "2026-05-16T12:56:33Z",
+      "last_success_at": "2026-05-16T13:17:20Z",
       "last_failure_at": "2026-05-16T11:43:51Z",
       "last_error": null,
       "last_status_code": null,
-      "latency_ms": 2559,
+      "latency_ms": 714,
       "consecutive_failures": 0,
-      "tested_at": "2026-05-16T12:56:33Z",
+      "tested_at": "2026-05-16T13:17:20Z",
       "probe_history": [
         {
           "ok": true,
-          "latency_ms": 212,
-          "ts": "2026-05-16T12:35:52Z",
+          "latency_ms": 2559,
+          "ts": "2026-05-16T12:56:33Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 228,
-          "ts": "2026-05-16T12:40:55Z",
+          "latency_ms": 1191,
+          "ts": "2026-05-16T13:01:51Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 1797,
-          "ts": "2026-05-16T12:46:10Z",
+          "latency_ms": 572,
+          "ts": "2026-05-16T13:07:09Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 1637,
-          "ts": "2026-05-16T12:51:28Z",
+          "latency_ms": 239,
+          "ts": "2026-05-16T13:12:18Z",
           "src": "probe"
         },
         {
           "ok": true,
-          "latency_ms": 2559,
-          "ts": "2026-05-16T12:56:33Z",
+          "latency_ms": 714,
+          "ts": "2026-05-16T13:17:20Z",
           "src": "probe"
         }
       ],
@@ -356,7 +356,7 @@
       "credits_remaining": 32.802310819,
       "credits_unit": "usd_balance",
       "credits_reset_at": null,
-      "credits_observed_at": 85053.044581083,
+      "credits_observed_at": 86302.751813875,
       "credits_low_water": 0.05
     },
     "groq:llama-3.3-70b-versatile": {

40-data/profiles/asha.json

@@ -0,0 +1,83 @@
+{
+  "name_display": "Asha",
+  "name_slug": "asha",
+  "persona_id": "ca28dcb8ed8b",
+  "profile": {
+    "name": "Asha",
+    "age": 35,
+    "dependents": "self+spouse",
+    "income_band": "10L-25L",
+    "existing_cover_inr": null,
+    "primary_goal": "first_buy",
+    "location_tier": "metro",
+    "parents_to_insure": null,
+    "parents_age_max": null,
+    "parents_has_ped": null,
+    "budget_band": null,
+    "desired_sum_insured_inr": null,
+    "health_conditions": [
+      "none"
+    ],
+    "copay_pct": 0,
+    "family_medical_history": [],
+    "smoker": null,
+    "asked": [
+      "copay_pct"
+    ],
+    "free_form_session": false,
+    "shown_policies": [
+      {
+        "policy_slug": "royal-sundaram__multiplier",
+        "insurer": "royal-sundaram",
+        "event_at": "2026-05-16T13:20:31Z",
+        "session_id": "t_f4a3f58c",
+        "reason": "shown_in_recommendation",
+        "turn_idx": 1
+      },
+      {
+        "policy_slug": "niva-bupa__reassure-3",
+        "insurer": "niva-bupa",
+        "event_at": "2026-05-16T13:20:31Z",
+        "session_id": "t_f4a3f58c",
+        "reason": "shown_in_recommendation",
+        "turn_idx": 2
+      },
+      {
+        "policy_slug": "care__supreme",
+        "insurer": "care",
+        "event_at": "2026-05-16T13:20:31Z",
+        "session_id": "t_f4a3f58c",
+        "reason": "shown_in_recommendation",
+        "turn_idx": 2
+      }
+    ],
+    "selected_policies": [],
+    "rejected_policies": []
+  },
+  "first_seen": "2026-05-16T13:12:45Z",
+  "last_seen": "2026-05-16T13:20:31Z",
+  "sessions": [
+    "t_b09c3434",
+    "t_2e2054e1",
+    "t_bc4f7b3c",
+    "t_65645f0d",
+    "t_f0c70441",
+    "t_f53db2f1",
+    "t_b2bc5ac3",
+    "t_21220cc0",
+    "t_5adb43c6",
+    "t_759a9562",
+    "t_01ae863a",
+    "t_4537aa0b",
+    "t_e3dd60f1",
+    "t_ea1bc2b9",
+    "t_fd68124b",
+    "t_aaa5d82e",
+    "t_f16a65ad",
+    "t_3ba18b4a",
+    "t_9d8b0680",
+    "t_f4a3f58c"
+  ],
+  "recall_pointer": true,
+  "points_to_persona_id": "ca28dcb8ed8b"
+}

40-data/profiles/ca28dcb8ed8b.json

@@ -0,0 +1,81 @@
+{
+  "name_display": "Asha",
+  "name_slug": "asha",
+  "persona_id": "ca28dcb8ed8b",
+  "profile": {
+    "name": "Asha",
+    "age": 35,
+    "dependents": "self+spouse",
+    "income_band": "10L-25L",
+    "existing_cover_inr": null,
+    "primary_goal": "first_buy",
+    "location_tier": "metro",
+    "parents_to_insure": null,
+    "parents_age_max": null,
+    "parents_has_ped": null,
+    "budget_band": null,
+    "desired_sum_insured_inr": null,
+    "health_conditions": [
+      "none"
+    ],
+    "copay_pct": 0,
+    "family_medical_history": [],
+    "smoker": null,
+    "asked": [
+      "copay_pct"
+    ],
+    "free_form_session": false,
+    "shown_policies": [
+      {
+        "policy_slug": "royal-sundaram__multiplier",
+        "insurer": "royal-sundaram",
+        "event_at": "2026-05-16T13:20:31Z",
+        "session_id": "t_f4a3f58c",
+        "reason": "shown_in_recommendation",
+        "turn_idx": 1
+      },
+      {
+        "policy_slug": "niva-bupa__reassure-3",
+        "insurer": "niva-bupa",
+        "event_at": "2026-05-16T13:20:31Z",
+        "session_id": "t_f4a3f58c",
+        "reason": "shown_in_recommendation",
+        "turn_idx": 2
+      },
+      {
+        "policy_slug": "care__supreme",
+        "insurer": "care",
+        "event_at": "2026-05-16T13:20:31Z",
+        "session_id": "t_f4a3f58c",
+        "reason": "shown_in_recommendation",
+        "turn_idx": 2
+      }
+    ],
+    "selected_policies": [],
+    "rejected_policies": []
+  },
+  "first_seen": "2026-05-16T13:12:45Z",
+  "last_seen": "2026-05-16T13:20:31Z",
+  "sessions": [
+    "t_b09c3434",
+    "t_2e2054e1",
+    "t_bc4f7b3c",
+    "t_65645f0d",
+    "t_f0c70441",
+    "t_f53db2f1",
+    "t_b2bc5ac3",
+    "t_21220cc0",
+    "t_5adb43c6",
+    "t_759a9562",
+    "t_01ae863a",
+    "t_4537aa0b",
+    "t_e3dd60f1",
+    "t_ea1bc2b9",
+    "t_fd68124b",
+    "t_aaa5d82e",
+    "t_f16a65ad",
+    "t_3ba18b4a",
+    "t_9d8b0680",
+    "t_f4a3f58c"
+  ]
+}

backend/brain_tools.py

@@ -290,6 +290,100 @@ _REQUIRED_FOR_READY = (
 )
 
 
+# ───────────────────────────────────────────────────────────────────────────
+# Bug #108 + #110 (2026-05-16) — POST-RECAP pricing & family-history bundle.
+#
+# Bug #108: the RULE 2.5 bundle (SI / budget / co-pay / family history /
+#           smoker) is asked in ONE prompt. When the user answers SOME but
+#           not all, the LLM treated the bundle as fully satisfied (it's
+#           SOFT capture) and recommended with the unanswered slot blank —
+#           e.g. asked SI/budget/co-pay/smoker, user gave SI/budget/co-pay,
+#           smoker never re-asked, bot recommended.
+# Bug #110: family_medical_history (item 5 of the bundle) was the slot most
+#           often silently dropped — the fact-find effectively NEVER asked it.
+#
+# FIX: a deterministic ONE-SHOT re-ask gate. After the hard 7-slot gate
+# passes, on a recommendation retrieve_policies call, if any UNRESOLVED
+# bundle slot remains we return a directive `pricing_inputs_incomplete`
+# response (re-ask exactly the unresolved ones, verbatim) — but ONLY once
+# per session, and ONLY when the user has not explicitly skipped. After the
+# single re-ask we proceed (SOFT-capture semantics preserved: the user can
+# still skip; we never hard-loop).
+#
+# A bundle slot is RESOLVED when it is either captured on the profile OR the
+# user explicitly declined/skipped it (session.pricing_bundle_skipped — set
+# by single_brain when the user says "just show me options" / "skip" / "you
+# decide"). parents_age_max is conditional: only part of the bundle when the
+# user is covering parents and it isn't captured yet.
+_PRICING_BUNDLE_CORE: tuple[str, ...] = (
+    "desired_sum_insured_inr",
+    "budget_band",
+    "existing_cover_inr",
+    "copay_pct",
+    "family_medical_history",   # Bug #110 — must be asked, same skip handling
+    "smoker",
+)
+
+# Exact verbatim re-ask phrasing per bundle slot (mirrors RULE 2.5 wording so
+# the re-ask reads identically to the first ask). family_medical_history is
+# first so a forgotten Bug #110 slot leads the re-ask.
+_PRICING_BUNDLE_QUESTIONS: dict[str, str] = {
+    "family_medical_history": (
+        "Any major conditions running in your blood family "
+        "(parents/siblings) — cancer / diabetes / heart disease / "
+        "hypertension? (say 'none' if not)"
+    ),
+    "desired_sum_insured_inr": (
+        "How much sum insured would you like? (e.g., ₹5L / ₹10L / "
+        "₹25L / ₹1Cr)"
+    ),
+    "budget_band": (
+        "What's your annual premium budget? (e.g., ₹10-15K/year, or "
+        "₹50K+ for premium covers)"
+    ),
+    "existing_cover_inr": (
+        "Any existing health cover from work or otherwise? "
+        "(e.g., '5L through employer', or 'no')"
+    ),
+    "copay_pct": (
+        "Are you OK with a co-pay — sharing 10-30% of every claim — to "
+        "lower the premium? Or do you want zero co-pay?"
+    ),
+    "smoker": "Do you smoke or use tobacco products? (yes / no)",
+    "parents_age_max": (
+        "Roughly what's the age of the eldest parent you'd cover?"
+    ),
+}
+
+
+def _profile_has_parents(profile) -> bool:
+    """True when the captured dependents indicate parents are covered (so
+    parents_age_max becomes part of the post-recap bundle)."""
+    dep = getattr(profile, "dependents", None)
+    if isinstance(dep, str) and "parent" in dep.lower():
+        return True
+    return bool(getattr(profile, "parents_to_insure", None))
+
+
+def _unresolved_pricing_bundle(profile, session) -> list[str]:
+    """Return the bundle slots that are NEITHER captured on the profile NOR
+    explicitly skipped by the user this session. Empty list ⇒ nothing left
+    to re-ask (recommend may proceed)."""
+    if session is not None and bool(
+        getattr(session, "pricing_bundle_skipped", False)
+    ):
+        # User explicitly said "just show me options / you decide / skip".
+        return []
+    bundle = list(_PRICING_BUNDLE_CORE)
+    if _profile_has_parents(profile):
+        bundle.append("parents_age_max")
+    unresolved: list[str] = []
+    for slot in bundle:
+        if getattr(profile, slot, None) in (None, "", []):
+            unresolved.append(slot)
+    return unresolved
+
+
 # ───────────────────────────────────────────────────────────────────────────
 # SLOT_UNION (B6, 2026-05-15)
 # ───────────────────────────────────────────────────────────────────────────
@@ -419,6 +513,8 @@ def save_profile_field(session, field: str, value: Any) -> dict:
             normalized = _coerce_family_medical_history(value)
         elif fld == "smoker":
             normalized = _coerce_smoker(value)
+        elif fld == "budget_band":
+            normalized = _coerce_budget_band(value)
         elif fld == "name":
             normalized = (str(value).strip() if value is not None else None) or None
         elif fld == "gender":
@@ -434,7 +530,8 @@ def save_profile_field(session, field: str, value: Any) -> dict:
                 "profile_complete": _profile_complete(profile),
             }
         else:
-            # location_tier / income_band / primary_goal / budget_band — pass through
+            # location_tier / income_band / primary_goal — pass through
+            # (budget_band is normalised above via _coerce_budget_band)
             normalized = (str(value).strip() if value is not None else None) or None
     except (TypeError, ValueError) as e:
         return {
@@ -564,6 +661,63 @@ async def retrieve_policies(
                 ),
             }
 
+    # Bug #108 + #110 (2026-05-16) — POST-RECAP pricing & family-history
+    # bundle re-ask gate. The hard 7-slot gate above is satisfied; before we
+    # return chunks for a RECOMMENDATION, ensure every bundle item (SI /
+    # budget / existing cover / co-pay / FAMILY MEDICAL HISTORY / smoker /
+    # parents-age-if-applicable) has been RESOLVED — captured OR explicitly
+    # skipped. If the user answered some but not all, re-ask ONLY the
+    # unresolved ones — but exactly ONCE per session (one-shot guard) so we
+    # never hard-loop and SOFT-capture semantics survive (the user can still
+    # skip on the re-ask). Follow-ups (policy_filter_ids) bypass this — it's
+    # purely the first recommendation path.
+    if (
+        profile is not None
+        and not policy_filter_ids
+        and (intent or "").lower() == "recommendation"
+        and session is not None
+        and not bool(getattr(session, "pricing_bundle_reasked", False))
+    ):
+        unresolved = _unresolved_pricing_bundle(profile, session)
+        if unresolved:
+            # One-shot: mark so the NEXT recommendation retrieve proceeds
+            # even if the user skips on the re-ask (SOFT capture, not a hard
+            # gate — Bug #108 fix must re-ask, not loop forever).
+            try:
+                session.pricing_bundle_reasked = True
+            except Exception:  # noqa: BLE001 — bookkeeping must not break
+                pass
+            _qs = [
+                _PRICING_BUNDLE_QUESTIONS.get(
+                    s, f"Could you share your {s.replace('_', ' ')}?"
+                )
+                for s in unresolved
+            ]
+            _numbered = "\n".join(
+                f"{i}. {q}" for i, q in enumerate(_qs, start=1)
+            )
+            return {
+                "chunks": [],
+                "count": 0,
+                "error": "pricing_inputs_incomplete",
+                "missing_slots": unresolved,
+                "action_required": "ask_user_for",
+                "field": unresolved[0],
+                "exact_question": (
+                    "Before I pull your recommendations, just a couple more "
+                    "(you can skip any):\n" + _numbered
+                ),
+                "instruction": (
+                    "The user answered some but not all of the pricing / "
+                    "family-history questions. Do NOT call retrieve_policies "
+                    "again this turn and do NOT recommend yet. Emit a TEXT "
+                    "reply that asks ONLY the still-missing items in "
+                    "`exact_question` verbatim. If the user then provides "
+                    "them, save each via save_profile_field; if they skip, "
+                    "proceed to retrieve_policies on the next turn."
+                ),
+            }
+
     try:
         from rag.retrieve import retrieve as _retrieve
 
@@ -924,6 +1078,92 @@ def _coerce_existing_cover(value: Any) -> Optional[int]:
     return None
 
 
+# Canonical budget bands — the EXACT string contract the frontend
+# ProfileBuilderPanel round-trips via budgetBandToInr / budgetInrToBand
+# (frontend/src/app/page.tsx) and that needs_finder._parse_budget_band
+# emits. Keeping this set inline makes the contract greppable from the
+# capture surface.
+_CANONICAL_BUDGET_BANDS: frozenset[str] = frozenset(
+    {"under_15k", "15k_30k", "30k_60k", "60k+"}
+)
+
+
+def _coerce_budget_band(value: Any) -> Optional[str]:
+    """Normalise a budget capture to the documented `budget_band` contract.
+
+    Bug #109 (2026-05-16). The user states a premium budget in chat
+    ("max ₹15,000/yr", "around 30k", "15000"). Gemini calls
+    save_profile_field(field="budget_band", value=...) but often passes the
+    NUMERIC the user said, not a canonical band. The old code let
+    budget_band fall through the generic string pass-through, so
+    profile.budget_band was stored as the raw "15000" — which the frontend
+    ProfileBuilderPanel's budgetBandToInr() switch can't map, so the panel
+    never pre-filled the budget slider even though the bot's summary showed
+    it.
+
+    Mapping (matches frontend budgetInrToBand + needs_finder bands):
+      • already a canonical band ("15k_30k") → passed through unchanged
+      • free-text / numeric ("max ₹15,000/yr", "30k", 22000, "10-15K")
+        → delegated to needs_finder._parse_budget_band → canonical band
+      • unrecognised → None (KI-091 null-overwrite guard then refuses to
+        clobber a previously-captured band)
+    """
+    if value is None:
+        return None
+    # Numeric → bucket directly (₹ amount per year).
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        v = int(value)
+        if v < 15_000:
+            return "under_15k"
+        if v < 30_000:
+            return "15k_30k"
+        if v < 60_000:
+            return "30k_60k"
+        return "60k+"
+    s = str(value).strip()
+    if not s:
+        return None
+    # Already canonical — accept verbatim (case/space tolerant).
+    norm = s.lower().replace(" ", "")
+    if norm in _CANONICAL_BUDGET_BANDS:
+        return norm
+    # Strip ANNUAL-budget qualifiers FIRST. needs_finder._parse_inr_amount
+    # treats a bare "yr" / "year" as an AGE context and refuses to read any
+    # number as currency (the KI-161 age guard) — so the canonical live
+    # phrasing "max ₹15,000/yr" / "₹15000 per year" parsed to None and the
+    # band was never captured (Bug #109). These suffixes are unambiguous
+    # PER-ANNUM budget markers here (the field is explicitly the premium
+    # budget), not an age, so we drop them before delegating.
+    import re as _re
+
+    cleaned = _re.sub(
+        r"\b(?:per\s*(?:year|annum)|p\.?\s*a\.?|/\s*(?:yr|year|annum)|"
+        r"a\s*year|annually|yearly|/\s*yr)\b",
+        " ",
+        s,
+        flags=_re.IGNORECASE,
+    )
+    # Free-text / amount → canonical band via the shared parser. This
+    # handles "max ₹15,000", "30k", "around 25000", "15-30k", "1 lakh".
+    try:
+        from backend.needs_finder import _parse_budget_band
+
+        band = _parse_budget_band(cleaned)
+        if band in _CANONICAL_BUDGET_BANDS:
+            return band
+        # Last-resort: if the qualifier strip left only the amount, try the
+        # raw string too (covers phrasings the regex didn't anticipate).
+        if cleaned != s:
+            band = _parse_budget_band(s)
+            if band in _CANONICAL_BUDGET_BANDS:
+                return band
+    except Exception:  # noqa: BLE001 — parser optional; fall through to None
+        pass
+    return None
+
+
 def _coerce_bool(value: Any) -> Optional[bool]:
     """Tri-state bool coercion for parents_to_insure / parents_has_ped.
 

backend/session_state.py

@@ -92,6 +92,17 @@ class SessionState:
     # turn. Independent of `pending_profile_recall` (which tracks an
     # in-flight confirm), so a declined recall is not retried either.
     _recall_sniff_done: bool = False
+    # Bug #108 + #110 (2026-05-16) — POST-RECAP pricing & family-history
+    # bundle re-ask gate (brain_tools.retrieve_policies).
+    #   pricing_bundle_reasked — one-shot guard. Set True the first time the
+    #     gate re-asks an unresolved bundle slot so the NEXT recommendation
+    #     retrieve proceeds even if the user skips (SOFT capture, no hard
+    #     loop).
+    #   pricing_bundle_skipped — set True by single_brain when the user
+    #     explicitly declines the pricing inputs ("just show me options",
+    #     "you decide", "skip"). Bypasses the re-ask entirely.
+    pricing_bundle_reasked: bool = False
+    pricing_bundle_skipped: bool = False
 
     def _flush(self) -> None:
         """No-op since KI-118 (2026-05-15). Disk persistence was removed; the

backend/single_brain.py

@@ -181,7 +181,7 @@ NEVER ask the user for a fact you can already extract from their last message. C
 ═══════════════════════════════════
 RULE 2 — retrieve_policies query MUST be profile-aware
 ═══════════════════════════════════
-Only call retrieve_policies AFTER all 7 required slots are saved AND the user has confirmed your recap.
+Only call retrieve_policies AFTER all 7 required slots are saved AND the user has confirmed your recap AND the RULE 2.5 pricing/family-history bundle has been either answered or explicitly skipped (a PARTIAL answer is not a skip — re-ask the missing items first; see RULE 2.5).
 
 Build the query string from the profile snapshot. The query MUST be profile+pricing aware — include both recommendation and pricing slots so retrieval scores reflect what the user actually needs.
 
@@ -235,7 +235,16 @@ When the user answers, call save_profile_field once per provided value:
 
 Gender hint: if the user mentions gender, keep it for conversational context only — Profile has no `gender` slot. Do NOT call save_profile_field(field="gender", ...) — it returns `field_not_on_profile_dataclass` and wastes a tool-call iteration.
 
-Then call retrieve_policies and INCLUDE the new inputs in the query (e.g., "...sum insured 10 lakh, budget 10-20K/year, existing employer cover 5L, parent age 68..."). If the user skips ("just show me options", "you decide"), proceed with retrieve_policies using profile defaults — DO NOT block. SOFT capture, not a hard gate.
+PARTIAL ANSWER → RE-ASK THE REST (Bug #108 — DO NOT SKIP THIS):
+If the user answers SOME of the bundle but not ALL (e.g. you asked sum
+insured / budget / co-pay / family history / smoking and they gave SI +
+budget + co-pay only), you MUST re-ask ONLY the still-unanswered items in
+ONE short follow-up before recommending — do NOT silently proceed to
+retrieve_policies with the unanswered slot blank. The single most-dropped
+item is FAMILY MEDICAL HISTORY (Bug #110): always confirm it is answered or
+skipped. Re-ask at most ONCE; if the user then skips, proceed.
+
+Then call retrieve_policies and INCLUDE the new inputs in the query (e.g., "...sum insured 10 lakh, budget 10-20K/year, existing employer cover 5L, parent age 68..."). If the user EXPLICITLY skips ("just show me options", "you decide", "skip the rest"), proceed with retrieve_policies using profile defaults — DO NOT block, DO NOT re-ask again. SOFT capture, not a hard gate — but a PARTIAL answer is NOT a skip: re-ask the missing items once (see above).
 
 ═══════════════════════════════════
 RULE 2.6 — ONLY RECOMMEND PLANS THAT ARE GENUINELY STRONG FOR THIS USER
@@ -439,7 +448,8 @@ TOOL_SCHEMAS: list[dict] = [
             "per field every time the user reveals something new (name, age, "
             "dependents, location_tier, income_band, primary_goal, "
             "health_conditions, existing_cover_inr, budget_band, "
-            "desired_sum_insured_inr, gender)."
+            "desired_sum_insured_inr, copay_pct, family_medical_history, "
+            "smoker, parents_age_max, gender)."
         ),
         "parameters": {
             "type": "OBJECT",
@@ -450,7 +460,9 @@ TOOL_SCHEMAS: list[dict] = [
                         "Field name. One of: name, age, dependents, "
                         "location_tier, income_band, primary_goal, "
                         "health_conditions, existing_cover_inr, budget_band, "
-                        "desired_sum_insured_inr, gender."
+                        "desired_sum_insured_inr, copay_pct, "
+                        "family_medical_history, smoker, parents_age_max, "
+                        "gender."
                     ),
                 },
                 "value": {
@@ -751,6 +763,34 @@ _FALLBACK_REQUIRED_SLOTS = (
 )
 
 
+# Bug #108 + #110 (2026-05-16) — explicit-skip detector for the post-recap
+# pricing & family-history bundle. When the user clearly declines the
+# pricing inputs, single_brain stamps session.pricing_bundle_skipped so
+# brain_tools.retrieve_policies' one-shot re-ask gate is BYPASSED (the user
+# asked us not to keep asking — SOFT capture means "skip" is honoured).
+# Phrase-level only (substring on a lowercased message) so it stays cheap +
+# deterministic; a partial answer ("10 lakh cover, skip the rest") still
+# counts as skip-the-rest, which is the desired behaviour.
+_PRICING_SKIP_PHRASES: tuple[str, ...] = (
+    "just show me", "just show options", "just recommend", "just give me",
+    "you decide", "you choose", "your call", "whatever you think",
+    "skip", "skip the rest", "skip those", "skip that", "no preference",
+    "don't have a preference", "dont have a preference", "doesn't matter",
+    "doesnt matter", "not sure", "no idea", "show me options",
+    "show me the options", "show options", "proceed", "go ahead",
+    "let's see options", "lets see options", "recommend now",
+)
+
+
+def _user_skipped_pricing_inputs(user_text: str) -> bool:
+    """True when the user's message explicitly declines the pricing /
+    family-history bundle (so the deterministic re-ask gate is bypassed)."""
+    t = (user_text or "").strip().lower()
+    if not t:
+        return False
+    return any(p in t for p in _PRICING_SKIP_PHRASES)
+
+
 def _synthesise_fallback(profile) -> str:
     """KI-Z6-NONE (2026-05-15): replace the legacy 'I lost my train of
     thought' reply with a useful next-question synthesised from the
@@ -1773,6 +1813,18 @@ async def handle_turn(
         session.profile, is_returning_user=is_returning_user,
     )
 
+    # Bug #108 + #110 — if the user explicitly declines the pricing /
+    # family-history bundle on THIS turn, stamp the session so
+    # brain_tools.retrieve_policies' one-shot re-ask gate is bypassed (a
+    # skip is honoured under SOFT-capture semantics; we never nag). Sticky
+    # for the rest of the session — once the user says "just show me
+    # options" we don't re-gate the bundle on later recommendation turns.
+    try:
+        if _user_skipped_pricing_inputs(user_text):
+            session.pricing_bundle_skipped = True
+    except Exception:  # noqa: BLE001 — never break a turn for this
+        pass
+
     # The running `contents` list — we append model turns + function
     # responses to it across loop iterations so Gemini sees the entire
     # tool-call thread when emitting its final text.
@@ -1969,21 +2021,57 @@ async def handle_turn(
         retrieved_chunks_all=retrieved_chunks_all,
         marked_policy_ids=last_marked_policy_ids,
     )
-    if is_recommendation:
+    # Bug #107 (2026-05-16) — FACT-FIND / CLARIFYING TURNS CARRY NO
+    # CITATIONS.
+    #
+    # ROOT CAUSE: on a non-recommendation turn `citations` fell back to
+    # `recall_citations` (the raw retrieve_policies recall dump). When the
+    # LLM speculatively called retrieve_policies and THEN asked the user a
+    # clarifying / fact-find question (no policy named in prose, no
+    # mark_recommendation), that dump still flowed to the frontend, which
+    # rendered a full ranked "CITED POLICIES" list directly under a reply
+    # that says "Before I recommend… I need more info" — the cards
+    # contradict the message.
+    #
+    # "FACT-FIND vs RECOMMENDATION turn" detection (deterministic, no LLM):
+    #   • RECOMMENDATION turn  ⇔ `is_recommendation` is True
+    #       (_build_recommendation_citations saw an explicit
+    #        mark_recommendation OR a retrieved policy NAMED in the reply
+    #        prose) AND the required-slot profile gate is satisfied
+    #        (brain_tools._profile_complete — the SAME gate
+    #        retrieve_policies and main._compute_profile_complete use).
+    #   • Anything else (profile gate NOT satisfied, or no policy
+    #     recommended) is a FACT-FIND / clarifying / chit-chat turn.
+    #
+    # Only a RECOMMENDATION turn attaches policy citations. A fact-find or
+    # clarifying turn returns an EMPTY list so the UI renders nothing under
+    # the question. This also covers the spec's "no recommendation made /
+    # profile gate not satisfied" wording exactly.
+    try:
+        _profile_gate_ok = brain_tools._profile_complete(session.profile)
+    except Exception:  # noqa: BLE001 — gate read must never break a turn
+        _profile_gate_ok = False
+    _is_recommendation_turn = bool(is_recommendation) and _profile_gate_ok
+
+    if _is_recommendation_turn:
         # Recommendation turn — cards mirror the prose 1:1 (same count,
         # same order). An empty rec set here is CORRECT (do not fall back
         # to the recall dump and resurrect un-named policies).
         citations = rec_citations
     else:
-        # Pure QA / chit-chat (no shortlist named) — keep legacy recall
-        # chips so a factual answer still surfaces its supporting source.
-        citations = recall_citations
+        # FACT-FIND / clarifying / chit-chat turn — NO policy citations.
+        # Even if retrieve_policies ran speculatively this turn, the user
+        # is being asked for more info, not given a recommendation; the
+        # ranked-card UI must not contradict the question (Bug #107).
+        citations = []
 
     if len(citations) != len(recall_citations):
         _log.info(
-            "single_brain citations: rec=%d recall=%d is_rec=%s marked=%d "
-            "(KI-278 prose-aligned)",
+            "single_brain citations: rec=%d recall=%d is_rec=%s "
+            "profile_gate_ok=%s rec_turn=%s marked=%d "
+            "(KI-278 prose-aligned; Bug #107 fact-find gate)",
             len(citations), len(recall_citations), is_recommendation,
+            _profile_gate_ok, _is_recommendation_turn,
             len(last_marked_policy_ids),
         )
 
@@ -1997,7 +2085,10 @@ async def handle_turn(
     # derived from real state (prior snapshot + this turn's
     # save_profile_field calls) — nothing is invented. Only on
     # recommendation turns; the citation/gate behaviour is unchanged.
-    if is_recommendation:
+    # Bug #107 — use the GATED recommendation-turn signal (is_recommendation
+    # AND profile gate satisfied) so a fact-find turn that speculatively
+    # retrieved never emits a drop note or overwrites the rec snapshot.
+    if _is_recommendation_turn:
         _change_note = _recommendation_change_note(
             prev_snapshot=prev_rec_snapshot,
             current_citations=citations,
@@ -2019,7 +2110,7 @@ async def handle_turn(
     # blind the next constraint-driven swap. brain_tools.mark_recommendation
     # already wrote last_recommendation_ids; this name-bearing snapshot is
     # written here (single_brain owns it; brain_tools is out of scope).
-    if is_recommendation and citations:
+    if _is_recommendation_turn and citations:
         try:
             session.last_recommendation_snapshot = {
                 (c.get("policy_id") or "").strip(): c.get("policy_name", "")

backend/voice_format.py

@@ -317,6 +317,46 @@ def _expand_acronyms(text: str, language: str = "en") -> str:
     return text
 
 
+_ONES = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
+         "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
+         "sixteen", "seventeen", "eighteen", "nineteen"]
+_TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
+         "eighty", "ninety"]
+
+
+def _int_to_words(n: int) -> str:
+    """Deterministic 0–99,999 → spoken English (no external dep). Covers ages,
+    counts, years. Money/lakh/crore is already handled by _normalize_money."""
+    if n < 20:
+        return _ONES[n]
+    if n < 100:
+        return _TENS[n // 10] + ("-" + _ONES[n % 10] if n % 10 else "")
+    if n < 1000:
+        return _ONES[n // 100] + " hundred" + (" " + _int_to_words(n % 100) if n % 100 else "")
+    if n < 100000:
+        return _int_to_words(n // 1000) + " thousand" + (" " + _int_to_words(n % 1000) if n % 1000 else "")
+    return str(n)
+
+
+def _normalize_numbers(text: str) -> str:
+    """#106 — Sarvam TTS spells bare numerals digit-by-digit ("29" → "two
+    nine") and chokes on en/em dashes ("29–year-old"). Run AFTER
+    _normalize_money (so lakh/crore is already words): neutralise –/— to a
+    space, then expand any remaining standalone integer ≤ 99,999 to words so
+    the spoken payload says "twenty-nine". Display text is untouched."""
+    text = re.sub(r"\s*[–—]\s*", " ", text)
+    def _sub(m: "re.Match[str]") -> str:
+        try:
+            return _int_to_words(int(m.group(0)))
+        except (ValueError, TypeError):
+            return m.group(0)
+    # standalone integers only — not glued to letters/decimals/version-ids
+    text = re.sub(r"(?<![\w.])\d{1,5}(?![\w.])", _sub, text)
+    # spoken "percent" so "ten%" isn't read as "ten" (symbol dropped)
+    text = re.sub(r"\s*%", " percent", text)
+    return text
+
+
 def _compress_whitespace(text: str) -> str:
     text = re.sub(r"\n{2,}", ". ", text)  # paragraph break → sentence break
     text = re.sub(r"\n", " ", text)
@@ -537,6 +577,10 @@ def tts_preprocess(text: str, language: str = "en", max_words: int = 60) -> str:
     # acronym handling so ₹5L becomes "5 lakhs" instead of getting caught
     # by the bare-L acronym path.
     cleaned = _normalize_money(cleaned)
+    # #106 — AFTER money (lakh/crore already words): expand remaining bare
+    # integers ("29" → "twenty-nine") + neutralise en/em dashes so Sarvam
+    # stops spelling numbers digit-by-digit ("two nine year old").
+    cleaned = _normalize_numbers(cleaned)
     cleaned = _expand_acronyms(cleaned, language=language)
     cleaned = _compress_whitespace(cleaned)
     cleaned = _truncate_for_voice(cleaned, max_words=max_words)

frontend/src/app/page.tsx

@@ -1160,10 +1160,17 @@ export default function Page() {
             }
           } else if (tr.text && tr.text.trim()) {
             // KI-213 — replace the interim SR transcript with Sarvam's
-            // authoritative version, then submit. send() clears the input
-            // itself so the brief flash here is intentional UX feedback.
+            // authoritative version, then submit.
+            // #105 — the live composer shows the Web-Speech INTERIM (instant
+            // but approximate / shorter); the SENT message is this Sarvam
+            // authoritative text (fuller, punctuated). Before, setInput then
+            // immediate send() cleared it in the same tick, so the user only
+            // ever saw the shorter interim and read it as "truncated". Show
+            // the full authoritative transcript for a perceptible beat so
+            // what they see == what is sent, THEN submit.
             // V4 FIX 4 — transcript-sourced.
             setInputFromTranscript(tr.text);
+            await new Promise((r) => setTimeout(r, 380));
             // send() flips voicePhase to "thinking" itself; no need to set here
             await send(tr.text);
           } else if (srFallback) {

tests/test_bug107_108_109_110_factfind.py

@@ -0,0 +1,383 @@
+"""Bug #107 / #108 / #109 / #110 (2026-05-16) — fact-find / profile
+regressions found live by the user.
+
+#107 — On a FACT-FIND / clarifying turn (the assistant is asking for more
+       profile info, NOT recommending), the response still carried policy
+       citations so the UI rendered a ranked "CITED POLICIES" list directly
+       under "Before I recommend… I need more info". A fact-find /
+       clarifying turn (profile gate NOT satisfied, or no recommendation
+       made) must carry ZERO citations.
+
+#108 — When the user answers SOME but not ALL of the post-recap pricing /
+       family-history bundle (SI / budget / co-pay / family history /
+       smoker), the bot recommended with the unanswered slot blank. The
+       gate must re-ask the still-missing slot(s) ONCE before recommending;
+       only proceed once they are filled OR the user explicitly skipped.
+
+#109 — User states a premium budget in chat ("max ₹15,000/yr"); it must be
+       persisted to the documented `budget_band` contract field as a
+       canonical band so the profile panel can pre-fill it (not stored as
+       the raw "15000" string the panel's band→inr switch can't map).
+
+#110 — The fact-find never asked family_medical_history. It must be part
+       of the post-recap bundle with the same optional/skip handling, and
+       the deterministic gate must re-ask it when unresolved.
+
+Run:
+    cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
+    PYTHONPATH=$PWD .venv/bin/python -m pytest -q \\
+        tests/test_bug107_108_109_110_factfind.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import unittest
+import uuid
+from pathlib import Path
+from unittest import mock
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+from backend import brain_tools, single_brain  # noqa: E402
+from backend.brain_tools import (  # noqa: E402
+    _coerce_budget_band,
+    _unresolved_pricing_bundle,
+    save_profile_field,
+)
+from backend.needs_finder import Profile  # noqa: E402
+from backend.single_brain import (  # noqa: E402
+    SYSTEM_PROMPT,
+    _user_skipped_pricing_inputs,
+)
+
+
+def _run(coro):
+    return asyncio.new_event_loop().run_until_complete(coro)
+
+
+def _fc_part(name, args):
+    return {"functionCall": {"name": name, "args": args}}
+
+
+def _text_payload(text):
+    return {"candidates": [{"content": {"parts": [{"text": text}]}}]}
+
+
+def _tool_payload(parts):
+    return {"candidates": [{"content": {"parts": parts}}]}
+
+
+def _enriched(pid, name, slug, score, cid, *, grade="B", overall=80):
+    return {
+        "chunk_id": cid, "policy_id": pid, "policy_name": name,
+        "insurer_slug": slug, "doc_type": "policy",
+        "source_url": f"https://example.com/{pid}.pdf", "score": score,
+        "_grade": grade, "_overall_score": overall,
+    }
+
+
+class _Harness(unittest.TestCase):
+    """Drives single_brain.handle_turn for real with Gemini + the vector
+    store stubbed. The Bug #107 citation gate, the Bug #108/#110 bundle
+    re-ask gate, and the Bug #109 budget coercer all run for real."""
+
+    def setUp(self):
+        self._env = mock.patch.dict(os.environ,
+                                    {"GOOGLE_API_KEY": "test-key"})
+        self._env.start()
+        self._gemini_script: list = []
+        self._retrieve_chunks: list = []
+
+        async def _fake_gemini(*_a, **_k):
+            if not self._gemini_script:
+                return _text_payload("(no more scripted turns)")
+            return self._gemini_script.pop(0)
+
+        # The vector store is the only thing we hard-stub; the REAL
+        # brain_tools.retrieve_policies gate (7-slot profile gate + the Bug
+        # #108/#110 post-recap bundle re-ask gate) must run. We wrap the
+        # real function so the gate executes for real, but the network /
+        # Chroma seam (rag.retrieve) is replaced by canned chunks.
+        _real_retrieve_policies = brain_tools.retrieve_policies
+
+        async def _fake_rag_retrieve(*_a, **_k):
+            class _C:
+                pass
+            out = []
+            for c in self._retrieve_chunks:
+                o = _C()
+                for k, v in c.items():
+                    setattr(o, k, v)
+                o.text = c.get("chunk_text", "")
+                out.append(o)
+            return out
+
+        async def _fake_retrieve_policies(*a, **k):
+            sess = k.get("session")
+            with mock.patch("rag.retrieve.retrieve", _fake_rag_retrieve), \
+                 mock.patch(
+                     "backend.retrieval_filters.filter_pipeline",
+                     lambda raw, **_kw: (raw, None)), \
+                 mock.patch.object(brain_tools, "_load_policy_facts",
+                                   lambda *_x, **_y: {}), \
+                 mock.patch.object(brain_tools, "_scorecard_signal",
+                                   lambda *_x, **_y: {}):
+                res = await _real_retrieve_policies(*a, **k)
+            # Mirror the real session bookkeeping the citation builder needs.
+            if sess is not None and res.get("chunks"):
+                sess.last_retrieved_chunks = list(res["chunks"])
+                sess.slug_to_insurer = {
+                    c["policy_id"]: c.get("insurer_slug", "")
+                    for c in res["chunks"]
+                }
+            return res
+
+        self._gp = mock.patch.object(single_brain, "_gemini_call",
+                                     _fake_gemini)
+        self._rp = mock.patch.object(brain_tools, "retrieve_policies",
+                                     _fake_retrieve_policies)
+        self._gp.start()
+        self._rp.start()
+
+    def tearDown(self):
+        self._rp.stop()
+        self._gp.stop()
+        self._env.stop()
+
+    def _fresh_session(self):
+        from backend.session_state import SessionState
+        return SessionState(session_id=f"t_{uuid.uuid4().hex[:8]}")
+
+    def _required_filled_session(self):
+        """7 required slots filled; pricing bundle NOT yet resolved."""
+        sess = self._fresh_session()
+        sess.profile.name = "Asha"
+        sess.profile.age = 35
+        sess.profile.dependents = "self+spouse"
+        sess.profile.location_tier = "metro"
+        sess.profile.income_band = "10L-25L"
+        sess.profile.primary_goal = "first_buy"
+        sess.profile.health_conditions = ["none"]
+        return sess
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# BUG #107 — fact-find / clarifying turns carry NO citations
+# ════════════════════════════════════════════════════════════════════════════
+class TestBug107NoCitationsOnFactFind(_Harness):
+    def test_speculative_retrieve_then_clarifying_question_has_no_cards(self):
+        # Profile is INCOMPLETE (name only). The LLM speculatively retrieves
+        # then — correctly — asks a clarifying question. The recall dump must
+        # NOT flow to the UI as a ranked CITED POLICIES list.
+        sess = self._fresh_session()
+        sess.profile.name = "Rohit"
+        self._retrieve_chunks = [
+            _enriched("hdfc-ergo__optima-secure", "my:Optima Secure",
+                      "hdfc-ergo", 0.71, "c1"),
+            _enriched("niva-bupa__reassure-3", "ReAssure 3.0",
+                      "niva-bupa", 0.66, "c2"),
+        ]
+        self._gemini_script = [
+            _tool_payload([_fc_part("retrieve_policies",
+                                    {"query": "family floater metro"})]),
+            _text_payload(
+                "Before I recommend, I need a bit more — how old are you, "
+                "and who should the cover include?"),
+        ]
+        r = _run(single_brain.handle_turn(sess, "I need health insurance"))
+        self.assertEqual(
+            r.citations, [],
+            "Bug #107: a clarifying / fact-find turn (profile gate not "
+            "satisfied) must carry ZERO policy citations")
+
+    def test_recommendation_turn_with_complete_profile_still_cites(self):
+        # Control: a genuine recommendation turn (profile complete, bundle
+        # skipped) still attaches the cited cards — the gate must not break
+        # the happy path.
+        sess = self._required_filled_session()
+        sess.pricing_bundle_skipped = True
+        self._retrieve_chunks = [
+            _enriched("hdfc-ergo__optima-secure", "my:Optima Secure",
+                      "hdfc-ergo", 0.71, "c1", grade="A", overall=85),
+        ]
+        self._gemini_script = [
+            _tool_payload([_fc_part("retrieve_policies",
+                                    {"query": "metro family 10L"})]),
+            _tool_payload([_fc_part("mark_recommendation", {
+                "policy_ids": ["hdfc-ergo__optima-secure"]})]),
+            _text_payload("I recommend my:Optima Secure (HDFC ERGO)."),
+        ]
+        r = _run(single_brain.handle_turn(sess, "show me options"))
+        ids = [c["policy_id"] for c in r.citations]
+        self.assertEqual(ids, ["hdfc-ergo__optima-secure"],
+                         "recommendation turn must still attach cited cards")
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# BUG #108 + #110 — partial pricing/family-history answer → re-ask gate
+# ════════════════════════════════════════════════════════════════════════════
+class TestBug108PartialAnswerReask(_Harness):
+    def test_unresolved_bundle_includes_family_medical_history(self):
+        # Bug #110 — family_medical_history is part of the bundle the gate
+        # tracks; with nothing pricing-related captured it's unresolved.
+        p = Profile()
+        sess = self._fresh_session()
+        unresolved = _unresolved_pricing_bundle(p, sess)
+        self.assertIn("family_medical_history", unresolved)
+        self.assertIn("smoker", unresolved)
+
+    def test_explicit_skip_resolves_the_whole_bundle(self):
+        p = Profile()
+        sess = self._fresh_session()
+        sess.pricing_bundle_skipped = True
+        self.assertEqual(_unresolved_pricing_bundle(p, sess), [])
+
+    def test_partial_answer_triggers_one_shot_reask_then_proceeds(self):
+        # User answered SI + budget + co-pay but NOT smoker / family
+        # history. The gate must re-ask (not recommend); the C/F bundle
+        # slots come back in the directive.
+        sess = self._required_filled_session()
+        sess.profile.desired_sum_insured_inr = 1_000_000
+        sess.profile.budget_band = "15k_30k"
+        sess.profile.copay_pct = 0
+        # smoker + family_medical_history still missing.
+        self._retrieve_chunks = [
+            _enriched("hdfc-ergo__optima-secure", "my:Optima Secure",
+                      "hdfc-ergo", 0.71, "c1"),
+        ]
+        # The LLM tries to retrieve → the gate intercepts → it then asks the
+        # user the re-ask question (no recommendation this turn).
+        self._gemini_script = [
+            _tool_payload([_fc_part("retrieve_policies",
+                                    {"query": "metro family 10L"})]),
+            _text_payload(
+                "Just two more: any major conditions in your blood family, "
+                "and do you smoke?"),
+        ]
+        r1 = _run(single_brain.handle_turn(sess, "10 lakh, 20k budget, "
+                                                 "zero co-pay"))
+        # Bug #108: no recommendation cards on the re-ask turn.
+        self.assertEqual(r1.citations, [])
+        # One-shot guard now set.
+        self.assertTrue(sess.pricing_bundle_reasked)
+
+        # Turn 2 — user answers the missing slots, then the recommend
+        # proceeds (gate no longer blocks; one-shot already consumed).
+        self._gemini_script = [
+            _tool_payload([
+                _fc_part("save_profile_field",
+                         {"field": "family_medical_history",
+                          "value": "none"}),
+                _fc_part("save_profile_field",
+                         {"field": "smoker", "value": "no"}),
+            ]),
+            _tool_payload([_fc_part("retrieve_policies",
+                                    {"query": "metro family 10L no PED"})]),
+            _tool_payload([_fc_part("mark_recommendation", {
+                "policy_ids": ["hdfc-ergo__optima-secure"]})]),
+            _text_payload("I recommend my:Optima Secure (HDFC ERGO)."),
+        ]
+        r2 = _run(single_brain.handle_turn(
+            sess, "no family history, non-smoker"))
+        self.assertEqual(sess.profile.smoker, False)
+        self.assertEqual(sess.profile.family_medical_history, [])
+        self.assertEqual(
+            [c["policy_id"] for c in r2.citations],
+            ["hdfc-ergo__optima-secure"],
+            "after the missing bundle slots are filled the recommendation "
+            "proceeds and cites the policy")
+
+    def test_explicit_skip_bypasses_the_reask_gate(self):
+        sess = self._required_filled_session()
+        self._retrieve_chunks = [
+            _enriched("hdfc-ergo__optima-secure", "my:Optima Secure",
+                      "hdfc-ergo", 0.71, "c1", grade="A", overall=85),
+        ]
+        self._gemini_script = [
+            _tool_payload([_fc_part("retrieve_policies",
+                                    {"query": "metro family"})]),
+            _tool_payload([_fc_part("mark_recommendation", {
+                "policy_ids": ["hdfc-ergo__optima-secure"]})]),
+            _text_payload("I recommend my:Optima Secure."),
+        ]
+        # User explicitly skips the pricing inputs → gate is bypassed,
+        # recommendation proceeds on the SAME turn.
+        r = _run(single_brain.handle_turn(
+            sess, "just show me options, you decide"))
+        self.assertTrue(sess.pricing_bundle_skipped)
+        self.assertEqual([c["policy_id"] for c in r.citations],
+                         ["hdfc-ergo__optima-secure"])
+
+    def test_skip_phrase_detector(self):
+        self.assertTrue(_user_skipped_pricing_inputs("just show me options"))
+        self.assertTrue(_user_skipped_pricing_inputs("you decide"))
+        self.assertTrue(_user_skipped_pricing_inputs("skip the rest"))
+        self.assertFalse(_user_skipped_pricing_inputs("10 lakh cover"))
+        self.assertFalse(_user_skipped_pricing_inputs(""))
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# BUG #110 ��� family_medical_history is in the fact-find plan
+# ════════════════════════════════════════════════════════════════════════════
+class TestBug110FamilyHistoryInPlan(unittest.TestCase):
+    def test_system_prompt_asks_family_medical_history(self):
+        self.assertIn("Family medical history", SYSTEM_PROMPT)
+        self.assertIn("family_medical_history", SYSTEM_PROMPT)
+        # The partial-answer re-ask rule names the most-dropped slot.
+        self.assertIn("FAMILY MEDICAL HISTORY", SYSTEM_PROMPT)
+
+    def test_family_history_is_in_the_bundle_questions(self):
+        self.assertIn("family_medical_history",
+                      brain_tools._PRICING_BUNDLE_CORE)
+        self.assertIn("family_medical_history",
+                      brain_tools._PRICING_BUNDLE_QUESTIONS)
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# BUG #109 — budget persists to budget_band as a canonical band
+# ════════════════════════════════════════════════════════════════════════════
+class TestBug109BudgetBandPersistence(unittest.TestCase):
+    def test_numeric_string_maps_to_band(self):
+        # The exact live phrasing.
+        self.assertEqual(_coerce_budget_band("max ₹15,000/yr"), "15k_30k")
+        self.assertEqual(_coerce_budget_band("15000"), "15k_30k")
+        self.assertEqual(_coerce_budget_band("around 30k"), "30k_60k")
+        self.assertEqual(_coerce_budget_band("12000"), "under_15k")
+        self.assertEqual(_coerce_budget_band("1 lakh"), "60k+")
+
+    def test_numeric_value_maps_to_band(self):
+        self.assertEqual(_coerce_budget_band(15000), "15k_30k")
+        self.assertEqual(_coerce_budget_band(12000), "under_15k")
+        self.assertEqual(_coerce_budget_band(45000), "30k_60k")
+        self.assertEqual(_coerce_budget_band(80000), "60k+")
+
+    def test_canonical_band_passes_through(self):
+        for band in ("under_15k", "15k_30k", "30k_60k", "60k+"):
+            self.assertEqual(_coerce_budget_band(band), band)
+        # case / space tolerant
+        self.assertEqual(_coerce_budget_band("15K_30K"), "15k_30k")
+
+    def test_unparseable_returns_none_not_raw(self):
+        self.assertIsNone(_coerce_budget_band("dunno"))
+        self.assertIsNone(_coerce_budget_band(""))
+
+    def test_save_profile_field_persists_band_not_raw(self):
+        class _S:
+            profile = Profile()
+        s = _S()
+        out = save_profile_field(s, field="budget_band",
+                                 value="max ₹15,000/yr")
+        self.assertTrue(out["saved"])
+        self.assertEqual(out["value"], "15k_30k")
+        self.assertEqual(s.profile.budget_band, "15k_30k",
+                         "Bug #109: must be the canonical band the profile "
+                         "panel can map, not the raw '15000' string")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

tests/test_bug69_71_conversation_logic.py

@@ -187,6 +187,25 @@ class _HandleTurnHarness(unittest.TestCase):
         from backend.session_state import SessionState
         return SessionState(session_id=f"t_{uuid.uuid4().hex[:8]}")
 
+    def _ready_session(self):
+        """A session whose 7 required slots are filled AND the post-recap
+        pricing bundle is marked skipped — the realistic precondition for a
+        RECOMMENDATION turn. Bug #107 only attaches citations once the
+        profile gate (brain_tools._profile_complete) is satisfied, and Bug
+        #108's one-shot bundle re-ask gate is bypassed when the user skipped
+        the pricing inputs. End-to-end recommendation tests must reflect
+        that real flow rather than recommend off an empty profile."""
+        sess = self._fresh_session()
+        sess.profile.name = "Asha"
+        sess.profile.age = 35
+        sess.profile.dependents = "self+spouse"
+        sess.profile.location_tier = "metro"
+        sess.profile.income_band = "10L-25L"
+        sess.profile.primary_goal = "first_buy"
+        sess.profile.health_conditions = ["none"]
+        sess.pricing_bundle_skipped = True
+        return sess
+
 
 # ════════════════════════════════════════════════════════════════════════════
 # BUG #69 — end-to-end: all details EXCEPT name early; name turn not a no-match
@@ -382,7 +401,7 @@ class TestBug71EndToEnd(_HandleTurnHarness):
         # Retrieval surfaces a strong B/75 and a weak C/64 for this user's
         # own profile. Even if the LLM names both, the cited recommendation
         # set must exclude the C/64.
-        sess = self._fresh_session()
+        sess = self._ready_session()
         self._retrieve_chunks = [
             _enriched("hdfc-ergo__optima-secure", "my:Optima Secure",
                       "hdfc-ergo", 0.71, "c1", grade="B", overall=75),
@@ -411,7 +430,7 @@ class TestBug71EndToEnd(_HandleTurnHarness):
                          "present fewer (the one strong plan), not padded")
 
     def test_handle_turn_only_weak_matches_no_padded_recommendation(self):
-        sess = self._fresh_session()
+        sess = self._ready_session()
         self._retrieve_chunks = [
             _enriched("a__x", "Plan Xray", "a", 0.7, "w1", grade="C",
                       overall=64),

tests/test_recommendation_transparency.py

@@ -333,10 +333,29 @@ class _HandleTurnHarness(unittest.TestCase):
         from backend.session_state import SessionState
         return SessionState(session_id=f"t_{uuid.uuid4().hex[:8]}")
 
+    def _ready_session(self):
+        """Session with the 7 required slots filled + the post-recap pricing
+        bundle marked skipped — the realistic precondition for a
+        RECOMMENDATION turn. Bug #107 only attaches policy citations once
+        brain_tools._profile_complete is satisfied, and Bug #108's one-shot
+        bundle re-ask gate is bypassed when the user skipped the pricing
+        inputs; recommendation-transparency assertions (snapshot persists,
+        drop note fires) must reflect that real flow."""
+        sess = self._fresh_session()
+        sess.profile.name = "Asha"
+        sess.profile.age = 35
+        sess.profile.dependents = "self+spouse"
+        sess.profile.location_tier = "metro"
+        sess.profile.income_band = "10L-25L"
+        sess.profile.primary_goal = "first_buy"
+        sess.profile.health_conditions = ["none"]
+        sess.pricing_bundle_skipped = True
+        return sess
+
 
 class TestHandleTurnTransparency(_HandleTurnHarness):
     def test_silent_swap_becomes_explicit_on_new_constraint(self):
-        sess = self._fresh_session()
+        sess = self._ready_session()
 
         # ---- Turn 1: recommend Multiplier + ReAssure (no constraint yet).
         self._retrieve_chunks = [_MULTIPLIER, _REASSURE]
@@ -394,7 +413,7 @@ class TestHandleTurnTransparency(_HandleTurnHarness):
         self.assertIn("niva-bupa__reassure-3", cited2)
 
     def test_no_spurious_note_when_set_unchanged(self):
-        sess = self._fresh_session()
+        sess = self._ready_session()
 
         self._retrieve_chunks = [_REASSURE, _CARE]
         self._gemini_script = [
@@ -422,7 +441,7 @@ class TestHandleTurnTransparency(_HandleTurnHarness):
         self.assertEqual(r2.reply_text, "Both still fit with zero co-pay.")
 
     def test_no_note_on_pure_qa_turn_after_recommendation(self):
-        sess = self._fresh_session()
+        sess = self._ready_session()
 
         self._retrieve_chunks = [_MULTIPLIER, _REASSURE]
         self._gemini_script = [