fix(reco): cap 3, exclude non-extracted policies, unify premium, ask PED

Five live recommendation-card defects, fixed at source:

- #28 hard ≤3 cap in _build_recommendation_citations + prompt 2-3 + compare modal ≤3 (>3 collapsed the layout to 1 char/line)
- #29 _has_extraction renderability gate: non-extracted policies excluded from _quality_seed_candidates AND the citation gate (was rendering raw slug / N/A / 'No extraction available' / 'Data not indexed')
- #30 'Your share & the limits' always renders both rows with 'Not specified' fallback (was omitting nulls -> different field per card)
- #31 removed Path C NonCuratedPricingNotice (dead component+styles deleted); estimate_premium_band now p25-p75 interquartile not raw min-max (was identical 30x-wide band on every non-curated card)
- #32 SYSTEM_PROMPT now mandates the explicit pre-existing-conditions question before retrieve_policies

Tests: rewrote no-cap + band-superset guards to the new contracts, added tests/test_extraction_gate.py + tests/conftest.py renderable-stub; full pytest gate green; frontend tsc + next build clean.

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

backend/brain_tools.py

@@ -150,6 +150,35 @@ def _candidate_stems(policy_id: str) -> list[str]:
     return stems
 
 
+_extraction_cache: dict = {}
+
+
+def _has_extraction(policy_id: str) -> bool:
+    """True iff this policy has an LLM-extracted corpus file — the EXACT
+    renderability rule the marketplace uses (main builds its card set from
+    settings.EXTRACTED_DIR/*.json). A policy with curated facts but no
+    extracted file renders as a BROKEN card: raw policy_id as the title,
+    grade "N/A", "No extraction available for this policy.", "Data not
+    indexed" (/api/bulk-scorecard). Such a policy must NEVER be quality-
+    seeded or cited. Canonical-stem aware (doctype siblings count); cached
+    incl. negatives."""
+    pid = (policy_id or "").strip()
+    if not pid:
+        return False
+    if pid in _extraction_cache:
+        return _extraction_cache[pid]
+    ok = False
+    try:
+        for stem in _candidate_stems(pid):
+            if (settings.EXTRACTED_DIR / f"{stem}.json").exists():
+                ok = True
+                break
+    except Exception:  # noqa: BLE001 — predicate must never break retrieval
+        ok = False
+    _extraction_cache[pid] = ok
+    return ok
+
+
 def _load_policy_facts(policy_id: str) -> dict:
     """Return {fact_key: value} for a policy_id, or {} when no facts file
     exists / is unreadable. Cached per policy_id (incl. negative cache)."""
@@ -646,6 +675,11 @@ def _quality_seed_candidates(profile, limit: int = 25) -> list[dict]:
             if not pid or pid in seen:
                 continue
             seen.add(pid)
+            if not _has_extraction(pid):
+                # Curated-graded but no extracted corpus → its card would
+                # render as N/A / "No extraction available for this policy"
+                # / "Data not indexed". Never seed a non-renderable policy.
+                continue
             sig = _scorecard_signal(pid, profile=profile)
             ov = sig.get("_overall_score")
             if ov is None:

backend/premium_calculator.py

@@ -953,6 +953,25 @@ def _median(xs: list[int]) -> int:
     return int((s[mid - 1] + s[mid]) / 2)
 
 
+def _percentile(xs: list[int], q: float) -> int:
+    """Linear-interpolated q-th percentile (q in 0..100). Used for the
+    predicted-premium BAND edges. The basket mixes cheap fixed-benefit
+    plans with premium indemnity plans, so absolute min/max sit ~4-5x
+    apart — a band that wide renders as a useless, broken-looking range
+    ("₹44,000-₹1,96,000"). The interquartile p25-p75 is the honest
+    "what similar profiles typically pay" range."""
+    if not xs:
+        return 0
+    s = sorted(xs)
+    if len(s) == 1:
+        return int(s[0])
+    pos = (q / 100.0) * (len(s) - 1)
+    lo = int(pos)
+    hi = min(lo + 1, len(s) - 1)
+    frac = pos - lo
+    return int(round(s[lo] + (s[hi] - s[lo]) * frac))
+
+
 def estimate_premium_band(
     profile: Optional[dict] = None,
     candidate_policy_ids: Optional[list[str]] = None,
@@ -970,13 +989,17 @@ def estimate_premium_band(
     `getPredictedPremiumBand()` / the `premiumBand` state in page.tsx.
 
     Contract guarantees (KI-278, 2026-05-16):
-      • The chip band = the SAME 26-policy basket priced at the SAME
-        profile-resolved SI the per-settings panel uses. The panel's point
-        estimate for the user's stated SI therefore lands INSIDE
-        [min_inr, max_inr] by construction (it's literally one member of
-        the basket the band aggregates), so the two surfaces can never
-        contradict the way they did pre-fix (header ₹6.5k–₹26.5k vs panel
-        ₹19.1k for one profile).
+      • The chip band = the p25-p75 INTERQUARTILE of the 26-policy basket
+        priced at the profile-resolved SI — the "what similar profiles
+        typically pay" range, NOT the raw min-max envelope (the basket
+        mixes fixed-benefit and premium indemnity plans whose absolute
+        spread is ~4-5x and renders as a useless, broken-looking band).
+        The per-settings panel shows ONE specific plan's point estimate,
+        which may sit inside or just outside this typical band — that is
+        expected and correct (a specific plan can be cheaper or pricier
+        than the typical cohort); the surfaces no longer contradict
+        because the band is explicitly a "typical range", not an
+        absolute envelope.
       • SI precedence is resolved by `resolve_profile_sum_insured(profile)`
         — byte-identical to PremiumCalculatorPanel's slider seed
         (`desired_sum_insured_inr ?? existing_cover_inr ?? default`). The
@@ -1035,14 +1058,15 @@ def estimate_premium_band(
         }
 
     return {
-        # Directional rounding (KI-278) — floor the min / ceil the max so the
-        # displayed band is a strict superset of every basket member. This is
-        # what guarantees the per-settings panel's point estimate (one basket
-        # member at the same profile-resolved SI) always reads as INSIDE the
-        # header band the user sees.
-        "min_inr": _floor_to_500(min(premiums)),
+        # INTERQUARTILE band (p25-p75), NOT raw min-max. The basket mixes
+        # cheap fixed-benefit and premium indemnity plans whose absolute
+        # min/max sit ~4-5x apart — a band that wide ("₹44,000-₹1,96,000")
+        # is useless and reads as broken. p25-p75 is the honest "what
+        # similar profiles typically pay" range; median is the typical
+        # anchor. Edges still directionally rounded for clean display.
+        "min_inr": _floor_to_500(_percentile(premiums, 25)),
         "median_inr": _round_to_500(_median(premiums)),
-        "max_inr": _ceil_to_500(max(premiums)),
+        "max_inr": _ceil_to_500(_percentile(premiums, 75)),
         "sample_size": len(premiums),
         "assumed": bool(any_assumed),
         "sum_insured_used": resolved_si,

backend/single_brain.py

@@ -77,11 +77,21 @@ SYSTEM_PROMPT = """You are an Indian health-insurance advisor speaking with a cu
 
 YOUR JOB:
 1. Have a natural conversation to learn the customer's profile.
-2. Once you have ALL required slots, summarise + confirm, then call retrieve_policies, then recommend 2-4 options with policy citations.
+2. Once you have ALL required slots, summarise + confirm, then call retrieve_policies, then recommend EXACTLY 2-3 options (NEVER more than 3 — the recommendation cards do not render past 3) with policy citations.
 3. Help the customer choose one. Cite the UIN / policy_id for every claim about features, sums insured, or premiums.
 
 REQUIRED slots before recommending: name, age, dependents, location_tier, income_band, primary_goal, health_conditions.
 
+PRE-EXISTING CONDITIONS ARE MANDATORY — you MUST explicitly ASK the
+customer this question (do not skip it, do not infer it): "Do you have
+any pre-existing conditions — diabetes, BP / hypertension, thyroid,
+heart, asthma, or a cancer history — or none?" Then call
+save_profile_field(field="health_conditions", value=...) with their
+answer (use value="none" when they have none). NEVER call
+retrieve_policies or recommend any policy until health_conditions has
+been captured this way — it materially changes eligibility, pricing
+and the recommendation.
+
 ═══════════════════════════════════
 ABSOLUTE RULE — NO POLICY NAMES WITHOUT RETRIEVE
 ═══════════════════════════════════
@@ -991,6 +1001,11 @@ def _norm_policy_name(s: str) -> str:
 # shortlist with a weak plan. We do NOT loosen the scorecard or fabricate;
 # we only stop presenting weak-fit plans AS recommendations.
 _MIN_RECOMMENDATION_OVERALL: float = 70.0
+# Hard ceiling on cited recommendations. The CitedPolicyCards layout
+# collapses (names wrap to one character per line) past 3 cards, so the
+# recommended set is capped at 3 regardless of how many clear the fitness
+# floor — best-first, so the 3 strongest are the ones kept.
+_MAX_RECOMMENDATIONS: int = 3
 _STRONG_RECOMMENDATION_GRADES: frozenset[str] = frozenset({"A", "B"})
 
 
@@ -1166,6 +1181,14 @@ def _build_recommendation_citations(
             c = best_by_canon.get(k)
             if c is None:
                 continue
+            if not brain_tools._has_extraction(c.get("policy_id") or ""):
+                # No extracted corpus → the card renders as N/A /
+                # "No extraction available for this policy" / "Data not
+                # indexed". Drop it from the recommended set even if the
+                # LLM named it; only renderable, data-backed policies are
+                # ever cited.
+                dropped.append(f"{c.get('policy_name') or k}(no-extraction)")
+                continue
             strong, overall, _grade = _recommendation_fit(c)
             if not strong:
                 dropped.append(
@@ -1196,6 +1219,8 @@ def _build_recommendation_citations(
             cite = _cite_canon(k)
             if cite is not None:
                 out.append(cite)
+            if len(out) >= _MAX_RECOMMENDATIONS:
+                break  # hard ≤3 cap — keep the 3 strongest (best-first)
         return out
 
     # ---- Path 1: explicit mark_recommendation selection -------------------

frontend/src/app/page.tsx

@@ -4041,13 +4041,11 @@ function CitedPolicyCards({
           onClose={() => setCompareOpen(false)}
           profile={profile}
           policyDataFor={(id) => policyById[id]}
-          aggregateBand={premiumBand}
           renderPremiumFor={(policyId, policyName) => (
             <PolicyPremiumWidget
               policyId={policyId}
               policyName={policyName}
               profile={premiumProfile}
-              aggregateBand={premiumBand}
             />
           )}
           renderScorecardFor={(policyId, policyName) => (

frontend/src/components/PolicyCompareModal.tsx

@@ -244,21 +244,6 @@ export type PolicyCompareModalProps = {
   policyDataFor?: (policyId: string) => MarketplacePolicy | undefined;
   // Hook for "Open in full marketplace" — defaults to no-op + closes modal.
   onOpenMarketplace?: () => void;
-  // User's profile-level predicted premium band (same number rendered in
-  // the chat header chip). Threaded down to PolicyPremiumWidget so that
-  // non-curated policies (base_sample_used: false) can surface the band
-  // as their indicative reference instead of a heuristic slider estimate.
-  // Optional: when omitted, non-curated widgets fall back to a "band not
-  // available" hint. The parent (page.tsx) typically closes over the same
-  // value inside renderPremiumFor too — this prop is the declarative
-  // contract for future callers.
-  aggregateBand?: {
-    min_inr: number;
-    max_inr: number;
-    median_inr: number;
-    sample_size?: number;
-    assumed?: boolean;
-  } | null;
 };
 
 export default function PolicyCompareModal({
@@ -269,10 +254,8 @@ export default function PolicyCompareModal({
   profile: _profile,
   policyDataFor,
   onOpenMarketplace,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  aggregateBand: _aggregateBand,
 }: PolicyCompareModalProps) {
-  const uniq = uniquePolicies(policies).slice(0, 4);
+  const uniq = uniquePolicies(policies).slice(0, 3);
   const n = uniq.length;
 
   // Close on Escape — keyboard parity with the click-outside backdrop.
@@ -1016,17 +999,26 @@ export function buildSnapshot(
   // FORCES a share on every claim. The exact % the user opts into is set
   // later on the pricing slider; what matters here is mandatory-or-not (a
   // hard minimum is a real consideration). So: binary first, figure second.
+  // #30 — both rows render on EVERY card with an explicit "Not specified"
+  // fallback (never omitted), so this section is consistent across
+  // policies instead of showing whichever single field happened to be
+  // non-null (which read as random to the user).
   push(
     limits,
     "Mandatory co-pay",
     cCopay == null
-      ? null
+      ? "Not specified"
       : cCopay === 0
         ? "None — no forced co-pay"
         : `Yes · ${cCopay}% minimum on every claim`,
     "copay",
   );
-  push(limits, "Hospital room category", roomRent ? roomRent : null, "room");
+  push(
+    limits,
+    "Hospital room category",
+    roomRent ? roomRent : "Not specified",
+    "room",
+  );
 
   // CONDITIONAL — profile-aware, never headline
   const ctx = `${(profile?.dependents || "").toLowerCase()} ${(

frontend/src/components/PolicyPremiumWidget.tsx

@@ -64,18 +64,6 @@ export type PolicyPremiumWidgetProps = {
   initialTenureYears?: 1 | 2 | 3;
   initialDeductibleInr?: 0 | 25000 | 50000 | 100000;
   onCalculated?: (premium: number) => void;
-  // User's profile-level predicted premium band (the same number rendered in
-  // the header chip / `getPredictedPremiumBand`). Surfaced as the indicative
-  // reference when the backend reports `base_sample_used: false` (i.e. no
-  // curated quote sample for this specific policy). Threaded down from
-  // PolicyCompareModal so we don't refetch per-column.
-  aggregateBand?: {
-    min_inr: number;
-    max_inr: number;
-    median_inr: number;
-    sample_size?: number;
-    assumed?: boolean;
-  } | null;
 };
 
 const SUM_INSURED_MIN = 500_000;
@@ -189,7 +177,6 @@ export default function PolicyPremiumWidget({
   initialTenureYears = 1,
   initialDeductibleInr = 0,
   onCalculated,
-  aggregateBand,
 }: PolicyPremiumWidgetProps) {
   // KI-278 — seed the SI from the profile (same precedence as the header
   // chip) unless the caller forced an explicit initialSumInsured. This is
@@ -286,20 +273,12 @@ export default function PolicyPremiumWidget({
 
   const profileSummary = summariseProfile(profile);
 
-  // Option B+: when the backend has no curated quote sample for this policy,
-  // hide the slider widget entirely and surface the user's aggregate band
-  // (same number rendered in the header chip) as the indicative reference.
-  // We wait for the first response before deciding so we don't flash the
-  // notice while loading. Loading + error states fall through to the slider
-  // widget below (which renders its own loading/error UI).
-  if (resp && resp.base_sample_used === false) {
-    return (
-      <NonCuratedPricingNotice
-        policyName={policyName}
-        aggregateBand={aggregateBand ?? null}
-      />
-    );
-  }
+  // Every recommended policy renders the SAME per-policy estimate block
+  // below (point + ±15% band + methodology). When the backend has no
+  // curated quote sample, the `methodology` string itself states it is a
+  // rules-based estimate — we no longer substitute the wide profile-level
+  // basket band for some policies (that produced an identical, 4-5x-wide
+  // "no verified quote" panel on every non-curated card).
 
   // Compact, profile-only breakdown — the estimate endpoint doesn't expose
   // a multiplicative chain so we surface the active overrides + methodology
@@ -337,10 +316,9 @@ export default function PolicyPremiumWidget({
         >
           {policyName}
         </div>
-        {/* Curated-only branch: by the time we render this widget,
-            base_sample_used is guaranteed not false (the !== false branch
-            short-circuits to NonCuratedPricingNotice above). No "Estimate"
-            badge needed here — the number is anchored to a real quote sample. */}
+        {/* The methodology line under the estimate states whether the
+            number is anchored to a curated quote sample or a rules-based
+            formula — so no separate badge is needed here. */}
       </header>
 
       {profileSummary && (
@@ -460,81 +438,6 @@ export default function PolicyPremiumWidget({
   );
 }
 
-/* ------------------------------------------------------------------ */
-/* NonCuratedPricingNotice — rendered in place of the slider widget   */
-/* when /api/premium/estimate reports base_sample_used: false. Shows  */
-/* the user's aggregate predicted-premium band (threaded down from    */
-/* PolicyCompareModal) as the indicative reference + a clear pricing- */
-/* note explaining we don't have a policy-specific quote.             */
-/* ------------------------------------------------------------------ */
-
-function NonCuratedPricingNotice({
-  policyName,
-  aggregateBand,
-}: {
-  policyName: string;
-  aggregateBand: {
-    min_inr: number;
-    max_inr: number;
-    median_inr: number;
-    sample_size?: number;
-    assumed?: boolean;
-  } | null;
-}) {
-  const hasBand = !!aggregateBand;
-  return (
-    <div style={noticeWidgetStyle} role="note" aria-label="Pricing note">
-      <header style={noticeHeaderStyle}>
-        <span style={noticeIconStyle} aria-hidden="true">
-          {/* info icon — pure SVG so we don't pull a new dependency */}
-          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.4" strokeLinecap="round" strokeLinejoin="round">
-            <circle cx="12" cy="12" r="10" />
-            <line x1="12" y1="8" x2="12" y2="8" />
-            <line x1="12" y1="12" x2="12" y2="16" />
-          </svg>
-        </span>
-        <span style={noticeBadgeStyle}>Pricing note</span>
-      </header>
-
-      <p style={noticeBodyStyle}>
-        We don&apos;t have a verified quote for <strong>{policyName}</strong> yet,
-        so we can&apos;t show a plan-specific estimate. Based on your profile,
-        plans in this category typically cost:
-      </p>
-
-      <div style={noticeBandBoxStyle}>
-        {hasBand ? (
-          <>
-            <div style={noticeBandHeadlineStyle}>
-              ₹{formatInr(aggregateBand!.min_inr)}–₹{formatInr(aggregateBand!.max_inr)}
-              <span style={noticeBandSuffixStyle}>&nbsp;/ year</span>
-            </div>
-            <div style={noticeBandMedianStyle}>
-              Median ₹{formatInr(aggregateBand!.median_inr)}/year
-              {typeof aggregateBand!.sample_size === "number" &&
-                aggregateBand!.sample_size > 0 && (
-                  <> · across {aggregateBand!.sample_size} similar profiles</>
-                )}
-            </div>
-          </>
-        ) : (
-          <div style={noticeBandFallbackStyle}>
-            Profile-level band not available yet — complete your profile to see
-            an indicative range.
-          </div>
-        )}
-      </div>
-
-      <p style={noticeFootnoteStyle}>
-        This is an indicative range — the actual premium depends on the
-        insurer&apos;s underwriting + your final disclosures. To get an exact
-        quote, request one from the insurer directly or via
-        PolicyBazaar / InsuranceDekho.
-      </p>
-    </div>
-  );
-}
-
 /* ------------------------------------------------------------------ */
 /* Inline styles — kept local so the widget drops into any modal      */
 /* without a CSS-module dependency. All colors read from the landing's */
@@ -780,102 +683,6 @@ const noteStyle: React.CSSProperties = {
   paddingTop: 2,
 };
 
-/* ---------------- NonCuratedPricingNotice styles ------------------- */
-/* Same outer card framing as the slider widget (border + radius + bg) */
-/* but with a brand-teal informational accent rail so users instantly  */
-/* distinguish "indicative range" from a "calculated estimate".        */
-
-const noticeWidgetStyle: React.CSSProperties = {
-  border: "1px solid color-mix(in srgb, var(--primary) 22%, var(--border))",
-  borderLeft: "3px solid var(--primary)",
-  borderRadius: 18,
-  padding: 18,
-  background: "color-mix(in srgb, var(--primary) 4%, var(--card))",
-  display: "flex",
-  flexDirection: "column",
-  gap: 11,
-  fontFamily: SANS,
-  boxShadow:
-    "0 1px 2px color-mix(in srgb, var(--foreground) 4%, transparent), 0 16px 40px -32px color-mix(in srgb, var(--foreground) 28%, transparent)",
-};
-
-const noticeHeaderStyle: React.CSSProperties = {
-  display: "flex",
-  alignItems: "center",
-  gap: 8,
-};
-
-const noticeIconStyle: React.CSSProperties = {
-  display: "inline-flex",
-  alignItems: "center",
-  justifyContent: "center",
-  width: 22,
-  height: 22,
-  borderRadius: 999,
-  color: "var(--primary)",
-  background: "color-mix(in srgb, var(--primary) 12%, var(--card))",
-  border: "1px solid color-mix(in srgb, var(--primary) 22%, var(--border))",
-};
-
-const noticeBadgeStyle: React.CSSProperties = {
-  fontSize: 10,
-  fontWeight: 700,
-  letterSpacing: "0.12em",
-  textTransform: "uppercase",
-  color: "color-mix(in srgb, var(--primary) 78%, var(--foreground))",
-};
-
-const noticeBodyStyle: React.CSSProperties = {
-  margin: 0,
-  fontSize: 12.5,
-  lineHeight: 1.55,
-  color: "var(--foreground)",
-};
-
-const noticeBandBoxStyle: React.CSSProperties = {
-  background: "var(--card)",
-  border: "1px solid color-mix(in srgb, var(--primary) 16%, var(--border))",
-  borderRadius: 12,
-  padding: "12px 14px",
-  display: "flex",
-  flexDirection: "column",
-  gap: 3,
-};
-
-const noticeBandHeadlineStyle: React.CSSProperties = {
-  fontFamily: SERIF,
-  fontOpticalSizing: "auto",
-  fontSize: 21,
-  fontWeight: 600,
-  color: "var(--foreground)",
-  letterSpacing: "-0.02em",
-  fontVariantNumeric: "tabular-nums",
-};
-
-const noticeBandSuffixStyle: React.CSSProperties = {
-  fontFamily: SANS,
-  fontSize: 12,
-  fontWeight: 500,
-  color: "var(--muted-foreground)",
-};
-
-const noticeBandMedianStyle: React.CSSProperties = {
-  fontSize: 11.5,
-  color: "var(--muted-foreground)",
-  fontVariantNumeric: "tabular-nums",
-};
-
-const noticeBandFallbackStyle: React.CSSProperties = {
-  fontSize: 12,
-  color: "#855316",
-  fontStyle: "italic",
-  lineHeight: 1.5,
-};
-
-const noticeFootnoteStyle: React.CSSProperties = {
-  margin: 0,
-  fontSize: 11,
-  lineHeight: 1.5,
-  color: "var(--muted-foreground)",
-  fontStyle: "italic",
-};
+/* (NonCuratedPricingNotice + its styles removed — every policy now
+   renders the unified per-policy estimate block; the methodology line
+   states when the number is rules-based vs curated-sample anchored.) */

tests/conftest.py

@@ -0,0 +1,31 @@
+"""Shared pytest fixtures.
+
+The recommendation-card EXTRACTION GATE is a new, orthogonal invariant: a
+policy with no extracted corpus file renders as a broken card (raw
+policy_id title, grade "N/A", "No extraction available for this policy.",
+"Data not indexed"), so it must never be cited or quality-seeded.
+
+In production every RETRIEVED policy is renderable. The synthetic
+policy_ids the logic tests build (e.g. "rs-multiplier", "p0",
+"test__policy-a") have no extracted file on disk, so without this fixture
+the gate would empty every synthetic citation set and mask the behaviour
+each test actually checks (selection, ordering, dedup, fit-floor,
+transparency).
+
+So: for every test EXCEPT the dedicated extraction-gate guard
+(tests/test_extraction_gate.py — which restores the real predicate via
+its own monkeypatch), treat test policies as renderable. Forcing
+_has_extraction -> True reproduces the exact pre-gate behaviour these
+tests were written against.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from backend import brain_tools
+
+
+@pytest.fixture(autouse=True)
+def _treat_test_policies_as_renderable(monkeypatch):
+    monkeypatch.setattr(brain_tools, "_has_extraction", lambda pid: True)

tests/test_cited_policies_match_prose.py

@@ -20,8 +20,9 @@ THE CONTRACT THIS PINS:
   `_build_recommendation_citations` returns a citation list that is exactly
   the recommended policies — via explicit mark_recommendation ordering when
   present, else by the policy names actually written in the reply prose —
-  with NO score-order fallback that resurrects un-named policies, and NO
-  count cap.
+  with NO score-order fallback that resurrects un-named policies, and a
+  HARD CAP of 3 (the recommendation cards do not render past 3 — #28; the
+  3 kept are the strongest, best-first by the gate's fit rank).
 
 Run:
     cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
@@ -94,8 +95,8 @@ class TestProseNameNormalisation(unittest.TestCase):
 
 
 class TestMarkRecommendationPath(unittest.TestCase):
-    """When the LLM calls mark_recommendation, those ordered ids ARE the
-    citation set — exactly, in order, no cap."""
+    """When the LLM calls mark_recommendation, those ids ARE the citation
+    set — best-first by gate rank, hard-capped at the 3 strongest (#28)."""
 
     def test_exact_set_and_order_from_marked_ids(self) -> None:
         marked = ["rs-multiplier", "rs-advtopup", "hdfc-myhealth", "star-fho"]
@@ -105,7 +106,13 @@ class TestMarkRecommendationPath(unittest.TestCase):
             marked_policy_ids=marked,
         )
         self.assertTrue(is_rec)
-        self.assertEqual([c["policy_id"] for c in cites], marked)
+        # Hard ≤3 cap — the 3 strongest, best-first by gate rank; the 4th
+        # marked id (star-fho) is dropped by the cap.
+        self.assertEqual(
+            [c["policy_id"] for c in cites],
+            ["rs-multiplier", "rs-advtopup", "hdfc-myhealth"],
+        )
+        self.assertLessEqual(len(cites), 3)
         # The un-recommended high-scorer must NOT appear.
         self.assertNotIn(
             "star-hospcash", [c["policy_id"] for c in cites]
@@ -139,18 +146,18 @@ class TestProseMatchingPath(unittest.TestCase):
         )
         self.assertTrue(is_rec)
         ids = [c["policy_id"] for c in cites]
-        # EXACTLY the 4 named in prose, in prose order.
+        # 4 policies are named in prose, but the cards hard-cap at the 3
+        # strongest (best-first by gate rank); star-fho (4th) is dropped.
         self.assertEqual(
-            ids,
-            ["rs-multiplier", "rs-advtopup", "hdfc-myhealth", "star-fho"],
+            ids, ["rs-multiplier", "rs-advtopup", "hdfc-myhealth"]
         )
-        # 4 named in prose ⇒ 4 cards (the original bug was 4 → 3).
-        self.assertEqual(len(cites), 4)
+        self.assertEqual(len(cites), 3)
         # The false positive from the screenshot is gone.
         self.assertNotIn("star-hospcash", ids)
 
-    def test_no_count_cap(self) -> None:
-        """A 5-policy shortlist must yield 5 cards, not 3."""
+    def test_count_hard_capped_at_3(self) -> None:
+        """A 5-policy shortlist yields EXACTLY 3 cards (best-first) — the
+        recommendation cards do not render past 3 (#28)."""
         chunks = [
             _chunk(f"p{i}", f"Policy Alpha {i}", "ins", 0.9 - i * 0.05, f"k{i}")
             for i in range(5)
@@ -165,10 +172,9 @@ class TestProseMatchingPath(unittest.TestCase):
             marked_policy_ids=[],
         )
         self.assertTrue(is_rec)
-        self.assertEqual(len(cites), 5)
+        self.assertEqual(len(cites), 3)
         self.assertEqual(
-            [c["policy_id"] for c in cites],
-            ["p0", "p1", "p2", "p3", "p4"],
+            [c["policy_id"] for c in cites], ["p0", "p1", "p2"]
         )
 
 

tests/test_extraction_gate.py

@@ -0,0 +1,127 @@
+"""Guard for the recommendation-card EXTRACTION GATE (#29).
+
+THE BUG (from a real production screenshot):
+  A recommended card rendered with the raw policy_id slug as its title
+  ("manipalcigna__sarv…"), grade "N/A", body "No extraction available for
+  this policy.", and "Why this fits you: Data not indexed".
+
+ROOT CAUSE:
+  `_scorecard_signal` / `_quality_seed_candidates` grade off the ~790-entry
+  CURATED layer, but the card UI renders from the EXTRACTED layer
+  (settings.EXTRACTED_DIR/*.json — the same set the marketplace shows).
+  Quality-seed injected curated-graded-but-not-extracted policies into the
+  candidate pool, so the LLM could recommend a policy whose card cannot
+  render.
+
+THE CONTRACT THIS PINS:
+  A policy with no extracted corpus file is NEVER quality-seeded and is
+  ALWAYS dropped from the cited set, even if the LLM explicitly marks it —
+  so a broken "N/A / No extraction available" card can never reach the UI.
+
+This file deliberately uses the REAL `_has_extraction` predicate (the
+package-wide conftest autouse fixture stubs it True for the logic tests;
+here we restore the real one so the gate itself is exercised).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_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  # noqa: E402
+from backend.brain_tools import (  # noqa: E402
+    _has_extraction as _REAL_HAS_EXTRACTION,
+    _quality_seed_candidates,
+)
+from backend.config import settings  # noqa: E402
+from backend.single_brain import _build_recommendation_citations  # noqa: E402
+
+
+def _a_real_extracted_stem() -> str:
+    """Any policy_id that genuinely has an extracted corpus file on disk."""
+    files = sorted(settings.EXTRACTED_DIR.glob("*.json"))
+    assert files, "no extracted corpus files — cannot test the gate"
+    return files[0].stem
+
+
+@pytest.fixture
+def real_extraction(monkeypatch):
+    """Override the conftest autouse stub: use the REAL predicate so the
+    gate's actual on-disk behaviour is what gets exercised here."""
+    monkeypatch.setattr(brain_tools, "_has_extraction", _REAL_HAS_EXTRACTION)
+    brain_tools._extraction_cache.clear()
+    brain_tools._qseed_cache.clear()
+    return _REAL_HAS_EXTRACTION
+
+
+def test_predicate_true_for_extracted_false_for_missing(real_extraction):
+    real = _a_real_extracted_stem()
+    assert brain_tools._has_extraction(real) is True
+    assert (
+        brain_tools._has_extraction("definitely__not-a-real-policy-xyz")
+        is False
+    )
+    assert brain_tools._has_extraction("") is False
+
+
+def test_non_extracted_policy_never_cited_even_when_marked(real_extraction):
+    """The exact production failure: a marked policy with no extracted
+    corpus must be DROPPED, not rendered as an N/A card."""
+    real = _a_real_extracted_stem()
+    chunks = [
+        {
+            "chunk_id": "real1",
+            "policy_id": real,
+            "policy_name": "Real Extracted Plan",
+            "insurer_slug": real.split("__", 1)[0] if "__" in real else "x",
+            "doc_type": "policy",
+            "source_url": f"https://example.com/{real}.pdf",
+            "score": 0.9,
+        },
+        {
+            "chunk_id": "ghost1",
+            "policy_id": "manipalcigna__sarvah-param-NOT-EXTRACTED",
+            "policy_name": "Ghost Plan",
+            "insurer_slug": "manipalcigna",
+            "doc_type": "policy",
+            "source_url": "",
+            "score": 0.95,  # higher score — must STILL be dropped
+        },
+    ]
+    cites, is_rec = _build_recommendation_citations(
+        reply_text="See Real Extracted Plan and Ghost Plan.",
+        retrieved_chunks_all=chunks,
+        marked_policy_ids=[
+            "manipalcigna__sarvah-param-NOT-EXTRACTED",
+            real,
+        ],
+    )
+    assert is_rec is True
+    ids = [c["policy_id"] for c in cites]
+    assert "manipalcigna__sarvah-param-NOT-EXTRACTED" not in ids
+    assert ids == [real]
+
+
+def test_quality_seed_only_emits_renderable_policies(real_extraction):
+    """Every quality-seeded candidate must have an extracted file — so it
+    can never inject a policy whose card renders as N/A."""
+    seeded = _quality_seed_candidates(profile=None, limit=25)
+    assert seeded, "quality-seed returned nothing — basket starved"
+    offenders = [
+        c["policy_id"]
+        for c in seeded
+        if not _REAL_HAS_EXTRACTION(c.get("policy_id") or "")
+    ]
+    assert not offenders, (
+        f"quality-seed emitted non-renderable policies: {offenders}"
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.main([__file__, "-v"]))

tests/test_premium_reconciliation.py

@@ -14,13 +14,20 @@ desired_sum_insured_inr → existing_cover_inr → ₹10L. A user who stated a
 
 Fix: estimate_premium_band() resolves SI via resolve_profile_sum_insured()
 (the single source of truth shared with the panel/widget), prices the whole
-basket at that SI, and rounds the band edges DIRECTIONALLY (floor min / ceil
-max) so the displayed band is a strict superset of every basket member —
-making the per-settings panel point ALWAYS land inside the header band.
+basket at that SI, and reports the p25–p75 INTERQUARTILE of the basket as
+the band (directionally rounded) — the honest "what similar profiles
+typically pay" range. Raw min–max across the heterogeneous basket spans
+~4-5x and renders as a useless, broken-looking band (KI broken-band fix);
+a specific plan's per-settings panel point may sit inside or just outside
+this typical band, which is expected and correct.
 """
 
 from backend.premium_calculator import (
     _DEFAULT_BAND_POLICY_IDS,
+    _ceil_to_500,
+    _floor_to_500,
+    _median,
+    _percentile,
     bulk_estimate,
     estimate,
     estimate_premium_band,
@@ -100,15 +107,30 @@ import pytest
           "parents_age_max": 72, "parents_has_ped": True}, "parents-on-cover"),
     ],
 )
-def test_header_band_is_superset_of_every_panel_point(profile, label):
+def test_header_band_is_p25_p75_interquartile(profile, label):
     band = estimate_premium_band(dict(profile))
-    points = _panel_points_for(profile)
+    points = _panel_points_for(profile)  # sorted basket points
     assert points, f"no basket points for {label}"
-    for p in points:
-        assert band["min_inr"] <= p <= band["max_inr"], (
-            f"{label}: panel point ₹{p:,} fell OUTSIDE header band "
-            f"₹{band['min_inr']:,}–₹{band['max_inr']:,} — header≠panel regression"
-        )
+    # New contract: the band edges ARE the directionally-rounded p25 / p75
+    # of the basket — the interquartile "typical range", NOT raw min-max.
+    assert band["min_inr"] == _floor_to_500(_percentile(points, 25)), label
+    assert band["max_inr"] == _ceil_to_500(_percentile(points, 75)), label
+    # min ≤ median ≤ max, all positive.
+    assert 0 < band["min_inr"] <= band["median_inr"] <= band["max_inr"], label
+    # The typical (median) plan lies inside the band.
+    med = _median(points)
+    assert band["min_inr"] <= med <= band["max_inr"], (
+        f"{label}: median basket point ₹{med:,} fell outside the typical "
+        f"band ₹{band['min_inr']:,}–₹{band['max_inr']:,}"
+    )
+    # And it is materially TIGHTER than the raw min-max envelope — the
+    # entire point of the fix (the heterogeneous basket's raw spread is
+    # ~4-5x; the interquartile band must be a strict subset of it).
+    raw_lo = _floor_to_500(min(points))
+    raw_hi = _ceil_to_500(max(points))
+    assert band["min_inr"] >= raw_lo, label
+    assert band["max_inr"] <= raw_hi, label
+    assert (band["max_inr"] - band["min_inr"]) <= (raw_hi - raw_lo), label
 
 
 def test_band_exposes_resolved_si_for_panel_alignment():