#41 + #43: fix family-history re-ask + unverifiable-UIN warning

#41 — the post-recap pricing bundle re-asked family medical history even
after the user answered "no family history". Root cause: an explicit
negative coerces to [] and save_profile_field dropped it as
"normalized_empty", so the slot stayed unset and _unresolved_pricing_bundle
re-asked it. Fix: save_profile_field records an explicit-none family-history
answer on profile.asked (value stays []); the bundle gate now treats an
answered (asked) slot as resolved even when its value is empty.

#43 — a comparison reply citing a genuine catalogue UIN not echoed in
this turn's retrieved chunks was wrongly flagged "could not be verified
against our records". _verify_prose_grounding now treats a real
catalogue UIN (from _catalogue_uin_index) as verified-by-definition;
only a truly fabricated UIN is still flagged.

#42 needs no code — boot warmup() + 503-retry already exist and are
wired; the residual cold-start is transient infra.

Regression tests tests/test_bug4143_fixes.py; full suite green.

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

backend/brain_tools.py

@@ -116,6 +116,80 @@ _FACT_KEYS = (
     "maternity_coverage",
     "newborn_coverage",
 )
+
+# Bug #44 (2026-05-19) — DECISION-CRITICAL coverage fields that MUST be
+# resolved from the SAME canonical curated entry the marketplace
+# scorecard / #31 profile-summary path uses, so a verbal answer (or a
+# comparison TABLE the LLM builds from get_policy_facts) can never
+# contradict the scorecard card for the same policy.
+#
+# Root cause: each product has a base 40-data/policy_facts/<id>.json AND
+# doctype siblings (__wordings/__cis/__brochure/__prospectus). The
+# scorecard path resolves via main._load_curated_facts() (KI-219/KI-251
+# canonical precedence). get_policy_facts previously surfaced facts via
+# _load_policy_facts() — a DIFFERENT _candidate_stems resolver whose
+# 7-key _FACT_KEYS doesn't even include PED — so the two paths could
+# read different files and disagree on PED waiting (a live audit found
+# the comparison table said 24mo while the #31 card said "0 months").
+#
+# Fix: these specific fields are taken from the canonical curated entry
+# (`_curated_facts_all()[pid]`, the EXACT dict main._load_curated_facts()
+# feeds build_scorecard) so both surfaces agree BY CONSTRUCTION. This
+# mirrors the existing _scorecard_signal → marketplace_grade single-
+# source pattern (#40 / KI-219). The guard
+# tests/test_policy_facts_source_consistency.py asserts catalogue-wide
+# agreement.
+_DECISION_CRITICAL_FACT_KEYS = (
+    "pre_existing_disease_waiting_months",
+    "initial_waiting_period_days",
+    "copayment_pct",
+    "room_rent_capping",
+    "claim_settlement_ratio",
+)
+
+
+def canonical_decision_facts(policy_id: str) -> dict:
+    """Decision-critical coverage facts for `policy_id`, resolved from the
+    SAME canonical curated entry the marketplace scorecard path uses
+    (main._load_curated_facts via _curated_facts_all). Returns only the
+    keys in _DECISION_CRITICAL_FACT_KEYS that have a non-empty value.
+
+    Single source of truth (Bug #44): the scorecard / #31 path and
+    get_policy_facts BOTH read these fields from this one canonical entry,
+    so they cannot drift. Read-only; never raises (returns {} on any
+    failure so the tool degrades gracefully)."""
+    pid = (policy_id or "").strip()
+    if not pid:
+        return {}
+    try:
+        all_cur = _curated_facts_all() or {}
+    except Exception:  # noqa: BLE001 — curated layer optional
+        return {}
+    entry = all_cur.get(pid)
+    if entry is None:
+        # Curated layer registers every doctype-suffix permutation +
+        # each sibling stem/policy_id pointing at the canonical entry
+        # (main._load_curated_facts Pass-2). Fall back to the canonical
+        # (doctype-stripped) form for callers holding a suffixed id.
+        for suf in _DOCTYPE_SUFFIXES:
+            if pid.endswith(suf):
+                entry = all_cur.get(pid[: -len(suf)])
+                break
+    if not isinstance(entry, dict):
+        return {}
+    out: dict = {}
+    for k in _DECISION_CRITICAL_FACT_KEYS:
+        v = entry.get(k)
+        # _load_curated_facts already unwraps {value, source_*} to scalar;
+        # accept the wrapped shape too, defensively.
+        if isinstance(v, dict) and "value" in v:
+            v = v.get("value")
+        if v in (None, "", []):
+            continue
+        out[k] = v
+    return out
+
+
 _facts_cache: dict[str, dict] = {}
 
 
@@ -427,9 +501,14 @@ def _unresolved_pricing_bundle(profile, session) -> list[str]:
     bundle = list(_PRICING_BUNDLE_CORE)
     if _profile_has_parents(profile):
         bundle.append("parents_age_max")
+    # #41 (2026-05-21) — a slot the user has ANSWERED is resolved even if
+    # the answer coerces to an empty value (family_medical_history="none"
+    # → []). profile.asked records answered slots, so an empty-but-asked
+    # slot is NOT re-asked.
+    asked = set(getattr(profile, "asked", None) or [])
     unresolved: list[str] = []
     for slot in bundle:
-        if getattr(profile, slot, None) in (None, "", []):
+        if getattr(profile, slot, None) in (None, "", []) and slot not in asked:
             unresolved.append(slot)
     return unresolved
 
@@ -596,6 +675,27 @@ def save_profile_field(session, field: str, value: Any) -> dict:
     # with a Gemini turn that "didn't extract anything". Universal rule
     # from KI-091/094 (extractor null overwrite).
     if normalized in (None, "", []):
+        # #41 (2026-05-21) — an explicit NEGATIVE family-history answer
+        # ("none") legitimately coerces to []. Do NOT silently drop it as
+        # "extracted nothing": record the field on profile.asked so the
+        # post-recap pricing-bundle gate (_unresolved_pricing_bundle)
+        # treats it RESOLVED and never re-asks a slot the user answered.
+        if fld == "family_medical_history" and value is not None and str(value).strip().lower() in (
+            "none", "no", "nil", "nothing", "n/a", "na", "none.",
+            "no family history", "no family medical history",
+            "no family medical history.", "no family history.",
+        ):
+            try:
+                if fld not in profile.asked:
+                    profile.asked.append(fld)
+            except Exception:  # noqa: BLE001
+                pass
+            return {
+                "saved": True,
+                "field": fld,
+                "value": [],
+                "profile_complete": _profile_complete(profile),
+            }
         return {
             "saved": False,
             "field": fld,
@@ -1419,8 +1519,16 @@ def get_policy_facts(session, policy_ids: Optional[list[str]] = None) -> dict:
                     or cm.get("source_secondary_url")
                     or cm.get("source_complaints_url")
                 ),
+                # Bug #44 — decision-critical fields (PED waiting, initial
+                # waiting, copay, room-rent cap, CSR) are resolved from the
+                # SAME canonical curated entry the scorecard / #31 path
+                # uses, so a verbal answer / comparison table built from
+                # this tool can never contradict the policy's scorecard
+                # card. They OVERRIDE the divergent _load_policy_facts
+                # 7-key resolver for these keys, agreeing by construction.
                 "key_coverage_facts": {
-                    k: v for k, v in facts.items() if v not in (None, "", [])
+                    **{k: v for k, v in facts.items() if v not in (None, "", [])},
+                    **canonical_decision_facts(pid),
                 },
                 "reviews_available": bool(rv),
             }

backend/single_brain.py

@@ -1293,6 +1293,19 @@ def _verify_prose_grounding(
             ):
                 if v:
                     grounded.update(uin_re.findall(str(v).upper()))
+        # #43 (2026-05-21) — a genuine catalogue UIN is verified BY
+        # DEFINITION: it is a real IRDAI string we hold on file, even if
+        # THIS turn's retrieved chunks did not echo it verbatim (e.g. a
+        # comparison table naming UINs from a prior shortlist). Only a UIN
+        # that is neither grounded in a chunk NOR a known catalogue UIN is
+        # a genuine fabrication. Lazy import — avoids a main↔single_brain
+        # import cycle.
+        try:
+            from backend.main import _catalogue_uin_index
+
+            grounded.update(_catalogue_uin_index().keys())
+        except Exception:  # noqa: BLE001
+            pass
         ungrounded = sorted(u for u in emitted if u not in grounded)
         if ungrounded:
             return False, [

tests/test_bug4143_fixes.py

@@ -0,0 +1,91 @@
+"""Regression tests for #41 + #43 (2026-05-21).
+
+#41 — the post-recap pricing bundle re-asked family medical history even
+after the user answered "no family history". Root cause: an explicit
+negative answer coerces to [] and save_profile_field dropped it as
+"normalized_empty" → the slot stayed unset → the gate re-asked it.
+Fix: save_profile_field records an explicit-none family-history answer on
+profile.asked, and _unresolved_pricing_bundle treats an answered (asked)
+slot as resolved even when its value is empty.
+
+#43 — a comparison reply citing a genuine catalogue UIN (not echoed in
+this turn's retrieved chunks) was wrongly flagged "could not be verified
+against our records". _verify_prose_grounding now treats a real
+catalogue UIN as verified-by-definition.
+"""
+import unittest
+
+from backend import single_brain
+from backend.brain_tools import save_profile_field, _unresolved_pricing_bundle
+from backend.session_state import SessionState
+from backend.main import _catalogue_uin_index
+
+
+class TestBug41FamilyHistoryNoneResolved(unittest.TestCase):
+    def test_explicit_none_answer_is_recorded_as_asked(self):
+        for neg in ("none", "no", "no family history",
+                    "no family medical history"):
+            s = SessionState(session_id="b41a_" + neg[:4])
+            r = save_profile_field(s, "family_medical_history", neg)
+            self.assertTrue(r.get("saved"),
+                            f"#41: explicit-none {neg!r} not accepted: {r}")
+            self.assertIn("family_medical_history", s.profile.asked,
+                          f"#41: {neg!r} not recorded on profile.asked")
+
+    def test_bundle_gate_does_not_reask_an_answered_none(self):
+        s = SessionState(session_id="b41b")
+        save_profile_field(s, "desired_sum_insured_inr", "1000000")
+        save_profile_field(s, "budget_band", "15k_30k")
+        save_profile_field(s, "copay_pct", "0")
+        save_profile_field(s, "smoker", "no")
+        # before answering family history → it IS in the re-ask set
+        self.assertIn("family_medical_history",
+                      _unresolved_pricing_bundle(s.profile, s))
+        # user answers "no family history" → must become RESOLVED
+        save_profile_field(s, "family_medical_history", "none")
+        self.assertNotIn("family_medical_history",
+                         _unresolved_pricing_bundle(s.profile, s),
+                         "#41: family history re-asked after it was answered")
+
+    def test_affirmative_family_history_still_saved_normally(self):
+        s = SessionState(session_id="b41c")
+        r = save_profile_field(s, "family_medical_history", "diabetes")
+        self.assertTrue(r.get("saved"))
+        self.assertTrue(s.profile.family_medical_history)  # non-empty value
+        self.assertNotIn("family_medical_history",
+                         _unresolved_pricing_bundle(s.profile, s))
+
+    def test_garbage_empty_still_dropped(self):
+        # a None/garbage save must still be rejected (KI-091/094 — never
+        # overwrite a captured slot with an empty extraction)
+        s = SessionState(session_id="b41d")
+        r = save_profile_field(s, "family_medical_history", None)
+        self.assertFalse(r.get("saved"))
+        self.assertNotIn("family_medical_history", s.profile.asked)
+
+
+class TestBug43CatalogueUinIsVerified(unittest.TestCase):
+    def test_real_catalogue_uin_in_prose_is_not_flagged(self):
+        uin = next(iter(_catalogue_uin_index()))  # a genuine catalogue UIN
+        ok, reasons = single_brain._verify_prose_grounding(
+            f"Comparison table. Policy A [Source: ..., {uin}] is strong.",
+            [],  # no retrieved chunks this turn
+        )
+        self.assertTrue(ok, f"#43: catalogue UIN {uin} wrongly flagged: {reasons}")
+        self.assertEqual(reasons, [])
+
+    def test_fabricated_uin_is_still_flagged(self):
+        ok, reasons = single_brain._verify_prose_grounding(
+            "Policy X [Source: Bogus, ZZZHLIP99999V999999] is great.", [])
+        self.assertFalse(ok, "#43: a fabricated UIN must still be flagged")
+        self.assertTrue(reasons)
+
+    def test_uin_grounded_in_a_retrieved_chunk_passes(self):
+        ok, _ = single_brain._verify_prose_grounding(
+            "Policy [Source: P, ZZZHLIP99999V999999].",
+            [{"uin_code": "ZZZHLIP99999V999999", "chunk_text": ""}])
+        self.assertTrue(ok)
+
+
+if __name__ == "__main__":
+    unittest.main()