fix: deductible gating (#29), existing-cover steering + dangling-turn guard (#30), compare-modal full reviews (#32)

#29 — deductible selector/discount was applied to all 148 though only
2 truly offer a voluntary deductible. New premium_calculator.policy_
deductible_support() (deductible_amount>0 AND not top-up → exactly
bajaj-allianz__health-guard, star-health__star-assure); estimate +
bulk gate the discount (defense-in-depth); PremiumEstimateResponse
echoes supports_voluntary_deductible/allowed_deductibles; widget
renders the deductible row only when supported. tests/test_deductible_
eligibility.py sweeps all 148.

#30 — existing_cover_inr drove neither ranking, retrieval phrasing,
nor framing; bot promised 're-evaluate' then stopped; re-eval recycled
2/3. Decisive fix B1-c: +22 existing-cover term in _fit_score for
top-ups + seed out-of-window top-ups in _quality_seed_candidates.
B1-a: RULE 2 mandatory existing-cover phrasing + Worked example C +
RULE 2.6 framing mandate. B2: RULE 3.7 never-promise + _is_promissory_
no_action + one-shot loop guard that forces the promised tool call.
B3: RULE 3 materially-different re-eval + _CONSTRAINT_FIELD_PHRASES.
tests/test_bug30_existing_cover_and_promise.py.

#32 — in-chat compare modal now reuses the FULL InsurerReviewsBlock
(same guard as the detail modal) instead of the condensed cell.

Verified: full pytest suite exit 0 (no regression); #29 474, #30
new 11 + 555 filtered, all green; frontend tsc 0 errors, eslint
0-new (page.tsx 29=baseline, PolicyPremiumWidget 0, api.ts 0).

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

backend/brain_tools.py

@@ -663,6 +663,22 @@ def save_profile_field(session, field: str, value: Any) -> dict:
 
 
 _qseed_cache: dict = {}  # (profile_sig) -> [seed chunk dicts]
+# BUG #30 (B1-c) — per-signature count of TRAILING existing-cover top-up
+# seeds in `_qseed_cache[sig]`. They sit AFTER the primary window and must
+# survive the final `[:limit]` slice so a relevant super-top-up is never
+# truncated out of contention for a user who already holds base cover.
+_qseed_topup_n: dict = {}
+
+
+def _qseed_slice(rows: list[dict], sig: str, limit: int) -> list[dict]:
+    """Return up to `limit` primary seeds PLUS all existing-cover top-up
+    seeds (which trail the list), so the top-up seeds are never cut."""
+    n_top = _qseed_topup_n.get(sig, 0)
+    if n_top <= 0:
+        return rows[:limit]
+    primaries = rows[:-n_top] if n_top < len(rows) else []
+    topups = rows[-n_top:]
+    return primaries[:limit] + topups
 
 
 def _quality_seed_candidates(profile, limit: int = 25) -> list[dict]:
@@ -684,7 +700,7 @@ def _quality_seed_candidates(profile, limit: int = 25) -> list[dict]:
             )
         )) if profile is not None else "none"
         if prof_sig in _qseed_cache:
-            return _qseed_cache[prof_sig][:limit]
+            return _qseed_slice(_qseed_cache[prof_sig], prof_sig, limit)
         cur = _curated_facts_all()
         scored: list[tuple[float, str, dict, dict]] = []
         seen: set[str] = set()
@@ -710,7 +726,41 @@ def _quality_seed_candidates(profile, limit: int = 25) -> list[dict]:
                 continue
             scored.append((ovf, pid, data, sig))
         scored.sort(key=lambda t: -t[0])
-        for ovf, pid, data, sig in scored[: max(limit, 25)]:
+        # BUG #30 (B1-c) — when the user already holds ANY base cover, also
+        # union-in the top-N top-up / super-top-up policies even if they fall
+        # outside the profile-neutral top-25 window, so a directly relevant
+        # super-top-up is seeded into contention (filter_pipeline then ranks
+        # the union via _fit_score, which now carries the existing-cover term).
+        # Deterministic: drawn from the already-sorted `scored` list, no RNG.
+        _existing = getattr(profile, "existing_cover_inr", None) \
+            if profile is not None else None
+        try:
+            _existing_int = int(str(_existing).replace(",", "").strip()) \
+                if _existing not in (None, "") else 0
+        except (TypeError, ValueError):
+            _existing_int = 0
+        window = max(limit, 25)
+        primary_rows = scored[:window]
+        extra: list[tuple[float, str, dict, dict]] = []
+        if _existing_int > 0:
+            from backend.retrieval_filters import _is_top_up as _rf_is_top_up
+            in_window = {pid for _, pid, _, _ in primary_rows}
+            _TOPUP_SEED_MAX = 3  # bounded extra seeds; keeps pool deterministic
+            for ovf, pid, data, sig in scored[window:]:
+                if pid in in_window:
+                    continue
+                probe = {
+                    "policy_name": data.get("policy_name", pid),
+                    **_load_policy_facts(pid),
+                }
+                if _rf_is_top_up(probe):
+                    extra.append((ovf, pid, data, sig))
+                    if len(extra) >= _TOPUP_SEED_MAX:
+                        break
+        # `_n_topup_seeds` is preserved on the cached list so the final
+        # slice keeps the existing-cover top-up seeds (they sit AFTER the
+        # primary window and would otherwise be cut by `out[:limit]`).
+        for ovf, pid, data, sig in primary_rows + extra:
             ch = {
                 "chunk_id": f"{pid}__qseed",
                 "policy_id": pid,
@@ -731,6 +781,8 @@ def _quality_seed_candidates(profile, limit: int = 25) -> list[dict]:
             ch.update(sig)
             out.append(ch)
         _qseed_cache[prof_sig] = out
+        _qseed_topup_n[prof_sig] = len(extra)
+        return _qseed_slice(out, prof_sig, limit)
     except Exception as e:  # noqa: BLE001 — seeding must never break retrieval
         _log.warning("quality-seed failed: %s", e)
     return out[:limit]

backend/main.py

@@ -4211,6 +4211,12 @@ class PremiumEstimateResponse(BaseModel):
     # callers (PremiumCalculatorPanel ignores both).
     tenure_years: Optional[int] = None
     deductible_inr: Optional[int] = None
+    # BUG #29 — whether THIS policy genuinely offers a user-selectable
+    # voluntary deductible (curated deductible_amount > 0 AND not a
+    # top-up). Only ~2 of 148 do. The widget hides the deductible selector
+    # entirely when False; allowed_deductibles is the exact pill set.
+    supports_voluntary_deductible: bool = False
+    allowed_deductibles: list[int] = [0]
     # True when the underlying estimate() anchored to a curated quote sample.
     # PolicyPremiumWidget uses this (instead of bulk_estimate's `assumed` flag)
     # to decide whether to show its "Estimate" badge.
@@ -4255,8 +4261,17 @@ async def premium_estimate(req: PremiumEstimateRequest):
         point = int(round(point * tenure_mult))
         low = int(round(low * tenure_mult))
         high = int(round(high * tenure_mult))
+    # BUG #29 — resolve whether this policy genuinely supports a voluntary
+    # deductible. Only ~2 of 148 do; for every other policy a caller-supplied
+    # deductible must NOT discount the premium.
+    from backend.premium_calculator import policy_deductible_support
+    _supports, _allowed = policy_deductible_support(req.policy_id)
     if req.deductible_inr is not None:
-        if req.deductible_inr in BULK_DEDUCTIBLE_DISCOUNT:
+        if not _supports or req.deductible_inr not in _allowed:
+            # Unsupported policy (or a value outside this policy's allowed
+            # set) — no phantom discount, honest echo.
+            effective_ded = 0
+        elif req.deductible_inr in BULK_DEDUCTIBLE_DISCOUNT:
             effective_ded = req.deductible_inr
         else:
             effective_ded = min(
@@ -4292,6 +4307,8 @@ async def premium_estimate(req: PremiumEstimateRequest):
         sources=e.sources or [],
         tenure_years=effective_tenure,
         deductible_inr=effective_ded,
+        supports_voluntary_deductible=_supports,
+        allowed_deductibles=_allowed,
         base_sample_used=e.base_sample_used is not None,
         sum_insured_disclosure=si_disclosure,
     )

backend/premium_calculator.py

@@ -418,6 +418,7 @@ def _per_lakh_band(policy_id: str) -> tuple[float, float]:
 
 
 _ptype_cache: dict = {}
+_ded_support_cache: dict = {}
 
 
 # Traceable overrides for genuinely-ambiguous IRDAI products the generic
@@ -497,6 +498,55 @@ def _policy_product_type(policy_id: Optional[str]) -> str:
     return t
 
 
+def policy_deductible_support(policy_id: Optional[str]) -> tuple[bool, list[int]]:
+    """Authoritative answer to "does THIS policy genuinely offer a voluntary
+    deductible the user can pick to lower the premium?" (BUG #29).
+
+    Rule: a policy supports a voluntary deductible iff it has a curated
+    `deductible_amount > 0` AND it is NOT a top-up / super-top-up (whose
+    "deductible" is a structural threshold, not a user-selectable knob).
+    Across the full 148-policy catalogue this is exactly
+    {bajaj-allianz__health-guard, star-health__star-assure}.
+
+    Returns (supports, allowed_deductibles). `allowed_deductibles` always
+    includes 0 (the no-deductible baseline) plus the curated amount when
+    supported. Never raises — pricing must never break, so any failure
+    degrades to (False, [0]). Cached per policy_id."""
+    pid = (policy_id or "").strip()
+    if not pid:
+        return (False, [0])
+    if pid in _ded_support_cache:
+        return _ded_support_cache[pid]
+    result: tuple[bool, list[int]] = (False, [0])
+    try:
+        from backend.brain_tools import _load_policy_facts  # lazy: no cycle
+
+        f = _load_policy_facts(pid) or {}
+        pt = str(
+            f.get("policy_type")
+            or f.get("policy_type_indemnity_or_fixed")
+            or ""
+        ).lower()
+        ded = f.get("deductible_amount")
+        try:
+            ded = float(ded) if ded not in (None, "", []) else 0.0
+        except (TypeError, ValueError):
+            ded = 0.0
+        is_topup = (
+            _policy_product_type(pid) == "topup"
+            or "top" in pt
+            or "super_top" in pt
+        )
+        if ded > 0 and not is_topup:
+            result = (True, sorted({0, int(ded)}))
+        else:
+            result = (False, [0])
+    except Exception:  # noqa: BLE001 — facts optional; never break pricing
+        result = (False, [0])
+    _ded_support_cache[pid] = result
+    return result
+
+
 def _type_rel_cap(policy_id: Optional[str]) -> float:
     """Max fraction of the comprehensive-equivalent a non-comprehensive
     product may cost at the SAME profile. A cancer / top-up / hospital-cash
@@ -1029,6 +1079,14 @@ def bulk_estimate(
         if deductible_inr not in BULK_DEDUCTIBLE_DISCOUNT:
             # snap to nearest known bucket
             deductible_inr = min(BULK_DEDUCTIBLE_DISCOUNT.keys(), key=lambda d: abs(d - deductible_inr))
+        # BUG #29 — only the ~2 policies that genuinely offer a voluntary
+        # deductible may receive the discount. For every other policy a
+        # caller-supplied deductible is meaningless: force it to 0 so
+        # ded_mult resolves to 1.0 (no phantom discount) AND the echoed
+        # BulkPolicyPremium.deductible_inr is honest.
+        _ded_supported, _ded_allowed = policy_deductible_support(pid)
+        if not _ded_supported or deductible_inr not in _ded_allowed:
+            deductible_inr = 0
 
         notes: list[str] = []
         assumed = True

backend/retrieval_filters.py

@@ -859,6 +859,17 @@ def _fit_score(chunk_meta: dict, profile: Any, wants_zero_copay: bool,
             else:
                 score -= 25.0  # shouldn't survive eligibility, belt-and-braces
 
+    # BUG #30 (B1-c) — EXISTING-COVER term. When the user already holds ANY
+    # base cover (even a small ₹1L employer policy), a top-up / super-top-up
+    # is a directly relevant product that the profile-neutral scorecard is
+    # blind to. Surface it: the bonus (+22) clears roughly one letter-grade
+    # gap so a relevant top-up lands alongside the primary indemnity picks
+    # (which are untouched), giving a shortlist that mixes one strong primary
+    # plan with one relevant top-up. Inert when the user holds no base cover.
+    existing = _as_int(_profile_get(profile, "existing_cover_inr"))
+    if existing and existing > 0 and _is_top_up(chunk_meta):
+        score += 22.0
+
     # KI-280 — REQUIRED-FEATURE term. When the profile explicitly needs
     # maternity / newborn cover (P3), a plan whose curated facts CONFIRM it
     # must outrank one that does not, and an UNVERIFIED plan (fact absent)

backend/single_brain.py

@@ -187,7 +187,7 @@ Required ingredients:
   age band (e.g., "adult 30-40"),
   health-condition keywords — every captured condition by name ("diabetes", "hypertension", "heart disease") OR the literal "no PED" when health_conditions == ["none"],
   primary goal keyword,
-  existing cover signal — when existing_cover_inr > 0 add "top-up over existing X lakh cover"; when 0 add "fresh base policy",
+  existing cover signal (MANDATORY, threshold-free — BUG #30) — existing_cover_inr ANY positive value, no matter how small (even a ₹1 lakh employer policy), MUST be treated as held base cover. When existing_cover_inr > 0 you MUST (a) add the literal phrase "super top-up plan layered over existing N lakh base cover" to the retrieve_policies query (substitute N with the cover in lakh), AND (b) in the recommendation prose, state for EVERY pick how it relates to the user's existing ₹N cover — either "works as your PRIMARY plan; your ₹N employer cover supplements it" OR "this is a TOP-UP that sits above your ₹N existing cover". A recommendation that does NOT state its relation to the user's existing cover is INCOMPLETE and must not be presented. When existing_cover_inr == 0 add "fresh standalone base policy",
   parents-cover signal — when dependents mentions parents add "parents age ~XX" using parents_age_max (if captured),
   family-history rider boost — if family_medical_history is non-empty, INCLUDE keywords in the query that bias retrieval toward policies with relevant coverage:
     - "cancer" → "critical illness rider cancer cover"
@@ -202,6 +202,13 @@ Worked example A (no PED, no existing cover). Profile = {age=34, location_tier=m
 Worked example B (diabetes + employer top-up + parents). Profile = {age=42, location_tier=metro, dependents=self+spouse+parents, primary_goal=upgrade, health_conditions=["diabetes"], desired_sum_insured_inr=2500000, existing_cover_inr=500000, parents_age_max=68}:
   retrieve_policies(query="family floater plan metro sum insured 25 lakh adult 40-50 with spouse and parents diabetes managed top-up over existing 5 lakh employer cover parents age 68 upgrade plan", top_k=8)
 
+Worked example C (BUG #30 — small ₹1L employer cover + first-buy + smoker + family diabetes). Profile = {age=29, location_tier=metro, income_band=25L+, primary_goal=first_buy, health_conditions=["none"], desired_sum_insured_inr=2000000, existing_cover_inr=100000, family_medical_history="diabetes", smoker=yes}:
+  retrieve_policies(query="comprehensive base health plan individual metro sum insured 20 lakh adult 20-30 no PED first-time buyer super top-up plan layered over existing 1 lakh employer base cover diabetes short waiting period reduced PED wait smoker family history", top_k=8)
+  Model prose answer MUST surface BOTH a primary plan and a relevant super-top-up, each framed against the existing ₹1L cover, e.g.:
+    "1. <Primary indemnity plan> — this works as your PRIMARY plan; your ₹1L employer cover supplements it. Strong for a 29-yr-old first-time buyer at ₹20L SI; shorter diabetes-related waiting given your family history; smoker loading is priced in.
+     2. <Super top-up> — this is a TOP-UP that sits above your ₹1L existing cover, giving high catastrophic headroom at a low premium because it only pays above your deductible."
+  (Even though ₹1L is small, it is positive, so RULE 2's existing-cover signal fires: the query carries the "super top-up ... layered over existing 1 lakh employer base cover" phrase AND every pick is framed relative to the ₹1L cover.)
+
 If the first call returns 0 or 1 chunk, retry ONCE with a broader query (drop the most specific filter or broaden SI band by one tier) before asking the user to relax criteria.
 
 ═══════════════════════════════════
@@ -261,11 +268,46 @@ is worse than honestly presenting fewer. Never describe a clearly weak
 plan with recommendation language ("great pick", "top option") — be
 honest about where it falls short.
 
+BUG #30 — EXISTING-COVER FRAMING IS MANDATORY: when the user holds ANY
+existing cover (existing_cover_inr > 0, even a small ₹1L employer policy),
+EVERY pick you present MUST be framed relative to that existing cover —
+explicitly state whether it is the PRIMARY plan (their existing cover
+supplements it / sits below it), is LAYERED over it, or is a TOP-UP that
+sits ABOVE it. Never present a plan without saying how it interacts with
+cover the user already holds; a pick with no stated relation to existing
+cover is incomplete and must not be shown.
+
 ═══════════════════════════════════
 RULE 3 — Follow-ups + mark_recommendation
 ═══════════════════════════════════
 - After producing a ranked shortlist, call mark_recommendation(policy_ids=[...ordered IDs you cited...]).
 - For "tell me about #2" / "second one" follow-ups, call retrieve_policies(query, policy_filter_ids=[policy_id_of_#2]) to narrow to that policy.
+- BUG #30 (B3) — MATERIALLY-DIFFERENT RE-EVAL: when the user asks you to
+  reconsider in light of their existing cover (or any standing profile fact
+  — "but I already have ₹1L employer cover", "given my smoking", "factor in
+  my family diabetes"), you MUST issue a NEW retrieve_policies whose query
+  MATERIALLY DIFFERS from the prior turn's query — add the existing-cover /
+  top-up phrasing per RULE 2 (the "super top-up plan layered over existing N
+  lakh base cover" phrase) and any newly-emphasised fact. Do NOT just
+  re-narrate the ACTIVE SHORTLIST with the same wording. The revised set
+  MUST differ from the prior set by at least ONE pick UNLESS you explicitly
+  justify why the prior set is still optimal AND name the existing-cover
+  reasoning that led you there.
+
+═══════════════════════════════════
+RULE 3.7 — NEVER PROMISE WITHOUT PERFORMING (BUG #30 B2/B3)
+═══════════════════════════════════
+If your reply would say or imply that you will re-evaluate, re-check, look
+into, search again, find better options, or "take another look", you MUST
+call the tool(s) (retrieve_policies, and mark_recommendation if you are
+recommending) THIS turn and return the ACTUAL result. Never end a turn on a
+forward-looking promise ("let me re-evaluate", "let me check", "I'll look
+into it", "give me a moment"). Either DO it now and present the concrete
+result, or ask ONE specific clarifying question — never a bare promise.
+When the user asked you to reconsider in light of existing cover (or any
+standing profile fact), the re-evaluation MUST be a NEW retrieve_policies
+whose query materially differs from the prior turn's per RULE 2 / RULE 3
+(B3); re-narrating the prior shortlist verbatim is NOT a re-evaluation.
 
 ═══════════════════════════════════
 RULE 3.5 — Claims / denials / complaints / reputation / comparison → get_policy_facts (NEVER refuse)
@@ -879,6 +921,32 @@ def _user_skipped_pricing_inputs(user_text: str) -> bool:
     return any(p in t for p in _PRICING_SKIP_PHRASES)
 
 
+_PROMISSORY_NO_ACTION_PHRASES: tuple[str, ...] = (
+    "let me re-evaluate",
+    "let me check",
+    "let me look",
+    "i'll look into",
+    "i will re-evaluate",
+    "let me search",
+    "let me find",
+    "give me a moment",
+    "i'll check",
+    "let me see if",
+)
+
+
+def _is_promissory_no_action(text: str) -> bool:
+    """BUG #30 (B2) — True when the model's reply merely PROMISES to
+    re-evaluate / re-check / look into / search again instead of doing it.
+    A turn that ends on such a forward-looking promise without performing
+    the tool call is a 'promise without action' failure; the loop guard
+    re-prompts exactly once to force the actual work this turn."""
+    t = (text or "").strip().lower()
+    if not t:
+        return False
+    return any(p in t for p in _PROMISSORY_NO_ACTION_PHRASES)
+
+
 def _classify_intent(user_text: str, tool_calls_made: list[str]) -> str:
     """Best-effort intent label for logging only. Single-brain doesn't
     route on intent — but the legacy `TurnResult.intent` field is logged
@@ -1582,6 +1650,7 @@ _CONSTRAINT_FIELD_PHRASES: dict[str, str] = {
     "parents_age_max": "of the parents' age",
     "health_conditions": "of the health condition you mentioned",
     "smoker": "of the tobacco-use detail you shared",
+    "existing_cover_inr": "of the existing cover you already hold",
 }
 
 
@@ -1929,6 +1998,10 @@ async def handle_turn(
     # Defensive counter to break runaway loops.
     last_text: str = ""
     last_payload: dict = {}
+    # BUG #30 (B2) — fires at most ONCE per turn so a promissory no-tool
+    # reply ("let me re-evaluate") is re-prompted into actually calling the
+    # tool, with no risk of an infinite loop.
+    _b2_reprompted: bool = False
 
     for it in range(MAX_ITERATIONS):
         # Issue A instrumentation (KI-Z6-LATENCY, 2026-05-15) — Priya T3
@@ -1979,6 +2052,44 @@ async def handle_turn(
         if not function_calls:
             if text:
                 last_text = text
+            # BUG #30 (B2) — NEVER PROMISE WITHOUT PERFORMING. If the model
+            # ended the turn on a forward-looking promise ("let me
+            # re-evaluate / check / search") but called NO tool, re-prompt
+            # exactly once to force it to actually call the tool(s) THIS
+            # turn. Guarded by `_b2_reprompted` (fires ≤1/turn) and the
+            # iteration budget (only when a further iteration is available)
+            # so there is no infinite loop.
+            if (
+                text
+                and _is_promissory_no_action(text)
+                and not _b2_reprompted
+                and it < MAX_ITERATIONS - 1
+            ):
+                _b2_reprompted = True
+                _log.info(
+                    "single_brain iter=%d B2 promissory-no-action detected "
+                    "— re-prompting to force tool call",
+                    it,
+                )
+                contents.append({"role": "model", "parts": parts})
+                contents.append(
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "text": (
+                                    "You said you would re-evaluate/search "
+                                    "but called no tool. Do it NOW: call "
+                                    "retrieve_policies (existing-cover-aware "
+                                    "query) and mark_recommendation, then "
+                                    "present the revised shortlist. Do not "
+                                    "reply with another promise."
+                                )
+                            }
+                        ],
+                    }
+                )
+                continue
             _log.info(
                 "single_brain iter=%d gemini=%.2fs tools=%.2fs "
                 "tool_calls=[] final_text=True",

frontend/src/app/page.tsx

@@ -4060,16 +4060,21 @@ function CompareReviewsCell({ insurerSlug }: { insurerSlug: string }) {
       </div>
     );
   }
+  // FIX #32 — render the SAME FULL reputation section the policy DETAIL
+  // modal shows (page.tsx:6169-6171) instead of a condensed summary.
+  // Reuse the existing InsurerReviewsBlock component (no duplication);
+  // mirror the detail modal's guard exactly: full 6-bucket block when
+  // the payload has at least one headline metric, otherwise the same
+  // one-line graceful fallback (never a blank box — #76).
   const s = rv.aggregate_score || {};
   const cm = rv.claim_metrics || {};
   const csr = cm.claim_settlement_ratio_pct;
-  const bits: string[] = [];
-  if (s.letter_grade) bits.push(s.letter_grade);
-  if (s.value_0_100 != null) bits.push(`${s.value_0_100}/100`);
-  if (csr != null) bits.push(`${csr}% claims settled`);
-  // If the reviews payload came back but every headline metric is empty,
-  // still say so explicitly rather than rendering a blank box.
-  if (bits.length === 0 && !s.headline) {
+  const hasHeadlineMetric =
+    !!s.letter_grade ||
+    s.value_0_100 != null ||
+    csr != null ||
+    !!s.headline;
+  if (!hasHeadlineMetric) {
     return (
       <div
         style={{
@@ -4082,51 +4087,7 @@ function CompareReviewsCell({ insurerSlug }: { insurerSlug: string }) {
       </div>
     );
   }
-  return (
-    <div style={{ fontSize: 12.5, lineHeight: 1.5, color: "var(--foreground)" }}>
-      {bits.length > 0 && (
-        <div style={{ fontWeight: 600 }}>{bits.join(" · ")}</div>
-      )}
-      {s.headline && (
-        <div
-          style={{
-            marginTop: bits.length > 0 ? 4 : 0,
-            color: "var(--muted-foreground)",
-          }}
-        >
-          {s.headline}
-        </div>
-      )}
-      {csr != null && cm.claim_settlement_ratio_year && (
-        <div
-          style={{
-            marginTop: 4,
-            fontSize: 11,
-            color: "var(--muted-foreground)",
-          }}
-        >
-          Claim settlement ratio · FY {cm.claim_settlement_ratio_year}
-          {cm.source_irdai_url ? (
-            <>
-              {" · "}
-              <a
-                href={cm.source_irdai_url}
-                target="_blank"
-                rel="noopener noreferrer"
-                style={{
-                  color: "var(--primary)",
-                  textDecoration: "underline",
-                  textUnderlineOffset: 2,
-                }}
-              >
-                IRDAI source
-              </a>
-            </>
-          ) : null}
-        </div>
-      )}
-    </div>
-  );
+  return <InsurerReviewsBlock reviews={rv} />;
 }
 
 // CitedPolicyCards — structured per-policy cards rendered BELOW the

frontend/src/components/PolicyPremiumWidget.tsx

@@ -197,6 +197,20 @@ export default function PolicyPremiumWidget({
   const [loading, setLoading] = useState<boolean>(true);
   const [error, setError] = useState<string | null>(null);
 
+  // BUG #29 — only the ~2 of 148 policies that genuinely offer a
+  // user-selectable voluntary deductible expose the selector. The backend
+  // is authoritative; default to "unsupported" until the estimate arrives.
+  // Declared here (before fetchPremium / the JSX) so both the request
+  // builder and the render read the same value without a TDZ hazard.
+  // Stale-selection reset is handled in the fetch callback (an async event
+  // handler — the React-recommended place to react to a response), not an
+  // effect, so we don't trigger cascading-render lint.
+  const supportsDeductible = resp?.supports_voluntary_deductible === true;
+  const deductibleChoices: readonly number[] =
+    resp?.allowed_deductibles && resp.allowed_deductibles.length
+      ? resp.allowed_deductibles
+      : DEDUCTIBLE_CHOICES;
+
   // Stable string key so we can put `profile` in the effect dep list without
   // triggering refetches on every parent re-render (object identity changes).
   const profileKey = useMemo(() => JSON.stringify(profile ?? {}), [profile]);
@@ -244,10 +258,16 @@ export default function PolicyPremiumWidget({
           pre_existing_conditions: normalisePed(profile?.pre_existing_conditions),
           copayment_pct: 0,
           tenure_years: tenureYears,
-          deductible_inr: deductibleInr,
+          deductible_inr: supportsDeductible ? deductibleInr : 0,
         });
         if (signal.aborted) return;
         setResp(r);
+        // BUG #29 — if this policy does NOT support a voluntary deductible
+        // but a stale non-zero selection carried over from a previously
+        // compared policy, clear it so it can't persist or be re-sent.
+        if (r.supports_voluntary_deductible === false && deductibleInr !== 0) {
+          setDeductibleInr(0);
+        }
         onCalculatedRef.current?.(r.point_estimate_inr);
       } catch (e) {
         if (signal.aborted) return;
@@ -373,28 +393,32 @@ export default function PolicyPremiumWidget({
           </div>
         </label>
 
-        <label style={labelStyle}>
-          <span style={labelHeadStyle}>
-            <span style={labelTextStyle}>Deductible</span>
-            <strong style={labelValueStyle}>
-              {formatDeductibleLabel(deductibleInr)}
-            </strong>
-          </span>
-          <div role="radiogroup" aria-label="Deductible" style={pillRowStyle}>
-            {DEDUCTIBLE_CHOICES.map((d) => (
-              <button
-                key={d}
-                type="button"
-                role="radio"
-                aria-checked={deductibleInr === d}
-                onClick={() => setDeductibleInr(d)}
-                style={pillStyle(deductibleInr === d)}
-              >
-                {formatDeductibleLabel(d)}
-              </button>
-            ))}
-          </div>
-        </label>
+        {supportsDeductible && (
+          <label style={labelStyle}>
+            <span style={labelHeadStyle}>
+              <span style={labelTextStyle}>Deductible</span>
+              <strong style={labelValueStyle}>
+                {formatDeductibleLabel(deductibleInr)}
+              </strong>
+            </span>
+            <div role="radiogroup" aria-label="Deductible" style={pillRowStyle}>
+              {deductibleChoices.map((d) => (
+                <button
+                  key={d}
+                  type="button"
+                  role="radio"
+                  aria-checked={deductibleInr === d}
+                  onClick={() =>
+                    setDeductibleInr(d as 0 | 25000 | 50000 | 100000)
+                  }
+                  style={pillStyle(deductibleInr === d)}
+                >
+                  {formatDeductibleLabel(d)}
+                </button>
+              ))}
+            </div>
+          </label>
+        )}
       </div>
 
       <div style={resultBoxStyle} aria-live="polite">

frontend/src/lib/api.ts

@@ -362,6 +362,12 @@ export type PremiumEstimateResponse = {
   // Echoed back when caller passed tenure / deductible overrides.
   tenure_years?: number | null;
   deductible_inr?: number | null;
+  // BUG #29 — whether THIS policy genuinely offers a user-selectable
+  // voluntary deductible (only ~2 of 148 do). When false the widget hides
+  // the deductible selector entirely; allowed_deductibles is the exact set
+  // of pills to render when true.
+  supports_voluntary_deductible?: boolean;
+  allowed_deductibles?: number[];
   // True when the backend anchored the base to a curated quote sample (i.e.
   // the policy is in illustrative_premiums.json). Drives the widget's
   // "Estimate" badge — replaces bulk_estimate's `assumed` flag.

tests/test_bug30_existing_cover_and_promise.py

@@ -0,0 +1,508 @@
+"""BUG #30 (2026-05-19) — existing-cover-aware ranking + "never promise
+without performing".
+
+Failing scenario the bug pins:
+  Profile = {existing_cover_inr=100000 (₹1L employer), primary_goal=first_buy,
+             smoker=yes, family_medical_history=["diabetes"],
+             desired_sum_insured_inr=2_000_000}
+
+Three sub-defects fixed:
+
+  B1-c  retrieval_filters._fit_score had NO existing-cover / top-up term, so
+        the ranker was existing-cover-blind: with ANY positive existing
+        cover a relevant top-up must now out-rank a SAME-GRADE non-top-up
+        (and land in the cited set), and brain_tools._quality_seed_candidates
+        must union-in top-ups when existing_cover_inr is truthy.
+
+  B2    single_brain must NEVER end a turn on a forward-looking promise
+        ("let me re-evaluate / check / search") with NO tool call:
+        `_is_promissory_no_action` detects it and the handle_turn loop
+        re-prompts EXACTLY ONCE to force the actual tool call this turn.
+
+  B3    _CONSTRAINT_FIELD_PHRASES now maps existing_cover_inr so a re-eval
+        triggered by the existing cover is explained, not silent.
+
+Run:
+    cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
+    PYTHONPATH=$PWD .venv/bin/python -m pytest -q \\
+        tests/test_bug30_existing_cover_and_promise.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.retrieval_filters import (  # noqa: E402
+    rank_by_profile_fit,
+    filter_pipeline,
+)
+from backend.single_brain import (  # noqa: E402
+    _is_promissory_no_action,
+    _constraint_reason_clause,
+    _HONEST_EMPTY_REPLY,
+)
+
+
+# ---------------------------------------------------------------------------
+# The exact BUG #30 failing-session profile.
+# ---------------------------------------------------------------------------
+
+BUG30_PROFILE = {
+    "age": 29,
+    "location_tier": "metro",
+    "income_band": "25L+",
+    "primary_goal": "first_buy",
+    "existing_cover_inr": 100_000,        # ₹1L employer cover — SMALL but > 0
+    "health_conditions": ["none"],
+    "desired_sum_insured_inr": 2_000_000,  # ₹20 lakh
+    "copay_pct": 0,
+    "smoker": True,
+    "family_medical_history": ["diabetes"],
+    "dependents": "self",
+}
+
+
+def _chunk(
+    policy_id: str,
+    policy_name: str,
+    *,
+    score: float = 0.5,
+    policy_type: str | None = None,
+    deductible_amount: int | None = None,
+    copay_pct: int | None = None,
+    sum_insured_options: list[int] | None = None,
+    grade: str | None = None,
+    overall_score: int | None = None,
+    doc_type: str = "policy",
+) -> dict:
+    """Chunk shaped like brain_tools.retrieve_policies output AFTER the
+    policy_facts enrichment step (mirrors tests/test_eligibility_ranking)."""
+    return {
+        "policy_id": policy_id,
+        "policy_name": policy_name,
+        "insurer_slug": policy_id.split("__")[0],
+        "doc_type": doc_type,
+        "score": score,
+        "chunk_text": "",
+        "policy_type_indemnity_or_fixed": policy_type,
+        "deductible_amount": deductible_amount,
+        "co_payment_pct": copay_pct,
+        "sum_insured_options": sum_insured_options,
+        "_grade": grade,
+        "_overall_score": overall_score,
+    }
+
+
+# A SAME-GRADE pair: identical cosine, grade, overall, SI, copay. The ONLY
+# differentiator is that one is a super-top-up. Pre-fix _fit_score scored
+# them equally (stable sort kept incoming order → top-up second). Post-fix
+# the +22 existing-cover term must lift the top-up above the non-top-up.
+SAME_GRADE_TOPUP = _chunk(
+    "royal-sundaram__advanced-top-up",
+    "Advanced Top Up Health Insurance Plan",
+    score=0.60,
+    policy_type="super_top_up",
+    deductible_amount=300_000,
+    copay_pct=0,
+    sum_insured_options=[1_000_000, 2_000_000, 5_000_000],
+    grade="A",
+    overall_score=85,
+)
+SAME_GRADE_PRIMARY = _chunk(
+    "niva-bupa__reassure-2",
+    "ReAssure 2.0",
+    score=0.60,
+    policy_type="indemnity",
+    deductible_amount=None,
+    copay_pct=0,
+    sum_insured_options=[1_000_000, 2_000_000, 5_000_000],
+    grade="A",
+    overall_score=85,
+)
+
+
+# ---------------------------------------------------------------------------
+# B1-c — existing-cover-aware ranking
+# ---------------------------------------------------------------------------
+
+class TestExistingCoverRanking(unittest.TestCase):
+    def test_topup_outranks_same_grade_non_topup_with_existing_cover(self):
+        """With existing_cover_inr=100000 a SAME-GRADE top-up must rank
+        ABOVE the same-grade non-top-up (the +22 term breaks the tie that,
+        pre-fix, left the top-up buried)."""
+        ranked = rank_by_profile_fit(
+            # incoming order puts the PRIMARY first so a stable sort would,
+            # absent the new term, KEEP the top-up second.
+            [SAME_GRADE_PRIMARY, SAME_GRADE_TOPUP], BUG30_PROFILE
+        )
+        order = [c["policy_id"] for c in ranked]
+        self.assertLess(
+            order.index("royal-sundaram__advanced-top-up"),
+            order.index("niva-bupa__reassure-2"),
+            "A relevant super-top-up must out-rank a same-grade non-top-up "
+            "when the user already holds ₹1L existing base cover.",
+        )
+
+    def test_topup_lands_in_cited_set_through_pipeline(self):
+        """End-to-end: through filter_pipeline the top-up survives
+        eligibility (user HAS base cover) AND lands in the cited set."""
+        filtered, _guard = filter_pipeline(
+            [SAME_GRADE_PRIMARY, SAME_GRADE_TOPUP],
+            profile=BUG30_PROFILE,
+            query=("comprehensive base health plan metro 20 lakh super "
+                   "top-up plan layered over existing 1 lakh employer base "
+                   "cover diabetes smoker"),
+            intent="recommendation",
+        )
+        ids = [c["policy_id"] for c in filtered]
+        self.assertIn(
+            "royal-sundaram__advanced-top-up", ids,
+            "the relevant super-top-up must reach the brain (cited set) for "
+            "a user who already holds base cover.",
+        )
+        self.assertIn("niva-bupa__reassure-2", ids,
+                      "the strong primary plan must also survive.")
+        self.assertLess(
+            ids.index("royal-sundaram__advanced-top-up"),
+            ids.index("niva-bupa__reassure-2"),
+            "post-fix the top-up ranks ahead of the same-grade primary.",
+        )
+
+    def test_term_inert_without_existing_cover(self):
+        """Regression: with NO existing cover the term must be inert — a
+        first-time buyer's ranking is unchanged (stable order preserved)."""
+        no_cover = dict(BUG30_PROFILE, existing_cover_inr=0)
+        ranked = rank_by_profile_fit(
+            [SAME_GRADE_PRIMARY, SAME_GRADE_TOPUP], no_cover
+        )
+        order = [c["policy_id"] for c in ranked]
+        # Equal score → stable sort keeps the incoming order (primary first).
+        self.assertEqual(
+            order[0], "niva-bupa__reassure-2",
+            "with no existing cover the +22 term must NOT fire — ordering "
+            "is unchanged from the profile-neutral baseline.",
+        )
+
+
+class TestQualitySeedUnionsTopUps(unittest.TestCase):
+    """B1-c — _quality_seed_candidates must union-in top-up policies when
+    existing_cover_inr is truthy, even if they fall OUTSIDE the
+    profile-neutral top-25 window."""
+
+    class _Prof:
+        def __init__(self, **kw):
+            for k, v in kw.items():
+                setattr(self, k, v)
+
+    def _patch_curated(self, monkeyish):
+        # Build a synthetic catalogue: 26 high-overall NON-top-up policies
+        # (fill the top-25 window) + ONE top-up with a LOWER overall so it
+        # falls OUTSIDE the window. The fix must still seed it.
+        curated = {}
+        for i in range(26):
+            pid = f"insurerx__primary-{i:02d}"
+            curated[pid] = {
+                "policy_id": pid,
+                "policy_name": f"Primary Plan {i}",
+                "insurer_slug": "insurerx",
+            }
+        curated["royal-sundaram__advanced-top-up"] = {
+            "policy_id": "royal-sundaram__advanced-top-up",
+            "policy_name": "Advanced Top Up Health Insurance Plan",
+            "insurer_slug": "royal-sundaram",
+        }
+
+        def _fake_curated_all():
+            return curated
+
+        def _fake_scorecard_signal(pid, profile=None):
+            if pid == "royal-sundaram__advanced-top-up":
+                return {"_overall_score": 50, "_grade": "C"}  # OUTSIDE top-25
+            n = int(pid.split("-")[-1])
+            return {"_overall_score": 95 - n, "_grade": "A"}  # all > 50
+
+        def _fake_load_facts(pid):
+            if pid == "royal-sundaram__advanced-top-up":
+                return {
+                    "policy_type_indemnity_or_fixed": "super_top_up",
+                    "deductible_amount": 300_000,
+                }
+            return {"policy_type_indemnity_or_fixed": "indemnity"}
+
+        return (_fake_curated_all, _fake_scorecard_signal, _fake_load_facts)
+
+    def test_topup_seeded_when_existing_cover_truthy(self):
+        ca, sig, lf = self._patch_curated(None)
+        with mock.patch.object(brain_tools, "_curated_facts_all", ca), \
+             mock.patch.object(brain_tools, "_scorecard_signal", sig), \
+             mock.patch.object(brain_tools, "_load_policy_facts", lf), \
+             mock.patch.object(brain_tools, "_has_extraction",
+                               lambda pid: True):
+            brain_tools._qseed_cache.clear()
+            prof = self._Prof(existing_cover_inr=100_000, age=29)
+            seeded = brain_tools._quality_seed_candidates(prof, limit=25)
+        ids = {c["policy_id"] for c in seeded}
+        self.assertIn(
+            "royal-sundaram__advanced-top-up", ids,
+            "a relevant super-top-up OUTSIDE the profile-neutral top-25 "
+            "must still be union-seeded when existing_cover_inr is truthy.",
+        )
+
+    def test_topup_not_seeded_without_existing_cover(self):
+        ca, sig, lf = self._patch_curated(None)
+        with mock.patch.object(brain_tools, "_curated_facts_all", ca), \
+             mock.patch.object(brain_tools, "_scorecard_signal", sig), \
+             mock.patch.object(brain_tools, "_load_policy_facts", lf), \
+             mock.patch.object(brain_tools, "_has_extraction",
+                               lambda pid: True):
+            brain_tools._qseed_cache.clear()
+            prof = self._Prof(existing_cover_inr=0, age=29)
+            seeded = brain_tools._quality_seed_candidates(prof, limit=25)
+        ids = {c["policy_id"] for c in seeded}
+        self.assertNotIn(
+            "royal-sundaram__advanced-top-up", ids,
+            "with no existing cover the out-of-window top-up must NOT be "
+            "force-seeded (term inert for first-time buyers).",
+        )
+
+
+# ---------------------------------------------------------------------------
+# B2 — promissory-no-action detector
+# ---------------------------------------------------------------------------
+
+class TestIsPromissoryNoAction(unittest.TestCase):
+    def test_detects_all_canonical_promise_phrases(self):
+        for phrase in (
+            "Let me re-evaluate the options for you.",
+            "Sure, let me check that.",
+            "Let me look into the best plans.",
+            "I'll look into it and get back.",
+            "I will re-evaluate given your existing cover.",
+            "Let me search for better-fit plans.",
+            "Let me find a top-up that suits you.",
+            "Give me a moment to reconsider.",
+            "I'll check the shortlist again.",
+            "Let me see if there's a better option.",
+        ):
+            self.assertTrue(
+                _is_promissory_no_action(phrase),
+                f"must flag promissory phrase: {phrase!r}",
+            )
+
+    def test_case_insensitive(self):
+        self.assertTrue(_is_promissory_no_action("LET ME RE-EVALUATE NOW"))
+
+    def test_non_promissory_text_is_not_flagged(self):
+        for ok in (
+            "Here are two strong plans for your profile: ...",
+            "Your ₹1L employer cover supplements this primary plan.",
+            "Could you confirm your preferred sum insured?",
+            "",
+            "   ",
+        ):
+            self.assertFalse(
+                _is_promissory_no_action(ok),
+                f"must NOT flag non-promissory text: {ok!r}",
+            )
+
+
+# ---------------------------------------------------------------------------
+# B3 — existing-cover constraint phrase
+# ---------------------------------------------------------------------------
+
+class TestExistingCoverConstraintPhrase(unittest.TestCase):
+    def test_existing_cover_inr_maps_to_its_phrase(self):
+        clause = _constraint_reason_clause({"existing_cover_inr": "100000"})
+        self.assertIn("existing cover you already hold", clause)
+
+
+# ---------------------------------------------------------------------------
+# B2 — handle_turn loop guard: a promissory no-tool reply forces EXACTLY
+#      ONE re-prompt iteration (no infinite loop).
+# ---------------------------------------------------------------------------
+
+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="A", overall=85):
+    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 TestPromissoryLoopGuard(unittest.TestCase):
+    """A no-tool promissory turn must trigger EXACTLY ONE re-prompt that
+    forces the actual tool call this turn (mirrors
+    tests/test_last_text_preserved_across_tool_iters harness)."""
+
+    def setUp(self):
+        self._env = mock.patch.dict(os.environ,
+                                    {"GOOGLE_API_KEY": "test-key"})
+        self._env.start()
+        self._gemini_script: list = []
+        self._calls: list = []
+        self._retrieve_chunks: list = []
+
+        async def _fake_gemini(*_a, **_k):
+            self._calls.append(_k.get("contents"))
+            if not self._gemini_script:
+                return _text_payload("(no more scripted turns)")
+            return self._gemini_script.pop(0)
+
+        async def _fake_retrieve(*_a, **_k):
+            chunks = list(self._retrieve_chunks)
+            sess = _k.get("session")
+            if sess is not None:
+                sess.last_retrieved_chunks = list(chunks)
+                sess.slug_to_insurer = {
+                    c["policy_id"]: c["insurer_slug"] for c in chunks
+                }
+            return {"chunks": chunks, "count": len(chunks)}
+
+        self._gp = mock.patch.object(single_brain, "_gemini_call",
+                                     _fake_gemini)
+        self._rp = mock.patch.object(brain_tools, "retrieve_policies",
+                                     _fake_retrieve)
+        self._gp.start()
+        self._rp.start()
+
+    def tearDown(self):
+        self._rp.stop()
+        self._gp.stop()
+        self._env.stop()
+
+    def _ready_session(self):
+        from backend.session_state import SessionState
+        sess = SessionState(session_id=f"t_{uuid.uuid4().hex[:8]}")
+        sess.profile.name = "Asha"
+        sess.profile.age = 29
+        sess.profile.dependents = "self"
+        sess.profile.location_tier = "metro"
+        sess.profile.income_band = "25L+"
+        sess.profile.primary_goal = "first_buy"
+        sess.profile.health_conditions = ["none"]
+        sess.profile.existing_cover_inr = 100_000
+        sess.pricing_bundle_skipped = True
+        return sess
+
+    def test_promissory_no_tool_turn_forces_exactly_one_reprompt(self):
+        sess = self._ready_session()
+        self._retrieve_chunks = [
+            _enriched("hdfc-ergo__optima-secure", "Optima Secure",
+                      "hdfc-ergo", 0.81, "c1"),
+            _enriched("royal-sundaram__advanced-top-up",
+                      "Advanced Top Up", "royal-sundaram", 0.70, "c2"),
+        ]
+        self._gemini_script = [
+            # iter 1 — PROMISSORY, NO tool call. Must trigger 1 re-prompt.
+            _text_payload(
+                "Let me re-evaluate given your ₹1L employer cover."),
+            # iter 2 — model now actually calls the tools.
+            _tool_payload([_fc_part("retrieve_policies", {
+                "query": ("comprehensive base plan super top-up plan "
+                          "layered over existing 1 lakh employer base "
+                          "cover")})]),
+            _tool_payload([_fc_part("mark_recommendation", {
+                "policy_ids": ["hdfc-ergo__optima-secure",
+                               "royal-sundaram__advanced-top-up"]})]),
+            # iter 3 — final prose with the revised shortlist.
+            _text_payload(
+                "Here is the revised shortlist: 1. Optima Secure works as "
+                "your PRIMARY plan; your ₹1L employer cover supplements it. "
+                "2. Advanced Top Up sits ABOVE your ₹1L existing cover."),
+        ]
+
+        r = _run(single_brain.handle_turn(
+            sess, "But I already have ₹1L cover from my employer — "
+                  "reconsider please"))
+
+        # The re-prompt fires (a synthetic user turn injected) and the
+        # final reply is the REAL revised shortlist, never the promise.
+        self.assertIn("revised shortlist", r.reply_text)
+        self.assertNotIn("Let me re-evaluate", r.reply_text,
+                          "the turn must NOT end on the promise")
+        self.assertNotEqual(r.reply_text, _HONEST_EMPTY_REPLY)
+        # _classify_intent → "recommendation" only when BOTH
+        # retrieve_policies AND mark_recommendation actually fired; proves
+        # the re-prompt forced the real tool calls.
+        self.assertEqual(
+            r.intent, "recommendation",
+            "the re-prompt must have forced the actual retrieve_policies + "
+            "mark_recommendation tool calls",
+        )
+        self.assertIn("retrieve_policies", r.brain_used)
+
+        # Exactly ONE re-prompt: find the injected guard user-turn in the
+        # contents passed to the final Gemini call.
+        final_contents = self._calls[-1]
+        guard_turns = [
+            c for c in final_contents
+            if c.get("role") == "user"
+            and any("called no tool" in p.get("text", "")
+                    for p in c.get("parts", []))
+        ]
+        self.assertEqual(
+            len(guard_turns), 1,
+            "the B2 loop guard must fire EXACTLY ONCE per turn "
+            "(no infinite loop / no double re-prompt).",
+        )
+
+    def test_no_reprompt_when_turn_has_a_tool_call(self):
+        """A turn that DOES call a tool must not trigger the B2 guard even
+        if its (later) prose happens to contain a promise-like phrase."""
+        sess = self._ready_session()
+        self._retrieve_chunks = [
+            _enriched("hdfc-ergo__optima-secure", "Optima Secure",
+                      "hdfc-ergo", 0.81, "c1"),
+        ]
+        self._gemini_script = [
+            _tool_payload([_fc_part("retrieve_policies",
+                                    {"query": "metro comprehensive"})]),
+            _tool_payload([_fc_part("mark_recommendation", {
+                "policy_ids": ["hdfc-ergo__optima-secure"]})]),
+            _text_payload(
+                "Here is Optima Secure — a strong primary plan; your "
+                "₹1L employer cover supplements it."),
+        ]
+        r = _run(single_brain.handle_turn(sess, "show options"))
+        self.assertIn("Optima Secure", r.reply_text)
+        final_contents = self._calls[-1]
+        guard_turns = [
+            c for c in final_contents
+            if c.get("role") == "user"
+            and any("called no tool" in p.get("text", "")
+                    for p in c.get("parts", []))
+        ]
+        self.assertEqual(len(guard_turns), 0,
+                         "no B2 guard when the turn already called a tool")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

tests/test_deductible_eligibility.py

@@ -0,0 +1,234 @@
+"""BUG #29 — voluntary-deductible eligibility.
+
+PROBLEM (pre-fix): the deductible selector (₹0/25K/50K/1L) and its premium
+discount were applied to EVERY policy, even though only 2 of the 148
+catalogued policies genuinely offer a user-selectable voluntary deductible.
+A top-up's "deductible" is a structural threshold, not a knob the buyer can
+trade for a lower premium — discounting on it fabricates savings.
+
+Authoritative rule (premium_calculator.policy_deductible_support):
+
+    supports_voluntary_deductible
+        = (curated deductible_amount > 0) AND (NOT a top-up / super-top-up)
+
+Across the full 148-policy catalogue this resolves to EXACTLY:
+
+    {bajaj-allianz__health-guard, star-health__star-assure}
+
+These tests:
+  1. Sweep the entire catalogue and pin the invariants (top-ups never
+     supported, deductible_amount<=0 never supported) plus the exact
+     supported set as a regression pin.
+  2. Exercise the end-to-end /api/premium/estimate path proving an
+     unsupported policy gets NO discount + an honest 0 echo, while a
+     supported policy gets the real ×0.85 discount + a 50000 echo.
+  3. Prove bulk_estimate() forces the discount to 1.0 and echoes
+     deductible_inr=0 for an unsupported policy.
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+
+from backend import main
+from backend.brain_tools import _load_policy_facts
+from backend.main import _marketplace_catalogue
+from backend.premium_calculator import (
+    BULK_DEDUCTIBLE_DISCOUNT,
+    _policy_product_type,
+    bulk_estimate,
+    policy_deductible_support,
+)
+
+client = TestClient(main.app, raise_server_exceptions=False)
+
+# The full catalogued set — single source of truth for the marketplace cards.
+_ALL_CARDS = _marketplace_catalogue(None)
+_ALL_PIDS = [c.policy_id for c in _ALL_CARDS if c.policy_id]
+
+# Regression pin — the EXACT set the rule must select across all 148.
+EXPECTED_SUPPORTED = {
+    "bajaj-allianz__health-guard",
+    "star-health__star-assure",
+}
+
+
+def _curated_deductible(pid: str) -> float:
+    f = _load_policy_facts(pid) or {}
+    ded = f.get("deductible_amount")
+    try:
+        return float(ded) if ded not in (None, "", []) else 0.0
+    except (TypeError, ValueError):
+        return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Catalogue-wide invariants
+# ---------------------------------------------------------------------------
+
+def test_catalogue_has_expected_size():
+    """Guards the regression pin: if the catalogue size drifts, the
+    EXPECTED_SUPPORTED set must be re-derived deliberately."""
+    assert len(_ALL_PIDS) == 148
+
+
+@pytest.mark.parametrize("pid", _ALL_PIDS)
+def test_topups_never_support_a_voluntary_deductible(pid):
+    """A top-up / super-top-up's deductible is a structural threshold, not a
+    user-selectable knob — it must NEVER be (True, ...)."""
+    if _policy_product_type(pid) == "topup":
+        assert policy_deductible_support(pid) == (False, [0]), pid
+
+
+@pytest.mark.parametrize("pid", _ALL_PIDS)
+def test_nonpositive_curated_deductible_never_supported(pid):
+    """No curated deductible_amount (or <=0) ⇒ no voluntary deductible."""
+    if _curated_deductible(pid) <= 0:
+        assert policy_deductible_support(pid) == (False, [0]), pid
+
+
+@pytest.mark.parametrize("pid", _ALL_PIDS)
+def test_support_shape_is_always_valid(pid):
+    """Whatever the answer, the shape contract holds: (bool, list[int]) with
+    0 always present and the list sorted/unique."""
+    supports, allowed = policy_deductible_support(pid)
+    assert isinstance(supports, bool)
+    assert isinstance(allowed, list) and all(isinstance(x, int) for x in allowed)
+    assert 0 in allowed
+    assert allowed == sorted(set(allowed))
+    if not supports:
+        assert allowed == [0], pid
+
+
+def test_exact_supported_set_regression_pin():
+    """The EXACT set of policies with supports==True across the full
+    catalogue is the two flagship comprehensive plans — nothing else."""
+    supported = {
+        pid for pid in _ALL_PIDS if policy_deductible_support(pid)[0]
+    }
+    assert supported == EXPECTED_SUPPORTED
+
+
+def test_supported_policies_expose_curated_amount():
+    """Each supported policy's allowed set is exactly {0, curated_amount}."""
+    for pid in EXPECTED_SUPPORTED:
+        supports, allowed = policy_deductible_support(pid)
+        assert supports is True
+        amt = int(_curated_deductible(pid))
+        assert amt > 0
+        assert allowed == sorted({0, amt}), (pid, allowed)
+
+
+def test_unknown_or_blank_policy_degrades_safely():
+    assert policy_deductible_support(None) == (False, [0])
+    assert policy_deductible_support("") == (False, [0])
+    assert policy_deductible_support("does-not-exist__nope") == (False, [0])
+
+
+# ---------------------------------------------------------------------------
+# End-to-end /api/premium/estimate — the user-visible behaviour
+# ---------------------------------------------------------------------------
+
+_BASE_REQ = {
+    "age": 35,
+    "sum_insured_inr": 1_000_000,
+    "city_tier": "metro",
+    "smoker": False,
+    "family_size": 1,
+    "pre_existing_conditions": "none",
+    "copayment_pct": 0,
+}
+
+
+def _estimate(policy_id, deductible_inr=None):
+    body = dict(_BASE_REQ, policy_id=policy_id)
+    if deductible_inr is not None:
+        body["deductible_inr"] = deductible_inr
+    r = client.post("/api/premium/estimate", json=body)
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def test_unsupported_policy_gets_no_discount_and_honest_echo():
+    """hdfc-ergo__optima-restore is a comprehensive plan with NO curated
+    voluntary deductible. Passing deductible_inr=100000 must NOT discount
+    the premium — point == the no-deductible result — and the echoed
+    deductible_inr must be 0 (honest), with supports flag False."""
+    pid = "hdfc-ergo__optima-restore"
+    assert policy_deductible_support(pid) == (False, [0])
+
+    base = _estimate(pid, deductible_inr=0)
+    with_ded = _estimate(pid, deductible_inr=100_000)
+
+    assert with_ded["point_estimate_inr"] == base["point_estimate_inr"]
+    assert with_ded["low_inr"] == base["low_inr"]
+    assert with_ded["high_inr"] == base["high_inr"]
+    assert with_ded["deductible_inr"] == 0
+    assert with_ded["supports_voluntary_deductible"] is False
+    assert with_ded["allowed_deductibles"] == [0]
+
+
+def test_supported_policy_gets_real_discount_and_echo():
+    """bajaj-allianz__health-guard genuinely supports a voluntary
+    deductible. A ₹50,000 deductible must apply the real ×0.85 discount
+    and echo deductible_inr=50000 with supports flag True."""
+    pid = "bajaj-allianz__health-guard"
+    supports, allowed = policy_deductible_support(pid)
+    assert supports is True
+    assert 50_000 in allowed
+
+    base = _estimate(pid, deductible_inr=0)
+    discounted = _estimate(pid, deductible_inr=50_000)
+
+    expected = int(round(base["point_estimate_inr"] * BULK_DEDUCTIBLE_DISCOUNT[50_000]))
+    assert discounted["point_estimate_inr"] == expected
+    assert discounted["point_estimate_inr"] < base["point_estimate_inr"]
+    assert discounted["deductible_inr"] == 50_000
+    assert discounted["supports_voluntary_deductible"] is True
+    assert 50_000 in discounted["allowed_deductibles"]
+
+
+def test_estimate_response_always_exposes_support_fields():
+    """Even with no deductible in the request the response must carry the
+    BUG #29 fields so the widget can decide whether to render the selector."""
+    resp = _estimate("hdfc-ergo__optima-restore")
+    assert resp["supports_voluntary_deductible"] is False
+    assert resp["allowed_deductibles"] == [0]
+
+
+# ---------------------------------------------------------------------------
+# bulk_estimate() — slider-driven multi-policy path
+# ---------------------------------------------------------------------------
+
+def test_bulk_estimate_forces_no_discount_for_unsupported():
+    """bulk_estimate() must neutralise the deductible discount (×1.0) and
+    echo deductible_inr=0 for a policy that does not support it."""
+    pid = "hdfc-ergo__optima-restore"
+    assert policy_deductible_support(pid) == (False, [0])
+
+    out = bulk_estimate(
+        profile={"age": 35, "location_tier": "metro"},
+        policy_ids=[pid],
+        overrides={pid: {"deductible_inr": 100_000}},
+    )
+    row = out[pid]
+    assert row.deductible_inr == 0
+    assert row.breakdown.get("deductible_discount_x", 1.0) == 1.0
+
+
+def test_bulk_estimate_applies_discount_for_supported():
+    """A supported policy with a valid deductible still gets the real
+    discount + an honest non-zero echo in bulk_estimate()."""
+    pid = "bajaj-allianz__health-guard"
+    supports, allowed = policy_deductible_support(pid)
+    assert supports is True and 50_000 in allowed
+
+    out = bulk_estimate(
+        profile={"age": 35, "location_tier": "metro"},
+        policy_ids=[pid],
+        overrides={pid: {"deductible_inr": 50_000}},
+    )
+    row = out[pid]
+    assert row.deductible_inr == 50_000
+    assert row.breakdown.get("deductible_discount_x") == pytest.approx(
+        BULK_DEDUCTIBLE_DISCOUNT[50_000]
+    )