feat(profile+pricing): KI-259..KI-266 — B-bundle (compare modal + per-policy + scorecard + premium band + budget/SI + union + persistence + recall)

B1 — Structured recommendation cards + Compare modal
- NEW frontend/src/components/PolicyCompareModal.tsx: side-by-side compare
for up to 3 cited policies. Each column = insurer logo + policy name +
premium-calc slot + scorecard slot + policy details expandable + PDF.
- page.tsx Message renderer now uses CitedPolicyCards (replaces flat
PolicyChipsFromCitations). "Compare all" pill opens the modal when >=2
cited policies present. Removed dead PolicyChipsFromCitations (-67 LOC).

B2 — Per-policy premium widget with sliders + profile defaults
- NEW frontend/src/components/PolicyPremiumWidget.tsx: SI/tenure/deductible
sliders, 300ms debounced fetch, AbortController cleanup, profile-summary
line, "Estimate" badge when assumed=true, breakdown bullets.
- backend/premium_calculator.py + main.py /api/premium/bulk:
multiplicative model (base x SI x age-band x location x family x tenure
x deductible). Anchors to illustrative_premiums.json when available
(assumed=false); flat heuristic otherwise (assumed=true).

B3 — Profile-aware scorecard widget
- NEW frontend/src/components/PolicyScorecardWidget.tsx: grade tile +
score + 6 sub-score bars + Why-this-score bullets + limited-data warning.
- backend/main.py /api/scorecard/bulk: takes (policy_ids, profile) ->
per-policy {grade, score, sub_scores, profile_rationale, completeness}.
- backend/scorecard.py: _profile_tuned_weights audited + fixed two bugs
(family dependents now BOOST cost predictability; senior+family keeps
renewal-weight boost instead of being silently cancelled).

B4 — Aggregate predicted premium band chip (header next to profile %)
- backend/premium_calculator.py: estimate_premium_band fans out to
26 curated policies, returns {min, median, max, sample_size, assumed}
rounded to nearest Rs.500.
- backend/main.py GET /api/profile/predicted-premium-band?session_id=...
- page.tsx: amber/orange chip after the violet profile-completeness pill,
500ms debounced on completeness change, gated on completeness_pct >= 50.

B5 — RULE 2.5 capture for desired_sum_insured + budget
- single_brain.py SYSTEM_PROMPT new RULE 2.5: after recap confirmation,
ask for sum insured + premium budget. SOFT capture (does not block
recommendation if user skips).
- brain_tools.py _ACCEPTED_FIELDS adds desired_sum_insured_inr.
- brain_tools.py _coerce_desired_sum_insured parses "10L"/"1 crore"/
"Rs.500000" via _parse_inr_amount, clamps [50000, 5e8].
- needs_finder.py Profile dataclass adds desired_sum_insured_inr field.

B6 — Unified SLOT_UNION drives both profile match AND pricing
- brain_tools.py SLOT_UNION constant (13 fields: 7 required + 3 pricing
+ 3 family). union_snapshot(profile) helper. Import-time assert that
SLOT_UNION ⊆ _ACCEPTED_FIELDS. Added parents_to_insure /
parents_age_max / parents_has_ped to accepted fields + _coerce_bool.
- premium_calculator.py: three new loadings used by both estimate() and
bulk_estimate(): health_loading (1.0-1.5x by chronic-condition severity),
existing_cover_loading (1.0/0.95/0.85x by current cover signal),
parents_loading (1.0-1.8x when dependents include parents +
parents_age_max).
desired_sum_insured_inr now overrides default 10L SI for the estimate.
- single_brain.py SYSTEM_PROMPT RULE 2 and RULE 2.5 extended to ask for
the full union (health, existing cover, parents age) and to include
health/cover signals in the retrieve_policies query.

B7 — Persist union to profile JSON + vector + returning-user recall
- NEW backend/profile_persistence.py:
- auto_persist_session(session) flushes the 13-slot union to
profile_store.save_profile + profile_rag.upsert_profile_chunk.
Try/except wrapped; persistence failure never blocks reply.
- extract_potential_name(text) regex w/ stopword filter
(I'm/My name is/this is/name's <Name>, <Name> here).
- try_recall_by_name(session, name) and recall_by_name_payload(name,
session_id) helpers.
- main.py:
- ChatResponse.returning_user_recalled: bool field.
- Pre/post-turn snapshot logic detects genuine recall (vs first-time
capture on turn 1) and stamps the flag.
- auto_persist_session called after every /api/chat turn (best-effort).
- NEW POST /api/profile/recall-by-name endpoint.
- single_brain.py handle_turn:
- If turn_idx==1 AND session.profile.name empty, extract_potential_name
from user_text + try_recall_by_name. On hit, profile is hydrated
before KNOWN PROFILE block is built and KI-255's is_returning_user
flips True so RULE 4 fires on this same Gemini iteration.
- frontend:
- api.ts: ChatResponse.returning_user_recalled? boolean +
postProfileRecallByName helper + RecallByNameResponse type.
- page.tsx: welcomeBack state + banner above messages when
returning_user_recalled. Banner shows name + last predicted band +
Use-this-profile / Update-my-info actions. Cleared on Clear Chat.

Verification:
- python -m py_compile clean on all 7 backend files
- npx tsc --noEmit clean on frontend
- Sample pricing comparison: 65yo+diabetes+BP+parents75+5L existing
cover = 12.09x baseline (vs healthy 34yo metro couple).
- Recall heuristic test: 8/8 cases pass incl. negation
("I am okay, thanks" returns None).

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

backend/brain_tools.py

@@ -15,6 +15,40 @@ Each function:
 The Gemini function-calling DSL (JSON Schema-flavoured) for these three
 tools is generated by `single_brain.TOOL_SCHEMAS` from this module's
 metadata.
+
+═══════════════════════════════════════════════════════════════════════════
+SLOT_UNION — SINGLE SOURCE OF TRUTH FOR CAPTURED FIELDS (B6, 2026-05-15)
+═══════════════════════════════════════════════════════════════════════════
+SLOT_UNION enumerates every captured field that influences EITHER the
+recommendation pipeline (retrieval query + scorecard) OR the pricing
+pipeline (premium_calculator.estimate / bulk_estimate). It is the contract
+between brain_tools (capture surface), single_brain (LLM tool calls),
+premium_calculator (pricing inputs) and scorecard (match scoring).
+
+Slot → consumer matrix:
+
+  RECOMMENDATION SLOTS (in _REQUIRED_FOR_READY — hard gate)
+    name                  → profile identity (no pricing influence)
+    age                   → retrieval query + scorecard + pricing (age band)
+    dependents            → retrieval query + scorecard + pricing (family loading)
+    location_tier         → retrieval query + scorecard + pricing (location loading)
+    income_band           → retrieval query + scorecard
+    primary_goal          → retrieval query + scorecard
+    health_conditions     → retrieval query + scorecard + pricing (health loading)
+
+  PRICING-ONLY SLOTS (B5 + B6 additions — SOFT capture, post-recap)
+    budget_band           → pricing band match
+    desired_sum_insured_inr → pricing SI override (per-policy estimate)
+    existing_cover_inr    → pricing (existing-cover discount loading)
+
+  FAMILY-DETAIL SLOTS (used by pricing if dependents includes parents)
+    parents_to_insure     → triggers parents_loading branch
+    parents_age_max       → pricing (parents age loading 1.0× / 1.4× / 1.8×)
+    parents_has_ped       → pricing (PED loading inflation for parents)
+
+Total: 13 slots. `gender` is tolerated by save_profile_field for forward
+compat but is NOT on the Profile dataclass today; it does not appear in
+SLOT_UNION because no consumer reads it.
 """
 
 from __future__ import annotations
@@ -41,6 +75,14 @@ _ACCEPTED_FIELDS = {
     "health_conditions",
     "existing_cover_inr",
     "budget_band",
+    "desired_sum_insured_inr",  # SOFT capture (pricing input, post-recap)
+    # Family-detail pricing inputs (B6) — already on the Profile dataclass
+    # via needs_finder.Profile (parents_to_insure / parents_age_max /
+    # parents_has_ped). Listed here so save_profile_field can persist them
+    # when Gemini extracts them post-recap.
+    "parents_to_insure",
+    "parents_age_max",
+    "parents_has_ped",
     "gender",  # tolerated; not persisted unless Profile gains the field
 }
 
@@ -58,6 +100,66 @@ _REQUIRED_FOR_READY = (
 )
 
 
+# ───────────────────────────────────────────────────────────────────────────
+# SLOT_UNION (B6, 2026-05-15)
+# ───────────────────────────────────────────────────────────────────────────
+# Single source of truth for every captured field that drives EITHER the
+# profile (recommendation match + scorecard) OR the pricing pipeline
+# (premium_calculator.estimate / bulk_estimate). See module docstring above
+# for the full slot→consumer matrix.
+#
+# Ordering convention (do not re-order without auditing union_snapshot
+# callers): required slots first, then pricing-only slots, then
+# family-detail slots. Total = 13.
+SLOT_UNION: tuple[str, ...] = (
+    # Recommendation slots (in _REQUIRED_FOR_READY)
+    "name",
+    "age",
+    "dependents",
+    "location_tier",
+    "income_band",
+    "primary_goal",
+    "health_conditions",
+    # Pricing slots (B5 + B6 additions)
+    "budget_band",
+    "desired_sum_insured_inr",
+    "existing_cover_inr",
+    # Family-detail slots (used by pricing if applicable)
+    "parents_to_insure",
+    "parents_age_max",
+    "parents_has_ped",
+)
+
+# Invariant: every SLOT_UNION field must be accepted by save_profile_field
+# (otherwise the LLM can never capture it). Validated at import time so a
+# future delete here is loud, not silent.
+assert all(_s in _ACCEPTED_FIELDS for _s in SLOT_UNION), (
+    "SLOT_UNION contains a field not in _ACCEPTED_FIELDS: "
+    f"{[s for s in SLOT_UNION if s not in _ACCEPTED_FIELDS]}"
+)
+
+
+def union_snapshot(profile) -> dict:
+    """Return a JSON-safe dict of every SLOT_UNION field currently captured
+    on `profile`. Empty / None / [] slots are EXCLUDED so the pricing
+    pipeline can safely treat presence as "captured" (KI-091 null-overwrite
+    rule — never pass None where 0 is meaningful).
+
+    Used by premium_calculator.estimate / bulk_estimate to read pricing
+    inputs without re-implementing the field-name list on each side.
+    """
+    snap: dict = {}
+    for fld in SLOT_UNION:
+        try:
+            v = getattr(profile, fld, None)
+        except Exception:  # noqa: BLE001
+            v = None
+        if v in (None, "", []):
+            continue
+        snap[fld] = v
+    return snap
+
+
 def _profile_complete(profile) -> bool:
     """Return True when every slot in _REQUIRED_FOR_READY is non-empty on
     the live Profile dataclass."""
@@ -110,6 +212,12 @@ def save_profile_field(session, field: str, value: Any) -> dict:
             normalized = _coerce_health_conditions(value)
         elif fld == "existing_cover_inr":
             normalized = _coerce_existing_cover(value)
+        elif fld == "desired_sum_insured_inr":
+            normalized = _coerce_desired_sum_insured(value)
+        elif fld in ("parents_to_insure", "parents_has_ped"):
+            normalized = _coerce_bool(value)
+        elif fld == "parents_age_max":
+            normalized = _coerce_age(value)
         elif fld == "name":
             normalized = (str(value).strip() if value is not None else None) or None
         elif fld == "gender":
@@ -525,6 +633,64 @@ def _coerce_existing_cover(value: Any) -> Optional[int]:
     return None
 
 
+def _coerce_bool(value: Any) -> Optional[bool]:
+    """Tri-state bool coercion for parents_to_insure / parents_has_ped.
+
+    Accepts: True / False / "yes" / "no" / "y" / "n" / "true" / "false"
+    / 1 / 0. Anything else → None (so the KI-091 null-overwrite guard
+    refuses to clobber a previously-captured value).
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value)
+    s = str(value).strip().lower()
+    if s in ("true", "yes", "y", "1"):
+        return True
+    if s in ("false", "no", "n", "0"):
+        return False
+    return None
+
+
+def _coerce_desired_sum_insured(value: Any) -> Optional[int]:
+    """Parse desired sum insured (cover amount) as integer rupees.
+
+    Accepts: "10L" / "10 lakh" / "1 crore" / "1Cr" / 1000000 /
+    "₹10,00,000" / "five lakh" (rejected — words not numerals).
+    Delegates to `_parse_inr_amount` from needs_finder for the heavy lift,
+    falls back to bare-digit extraction. Clamps to [50_000, 500_000_000]
+    (₹50K floor, ₹50Cr ceiling) — anything outside is implausible for a
+    health-insurance sum insured and likely a parse error.
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        n = int(value)
+        return max(50_000, min(500_000_000, n))
+    try:
+        from backend.needs_finder import _parse_inr_amount
+
+        parsed = _parse_inr_amount(str(value))
+        if parsed is not None:
+            return max(50_000, min(500_000_000, int(parsed)))
+    except Exception:  # noqa: BLE001
+        pass
+    # Last-ditch: strip non-digits (handles "₹10,00,000" if parser missed).
+    try:
+        digits = "".join(ch for ch in str(value) if ch.isdigit())
+        if digits:
+            n = int(digits)
+            if n >= 50_000:
+                return min(500_000_000, n)
+    except Exception:  # noqa: BLE001
+        pass
+    return None
+
+
 def _coerce_health_conditions(value: Any) -> Optional[list[str]]:
     """Always return list[str] lowercase, stripped, empties dropped.
 
@@ -566,4 +732,6 @@ __all__ = [
     "save_profile_field",
     "retrieve_policies",
     "mark_recommendation",
+    "SLOT_UNION",
+    "union_snapshot",
 ]

backend/main.py

@@ -161,6 +161,17 @@ class ChatResponse(BaseModel):
             "non-empty on the live session.profile at end-of-turn."
         ),
     )
+    # KI-Z7 (2026-05-15) — Feature B. True when single_brain.handle_turn's
+    # turn-1 name heuristic matched a stored profile and hydrated the
+    # session. Frontend renders a "Welcome back, <name>!" banner with the
+    # last predicted-premium band when this flips True on the first turn.
+    returning_user_recalled: bool = Field(
+        False,
+        description=(
+            "True iff a stored named-profile was matched + hydrated on the "
+            "current turn (typically only on turn 1)."
+        ),
+    )
 
 
 class TTSRequest(BaseModel):
@@ -213,6 +224,40 @@ class UploadResponse(BaseModel):
 # uses the same _REQUIRED_FOR_READY tuple; we mirror the call here instead of
 # duplicating the slot list so a future addition (e.g. risk_appetite) only
 # needs to be applied in brain_tools.
+# KI-Z7 (2026-05-15) — Feature B helper. Distinguishes "first-time capture
+# on turn 1" from "stored profile recalled on turn 1". Both end with a
+# non-empty Profile on the session; only the latter should flip
+# returning_user_recalled. Heuristic: if EVERY currently-filled slot was
+# written THIS turn (i.e. lives in `profile_updates`), the user just typed
+# their facts — NOT a recall. If at least one filled slot is NOT in
+# profile_updates, those slots came from the recall hydration.
+_FEATURE_B_SLOT_LIST: tuple[str, ...] = (
+    "name", "age", "dependents", "location_tier",
+    "income_band", "primary_goal", "health_conditions",
+)
+
+
+def _every_filled_slot_was_set_this_turn(profile, profile_updates: dict) -> bool:
+    """Return True iff every populated slot on `profile` was also set in
+    `profile_updates` this turn. Used by the recall detector to suppress
+    the banner when the user just freshly introduced themselves.
+    """
+    if not isinstance(profile_updates, dict):
+        profile_updates = {}
+    pu = set(profile_updates.keys())
+    any_filled = False
+    for fld in _FEATURE_B_SLOT_LIST:
+        v = getattr(profile, fld, None)
+        if v in (None, "", []):
+            continue
+        any_filled = True
+        if fld not in pu:
+            return False
+    # If nothing was filled at all, "every filled" is vacuously True →
+    # detector should NOT flip returning_user_recalled.
+    return True if any_filled else True
+
+
 def _compute_profile_complete(session_id: str) -> bool:
     """Read the live session profile and return True iff every required slot
     is populated. Tolerant of every failure mode (no session yet, session
@@ -545,6 +590,11 @@ async def chat(req: ChatRequest, request: Request):
     if preferred_codec not in _allowed_codecs:
         preferred_codec = "audio/wav"
     t_chat0 = time.time()
+    # KI-Z7 (2026-05-15) — pre-turn snapshot for the returning-user-recall
+    # detector below. Defaults match the "no session yet" case so the
+    # detector simply doesn't fire on the legacy orchestrator path.
+    _pre_turn_name: str = ""
+    _pre_turn_idx: int = 0
     # KI-106 — never let an inner TimeoutError / unhandled exception bubble out
     # of handle_turn as a 500. C4 NRI persona saw 5× HTTP 500s with
     # "Orchestrator failed: TimeoutError" because the outer non-fact-find
@@ -562,6 +612,13 @@ async def chat(req: ChatRequest, request: Request):
             from backend.session_state import get_session
 
             _sb_session = get_session(session_id)
+            # KI-Z7 — snapshot the pre-turn (name, turn_idx) so we can tell
+            # AFTER handle_turn whether the turn-1 name heuristic actually
+            # recalled a stored profile (and stamp ChatResponse accordingly).
+            _pre_turn_name = (
+                getattr(_sb_session.profile, "name", None) or ""
+            ).strip()
+            _pre_turn_idx = int(getattr(_sb_session, "turn_idx", 0) or 0)
             # Z2 fix — Issue 3 (brain election bouncing). Once a session
             # has had ANY successful single_brain turn, it must stay on
             # single_brain for the rest of its lifetime. Falling back to
@@ -831,6 +888,63 @@ async def chat(req: ChatRequest, request: Request):
     except Exception:  # noqa: BLE001 — log IO must never block a reply
         pass
 
+    # KI-Z7 (2026-05-15) — Feature A. Auto-persist the live profile to disk
+    # + Chroma AFTER handle_turn returns. brain_tools.save_profile_field
+    # only mutates the in-memory Profile; this flushes the union to the
+    # canonical name-keyed JSON and refreshes the user's profile chunk so a
+    # NEW session can recover the full profile via the turn-1 name recall.
+    # Wrapped in try/except — persistence failure NEVER breaks the reply.
+    _returning_user_recalled = False
+    try:
+        from backend.session_state import get_session as _get_session_p
+        from backend.profile_persistence import auto_persist_session
+
+        _persist_session = _get_session_p(session_id)
+        await auto_persist_session(_persist_session)
+
+        # KI-Z7 — Feature B detection. The pre-turn snapshot (captured before
+        # single_brain.handle_turn ran) lets us tell whether the turn-1 name
+        # heuristic actually hydrated a stored profile. Conditions:
+        #   (a) this WAS the first turn (pre_turn_idx == 0),
+        #   (b) no name on the profile BEFORE the turn ("" → recalled),
+        #   (c) a name AND at least one other slot are present AFTER the turn.
+        # Frontend uses this flag to render the "Welcome back" banner.
+        if USE_SINGLE_BRAIN:
+            try:
+                _post_name = (
+                    getattr(_persist_session.profile, "name", None) or ""
+                ).strip()
+                _post_has_other_slots = any(
+                    getattr(_persist_session.profile, fld, None) not in (None, "", [])
+                    for fld in (
+                        "age", "dependents", "location_tier",
+                        "income_band", "primary_goal", "health_conditions",
+                    )
+                )
+                if (
+                    _pre_turn_idx == 0
+                    and not _pre_turn_name
+                    and _post_name
+                    and _post_has_other_slots
+                    # save_profile_field captures a NEW name on turn 1 too —
+                    # only flag as returning when prior slots came from the
+                    # recall path, NOT from in-this-turn extraction. The
+                    # profile_updates dict carries fields written THIS turn;
+                    # if EVERY filled slot is in profile_updates, it's a
+                    # first-time capture, NOT a recall.
+                    and not _every_filled_slot_was_set_this_turn(
+                        _persist_session.profile, turn.profile_updates,
+                    )
+                ):
+                    _returning_user_recalled = True
+            except Exception:  # noqa: BLE001
+                pass
+    except Exception as _persist_err:  # noqa: BLE001
+        logging.warning(
+            "auto_persist_session failed (session=%s): %s: %s",
+            session_id, type(_persist_err).__name__, _persist_err,
+        )
+
     # Bug B defense — CitationOut requires page_start/page_end as ints, but
     # single_brain.TurnResult.citations dicts don't carry those fields (its
     # citation shape is {chunk_id, policy_id, policy_name, insurer_slug,
@@ -880,6 +994,7 @@ async def chat(req: ChatRequest, request: Request):
             blocked=turn.blocked,
             profile_updates=turn.profile_updates,
             profile_complete=_compute_profile_complete(session_id),
+            returning_user_recalled=_returning_user_recalled,
         )
     except Exception as _resp_err:  # noqa: BLE001
         # Anything else (TypeError/AttributeError/ValidationError) on the
@@ -2498,6 +2613,249 @@ async def policy_scorecard(
     )
 
 
+# ----------------------------------------------------------------------------
+# Bulk scorecard endpoint — powers the PolicyCompareModal scorecard widget.
+# ----------------------------------------------------------------------------
+# Why bulk: the compare modal renders 2-4 scorecards in parallel and each is
+# profile-tuned. Doing N sequential GETs from the client wastes the per-policy
+# JSON I/O cost (we re-load every reviews file even for the same insurer) and
+# fans out N renders. One POST with the full profile + id list lets us:
+#   - load each reviews file once per slug (memoized in the loop)
+#   - return missing policies as N/A so the client renders a clean placeholder
+#   - share one profile dict — no copy-paste of every field in N query strings
+class BulkScorecardRequest(BaseModel):
+    policy_ids: list[str]
+    profile: Optional[dict] = None
+
+
+class BulkScorecardEntry(BaseModel):
+    policy_id: str
+    policy_name: str
+    insurer_slug: str
+    overall_grade: str               # "A" / "B+" / etc — letter only for missing
+    overall_score: int               # 0-100
+    sub_scores: dict[str, int]       # {coverage_breadth: 82, cost_predictability: 64, ...}
+    profile_rationale: list[str]     # bullets explaining WHY this score for this user
+    data_completeness_pct: float
+    one_liner: str = ""
+    # raw signals per sub-score so the widget can pop-out a tooltip with detail
+    signals: dict[str, list[str]] = Field(default_factory=dict)
+
+
+class BulkScorecardResponse(BaseModel):
+    per_policy: dict[str, BulkScorecardEntry]
+
+
+def _slugify_subscore(name: str) -> str:
+    """'Coverage Breadth' -> 'coverage_breadth' (stable key for the widget)."""
+    return name.lower().replace("-", "_").replace("&", "and").replace(" ", "_").replace("__", "_")
+
+
+def _profile_rationale_for(policy: dict, profile: Optional[dict], sub_scores) -> list[str]:
+    """Turn raw signals + profile facts into 2-5 plain-English bullets.
+
+    Each bullet is shaped as 'Strong fit:' or 'Weak fit:' so the buyer can scan
+    pros and cons at a glance. We anchor each bullet to a concrete profile
+    attribute (you mentioned X) so the user trusts the personalization is real.
+    """
+    if not profile:
+        return []
+    bullets: list[str] = []
+    conditions = profile.get("health_conditions") or []
+    cond_str = " ".join(str(c).lower() for c in conditions) if isinstance(conditions, list) else ""
+    age = profile.get("age") if isinstance(profile.get("age"), int) else None
+    deps = (profile.get("dependents") or "").lower()
+    loc = profile.get("location_tier")
+    goal = (profile.get("primary_goal") or "").lower()
+    existing = profile.get("existing_cover_inr")
+
+    # Pre-existing disease handling
+    if cond_str and any(c in cond_str for c in ("diab", "bp", "hyper", "thyroid", "heart")):
+        ped = policy.get("pre_existing_disease_waiting_months")
+        try:
+            ped_n = int(ped) if ped is not None else None
+        except (TypeError, ValueError):
+            ped_n = None
+        if ped_n is not None:
+            if ped_n <= 24:
+                bullets.append(f"Strong fit: PED waiting is only {ped_n} months — short for your {cond_str.strip()}.")
+            elif ped_n >= 48:
+                bullets.append(f"Weak fit: {ped_n}-month PED waiting is long for your {cond_str.strip()} — alternatives offer 24-36 months.")
+            else:
+                bullets.append(f"Fair fit: {ped_n}-month PED waiting is standard for your {cond_str.strip()}.")
+
+    # Senior + claim reliability
+    if age and age >= 60:
+        nh = policy.get("network_hospital_count")
+        try:
+            nh_n = int(nh) if nh is not None else None
+        except (TypeError, ValueError):
+            nh_n = None
+        if nh_n is not None and nh_n >= 7000:
+            bullets.append(f"Strong fit: {nh_n:,}+ cashless hospitals matters at age {age} when access speed counts.")
+        elif nh_n is not None and nh_n < 3000:
+            bullets.append(f"Weak fit: only {nh_n} cashless hospitals — thin network for age {age}.")
+        maxr = policy.get("max_renewal_age")
+        if maxr and int(maxr) >= 99:
+            bullets.append(f"Strong fit: lifelong renewability — keeps protecting you past 70.")
+
+    # Family + room-rent / maternity
+    if any(k in deps for k in ("spouse", "wife", "husband", "partner", "kid", "child", "family")):
+        rrc = policy.get("room_rent_capping")
+        rrc_text = rrc if isinstance(rrc, str) else (rrc.get("limit_text") if isinstance(rrc, dict) else None)
+        if rrc_text and "no cap" in rrc_text.lower():
+            bullets.append("Strong fit: no room-rent cap — works for any hospital your family chooses.")
+        elif rrc_text and ("1%" in rrc_text or "%" in rrc_text):
+            metro_qual = " in a metro" if loc == "metro" else ""
+            bullets.append(f"Weak fit: room rent capped ({rrc_text[:40].strip()}) may be tight for hospitals{metro_qual}.")
+        if any(k in deps for k in ("spouse", "wife", "husband", "partner")):
+            mc = policy.get("maternity_coverage")
+            covered = mc.get("covered") if isinstance(mc, dict) else mc
+            if covered is True:
+                mw = policy.get("maternity_waiting_months")
+                bullets.append(
+                    f"Strong fit: maternity covered with {mw}-month wait — relevant to your spouse."
+                    if mw else
+                    "Strong fit: maternity covered — relevant to your spouse."
+                )
+            elif covered is False:
+                bullets.append("Weak fit: no maternity coverage — you'd need a separate rider.")
+
+    # First-time buyer — simplicity / premium predictability
+    if existing == 0:
+        copay = policy.get("copayment_pct")
+        try:
+            copay_n = float(copay) if copay is not None else None
+        except (TypeError, ValueError):
+            copay_n = None
+        if copay_n is not None and copay_n == 0:
+            bullets.append("Strong fit: zero co-pay — simpler to budget for as a first-time buyer.")
+        elif copay_n is not None and copay_n >= 20:
+            bullets.append(f"Weak fit: {copay_n:.0f}% co-pay adds a surprise out-of-pocket — hard to plan as a first-time buyer.")
+
+    # Tax-saving goal anchor
+    if "tax" in goal:
+        bullets.append("Note: premium qualifies for Section 80D deduction — aligned with your tax-saving goal.")
+
+    # If we still have <2 bullets, fall back to top sub-score deltas vs neutral
+    if len(bullets) < 2:
+        ranked = sorted(sub_scores, key=lambda s: s.score, reverse=True)
+        if ranked:
+            top = ranked[0]
+            bullets.append(f"Strongest area: {top.name} ({top.score}/100) — {top.summary.lower()}.")
+        if len(ranked) > 1:
+            bot = ranked[-1]
+            if bot.score < 60:
+                bullets.append(f"Watch out: {bot.name} ({bot.score}/100) — {bot.summary.lower()}.")
+
+    return bullets[:5]
+
+
+def _letter_grade_with_plus(score: int) -> str:
+    """Convert 0-100 to A / A- / B+ / B / B- / C+ / C / C- / D / F.
+
+    The base grade_for() returns flat letters (A/B/C/D/F). For the compare
+    widget the buyer wants finer distinction between e.g. an 84 (top of B) and
+    a 71 (bottom of B). Thresholds:
+        90+ A, 85-89 A-, 80-84 B+, 75-79 B, 70-74 B-,
+        65-69 C+, 60-64 C, 55-59 C-, 40-54 D, <40 F.
+    """
+    if score >= 90: return "A"
+    if score >= 85: return "A-"
+    if score >= 80: return "B+"
+    if score >= 75: return "B"
+    if score >= 70: return "B-"
+    if score >= 65: return "C+"
+    if score >= 60: return "C"
+    if score >= 55: return "C-"
+    if score >= 40: return "D"
+    return "F"
+
+
+@app.post("/api/scorecard/bulk", response_model=BulkScorecardResponse)
+async def scorecard_bulk(req: BulkScorecardRequest):
+    """Compute profile-tuned scorecards for N policies in one round-trip.
+
+    Body: { policy_ids: [...], profile: {...} }
+    Returns: { per_policy: { <policy_id>: { overall_grade, overall_score,
+                                            sub_scores, profile_rationale,
+                                            data_completeness_pct } } }
+
+    Missing policy_ids get overall_grade="N/A" + rationale=["Data not indexed"].
+    """
+    import json as _json
+    from backend.scorecard import build_scorecard
+
+    if not req.policy_ids:
+        raise HTTPException(400, "policy_ids must be a non-empty list")
+    if len(req.policy_ids) > 8:
+        raise HTTPException(400, "bulk scorecard caps at 8 policies per call")
+
+    profile = req.profile or None
+    insurer_cache: dict[str, Optional[dict]] = {}
+    out: dict[str, BulkScorecardEntry] = {}
+
+    for pid in req.policy_ids:
+        extracted_path = settings.EXTRACTED_DIR / f"{pid}.json"
+        if not extracted_path.exists():
+            out[pid] = BulkScorecardEntry(
+                policy_id=pid,
+                policy_name=pid,
+                insurer_slug="?",
+                overall_grade="N/A",
+                overall_score=0,
+                sub_scores={},
+                profile_rationale=["Data not indexed"],
+                data_completeness_pct=0.0,
+                one_liner="No extraction available for this policy.",
+                signals={},
+            )
+            continue
+        try:
+            policy = _json.loads(extracted_path.read_text())
+        except Exception as e:
+            out[pid] = BulkScorecardEntry(
+                policy_id=pid, policy_name=pid, insurer_slug="?",
+                overall_grade="N/A", overall_score=0, sub_scores={},
+                profile_rationale=[f"Data unreadable: {e}"],
+                data_completeness_pct=0.0,
+                one_liner="Extraction file is corrupted.",
+                signals={},
+            )
+            continue
+
+        slug = policy.get("insurer_slug") or "?"
+        if slug not in insurer_cache:
+            insurer_cache[slug] = None
+            rp = settings.CORPUS_DIR.parent.parent / "40-data" / "reviews" / f"{slug}.json"
+            if rp.exists():
+                try:
+                    insurer_cache[slug] = _json.loads(rp.read_text())
+                except Exception:
+                    insurer_cache[slug] = None
+
+        sc = build_scorecard(policy, insurer_reviews=insurer_cache[slug], profile=profile)
+
+        sub_map = {_slugify_subscore(s.name): s.score for s in sc.sub_scores}
+        signal_map = {_slugify_subscore(s.name): s.signals for s in sc.sub_scores}
+        rationale = _profile_rationale_for(policy, profile, sc.sub_scores)
+
+        out[pid] = BulkScorecardEntry(
+            policy_id=sc.policy_id or pid,
+            policy_name=sc.policy_name or pid,
+            insurer_slug=sc.insurer_slug or slug,
+            overall_grade=_letter_grade_with_plus(sc.overall_score),
+            overall_score=sc.overall_score,
+            sub_scores=sub_map,
+            profile_rationale=rationale,
+            data_completeness_pct=sc.data_completeness_pct,
+            one_liner=sc.one_liner,
+            signals=signal_map,
+        )
+
+    return BulkScorecardResponse(per_policy=out)
+
+
 class ReviewsResponse(BaseModel):
     insurer_slug: str
     insurer_name: str
@@ -2587,6 +2945,84 @@ async def premium_estimate(req: PremiumEstimateRequest):
     )
 
 
+# ---------------------------------------------------------------------------
+# /api/premium/bulk — multi-policy slider-driven premium calculator
+# Powers the PolicyPremiumWidget inside PolicyCompareModal.
+# ---------------------------------------------------------------------------
+
+class PremiumBulkProfile(BaseModel):
+    age: Optional[int] = Field(None, ge=0, le=120)
+    dependents: Optional[str] = None
+    location_tier: Optional[str] = None
+    family_size: Optional[int] = Field(None, ge=0, le=10)
+    smoker: Optional[bool] = False
+    pre_existing_conditions: Optional[str] = "none"
+
+
+class PremiumBulkOverride(BaseModel):
+    sum_insured_inr: Optional[int] = Field(None, ge=100_000, le=100_000_000)
+    tenure_years: Optional[int] = Field(None, ge=1, le=3)
+    deductible_inr: Optional[int] = Field(None, ge=0, le=200_000)
+
+
+class PremiumBulkRequest(BaseModel):
+    policy_ids: list[str] = Field(..., min_length=1, max_length=20)
+    profile: PremiumBulkProfile = Field(default_factory=PremiumBulkProfile)
+    overrides: Optional[dict[str, PremiumBulkOverride]] = None
+
+
+class PremiumBulkRow(BaseModel):
+    policy_id: str
+    premium_inr_annual: int
+    breakdown: dict
+    sum_insured_inr: int
+    tenure_years: int
+    deductible_inr: int
+    assumed: bool
+    notes: list[str] = []
+
+
+class PremiumBulkResponse(BaseModel):
+    per_policy: dict[str, PremiumBulkRow]
+    profile_used: PremiumBulkProfile
+    disclaimer: str = (
+        "Illustrative estimates only — actual premiums depend on underwriting, "
+        "medical history, and quote-time risk factors. Confirm with the insurer."
+    )
+
+
+@app.post("/api/premium/bulk", response_model=PremiumBulkResponse)
+async def premium_bulk(req: PremiumBulkRequest):
+    """Bulk slider-driven premium estimator for the PolicyCompareModal widget."""
+    from backend.premium_calculator import bulk_estimate as _bulk
+
+    overrides = {
+        pid: (ov.model_dump(exclude_none=True) if ov else {})
+        for pid, ov in (req.overrides or {}).items()
+    }
+    rows = _bulk(
+        policy_ids=req.policy_ids,
+        profile=req.profile.model_dump(exclude_none=True),
+        overrides=overrides,
+    )
+    return PremiumBulkResponse(
+        per_policy={
+            pid: PremiumBulkRow(
+                policy_id=r.policy_id,
+                premium_inr_annual=r.premium_inr_annual,
+                breakdown=r.breakdown,
+                sum_insured_inr=r.sum_insured_inr,
+                tenure_years=r.tenure_years,
+                deductible_inr=r.deductible_inr,
+                assumed=r.assumed,
+                notes=r.notes,
+            )
+            for pid, r in rows.items()
+        },
+        profile_used=req.profile,
+    )
+
+
 @app.post("/api/tts")
 async def tts(req: TTSRequest):
     """Standalone TTS endpoint — returns base64 WAV."""
@@ -2611,6 +3047,104 @@ async def api_root():
     }
 
 
+# ---------------------------------------------------------------------------
+# Profile-level predicted-premium BAND — feeds the chat-UI chip that sits
+# next to the "X% DONE" profile-completeness pill. Updates reactively as the
+# profile fills in (frontend refetches whenever completeness_pct changes).
+# ---------------------------------------------------------------------------
+class PredictedPremiumBandResponse(BaseModel):
+    min_inr: int
+    median_inr: int
+    max_inr: int
+    sample_size: int
+    assumed: bool
+
+
+@app.get(
+    "/api/profile/predicted-premium-band",
+    response_model=PredictedPremiumBandResponse,
+)
+async def predicted_premium_band(session_id: Optional[str] = None):
+    """Return the user's estimated premium band aggregated across a
+    representative basket of marketplace policies. Mirrors the slot-shape
+    used by /api/profile/completeness so the chip and the bar share triggers.
+    """
+    from backend.premium_calculator import estimate_premium_band
+    from backend.session_state import get_session
+
+    if not session_id:
+        return PredictedPremiumBandResponse(
+            min_inr=0, median_inr=0, max_inr=0, sample_size=0, assumed=True,
+        )
+
+    sess = get_session(session_id)
+    p = sess.profile
+    profile_dict = {
+        "name": p.name,
+        "age": p.age,
+        "dependents": p.dependents,
+        "income_band": p.income_band,
+        "existing_cover_inr": p.existing_cover_inr,
+        "primary_goal": p.primary_goal,
+        "location_tier": p.location_tier,
+        "parents_to_insure": p.parents_to_insure,
+        "parents_age_max": p.parents_age_max,
+        "parents_has_ped": p.parents_has_ped,
+        "health_conditions": p.health_conditions,
+        "budget_band": p.budget_band,
+    }
+    # Same answered-only gate as profile_completeness_view (KI-196 / ADR-041) —
+    # only feed slots the user has actually answered, not pre-populated
+    # defaults. Keeps the band stable until the user has actually said
+    # something meaningful.
+    answered = set(getattr(p, "asked", []) or [])
+    filtered_profile = {
+        k: (v if k in answered else None) for k, v in profile_dict.items()
+    }
+    band = estimate_premium_band(filtered_profile)
+    return PredictedPremiumBandResponse(**band)
+
+
+# ---------------------------------------------------------------------------
+# KI-Z7 (2026-05-15) — Feature B. POST /api/profile/recall-by-name.
+#
+# The chat hot path runs the same recall heuristic server-side inside
+# single_brain.handle_turn (turn-1 name sniff + try_recall_by_name) and
+# stamps `returning_user_recalled` on the ChatResponse, so the frontend
+# usually doesn't need this endpoint. It exists as an explicit, idempotent
+# escape hatch — e.g. the user types their name into the profile builder
+# AFTER turn 1 and we want to load their stored facts without sending a
+# chat turn. The hydration is server-side: the in-memory session_state for
+# `session_id` is mutated in place, so the next /api/chat turn already sees
+# the recalled slots.
+# ---------------------------------------------------------------------------
+class RecallByNameRequest(BaseModel):
+    name: str = Field(..., description="User-provided name (display form OK).")
+    session_id: str = Field(..., description="Session id to hydrate on a hit.")
+
+
+class RecallByNameResponse(BaseModel):
+    found: bool
+    profile: Optional[dict] = None
+    predicted_band: Optional[dict] = None
+    session_id: str
+
+
+@app.post("/api/profile/recall-by-name", response_model=RecallByNameResponse)
+async def recall_profile_by_name(req: RecallByNameRequest):
+    """Hydrate `session_id` from the stored named-profile JSON (if any).
+
+    Returns `found=False` when the slug doesn't resolve to a stored file.
+    On a hit, the live in-memory session is populated and the response
+    carries the full union dict + predicted premium band so the UI can
+    render the welcome-back banner without a second roundtrip.
+    """
+    from backend.profile_persistence import recall_by_name_payload
+
+    payload = await recall_by_name_payload(req.name, req.session_id)
+    return RecallByNameResponse(**payload)
+
+
 # ---- Static frontend (served alongside /api on the same port for HF Spaces) ----
 # The Next.js frontend is statically exported during the Docker build to
 # /app/frontend/out. In local dev, this directory may not exist — we still

backend/needs_finder.py

@@ -40,6 +40,7 @@ class Profile:
     parents_age_max: Optional[int] = None  # if parents_to_insure
     parents_has_ped: Optional[bool] = None  # if parents_to_insure
     budget_band: Optional[str] = None  # "under_15k", "15k_30k", "30k_60k", "60k+"
+    desired_sum_insured_inr: Optional[int] = None  # SOFT pricing input (post-recap)
     health_conditions: Optional[list[str]] = field(default_factory=list)  # ["diabetes", "hypertension", ...]
     asked: list[str] = field(default_factory=list)  # question IDs / field names already asked
     free_form_session: bool = False  # True = user asks free questions, not driven by us

backend/premium_calculator.py

@@ -15,13 +15,33 @@ How it works:
          family_floater
   3. Return a band of (low, mid, high) — low/high are ±15% wings around the
      point estimate, reflecting underwriting variance.
+
+═══════════════════════════════════════════════════════════════════════════
+SLOT_UNION → pricing-influence map (B6, 2026-05-15)
+═══════════════════════════════════════════════════════════════════════════
+The full slot list lives in `backend/brain_tools.py::SLOT_UNION`. Slots
+that influence the per-policy premium estimate (in addition to age /
+location / family_size that B2 already handles):
+
+  health_conditions       → health_loading 1.0× / 1.2× / 1.4× / 1.5×
+  existing_cover_inr      → existing_cover_loading 1.0× / 0.95× / 0.85×
+  desired_sum_insured_inr → overrides default SI per-policy
+  parents_age_max         → parents_loading 1.0× / 1.4× / 1.8×
+                            (only when `dependents` mentions "parents")
+  parents_has_ped         → adds +0.10× on top of parents_loading
+
+Slots that are profile-only (no pricing effect): name, primary_goal,
+income_band, budget_band (matched against output, not folded into the
+multiplicative chain). budget_band is a band-MATCH input downstream
+(e.g. scorecard fit), not a premium-direction input.
+═══════════════════════════════════════════════════════════════════════════
 """
 
 from __future__ import annotations
 
 import bisect
 import json
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
@@ -73,6 +93,102 @@ FALLBACK_PED = {
     "multiple": 1.55,
 }
 
+# ───────────────────────────────────────────────────────────────────────────
+# B6 loadings — profile-driven multipliers consumed by BOTH estimate() and
+# bulk_estimate() so the per-policy point estimate and the slider widget
+# agree by construction.
+# ───────────────────────────────────────────────────────────────────────────
+
+# Health condition loading — applied multiplicatively after PED loading.
+# Source band: PolicyBazaar PED articles + Acko underwriting guides.
+#   • diabetes / BP (hypertension)        → 1.20×
+#   • heart / cancer (severe chronic)     → 1.40×
+#   • 2+ chronic conditions (compounded)  → 1.50× (overrides the above)
+_HEALTH_DIABETES_BP = {"diabetes", "bp", "hypertension", "high bp", "hi-bp", "high-bp"}
+_HEALTH_SEVERE = {"heart", "heart disease", "cardiac", "cancer", "stroke"}
+
+
+def _health_loading(health_conditions) -> tuple[float, str]:
+    """Return (multiplier, label) for a health_conditions list.
+
+    Accepts list[str] (canonical), comma-joined string, or None. The empty
+    list and the sentinel ["none"] both map to 1.0×. Real conditions are
+    matched against the diabetes/BP and severe buckets case-insensitively.
+    """
+    if not health_conditions:
+        return 1.0, "no_conditions"
+    if isinstance(health_conditions, str):
+        items = [t.strip().lower() for t in health_conditions.split(",") if t.strip()]
+    else:
+        items = [str(t).strip().lower() for t in health_conditions if str(t).strip()]
+    # Strip the explicit-negation sentinel.
+    items = [t for t in items if t != "none"]
+    if not items:
+        return 1.0, "no_conditions"
+    has_diabetes_bp = any(t in _HEALTH_DIABETES_BP for t in items)
+    has_severe = any(any(s in t for s in _HEALTH_SEVERE) for t in items)
+    # 2+ chronic conditions → highest multiplier (overrides the others).
+    if len(items) >= 2:
+        return 1.50, "two_plus_chronic"
+    if has_severe:
+        return 1.40, "severe_chronic"
+    if has_diabetes_bp:
+        return 1.20, "diabetes_or_bp"
+    # Unrecognised single condition — treat as mild loading.
+    return 1.10, "other_single"
+
+
+def _existing_cover_loading(existing_cover_inr) -> tuple[float, str]:
+    """Return (multiplier, label) for existing_cover_inr.
+
+    Rationale: if the user already has cover, a top-up policy is cheaper
+    than a full base policy (insurer collects less risk + can price for the
+    cover gap only). Thresholds: <₹5L = mild discount (corporate top-up),
+    ≥₹5L = larger discount (only super-top-up needed).
+    """
+    try:
+        ec = int(existing_cover_inr or 0)
+    except (TypeError, ValueError):
+        ec = 0
+    if ec <= 0:
+        return 1.0, "no_existing_cover"
+    if ec < 500_000:
+        return 0.95, "corporate_topup"
+    return 0.85, "significant_existing_cover"
+
+
+def _parents_loading(dependents, parents_age_max, parents_has_ped=None) -> tuple[float, str]:
+    """Return (multiplier, label) for parents-on-cover scenarios.
+
+    Only fires when `dependents` mentions "parent" (case-insensitive). The
+    multiplier is age-banded:
+      • <60         → 1.0× (parents counted in family loading already)
+      • 60–70       → 1.40×
+      • 70+         → 1.80×
+    `parents_has_ped=True` adds a flat +0.10× on top (PED loading inflated
+    for the older age cohort).
+    """
+    has_parents = False
+    if dependents:
+        has_parents = "parent" in str(dependents).lower()
+    if not has_parents or parents_age_max in (None, "", 0):
+        return 1.0, "no_parents_on_cover"
+    try:
+        age = int(parents_age_max)
+    except (TypeError, ValueError):
+        return 1.0, "no_parents_on_cover"
+    if age < 60:
+        base, label = 1.0, "parents_under_60"
+    elif age <= 70:
+        base, label = 1.40, "parents_60_70"
+    else:
+        base, label = 1.80, "parents_70_plus"
+    if parents_has_ped is True and base > 1.0:
+        base += 0.10
+        label = f"{label}_with_ped"
+    return base, label
+
+
 # Co-pay reduces premium. Industry norm (PolicyBazaar/Acko): each 10 pct
 # points of co-pay yields ~7% premium reduction, capped at 40% co-pay.
 def _copay_multiplier(pct: float) -> float:
@@ -133,6 +249,13 @@ def estimate(
     policy_id: Optional[str] = None,
     pre_existing_conditions: str = "none",
     copayment_pct: float = 0.0,
+    # B6 additions — SLOT_UNION pricing inputs. All optional so legacy
+    # callers (B2's bulk_estimate, tests) keep working unchanged.
+    health_conditions: Optional[list] = None,
+    existing_cover_inr: Optional[int] = None,
+    dependents: Optional[str] = None,
+    parents_age_max: Optional[int] = None,
+    parents_has_ped: Optional[bool] = None,
 ) -> PremiumEstimate:
     data = _load_data()
     base_premiums = data.get("base_premiums", {})
@@ -183,6 +306,18 @@ def estimate(
     # Co-pay discount — opting into co-payment lowers premium
     base *= _copay_multiplier(copayment_pct)
 
+    # B6 loadings — health, existing cover, parents-on-cover. Each is
+    # 1.0× when the corresponding SLOT_UNION field is absent so legacy
+    # callers see no change in output.
+    health_mult, health_label = _health_loading(health_conditions)
+    base *= health_mult
+    ec_mult, ec_label = _existing_cover_loading(existing_cover_inr)
+    base *= ec_mult
+    parents_mult, parents_label = _parents_loading(
+        dependents, parents_age_max, parents_has_ped
+    )
+    base *= parents_mult
+
     point = int(round(base / 100) * 100)  # round to nearest ₹100
     return PremiumEstimate(
         policy_id=policy_id or "generic",
@@ -196,3 +331,404 @@ def estimate(
         ),
         sources=sources or [],
     )
+
+
+# ---------------------------------------------------------------------------
+# Bulk / slider widget heuristic — used by /api/premium/bulk so the
+# PolicyCompareModal premium widget can render fast estimates for several
+# policies at once. Same shape per policy: a transparent multiplicative
+# breakdown the UI can render as bullets.
+#
+# This is intentionally simpler than estimate(): a fixed ₹500 per ₹1L SI per
+# year base × age × location × family × deductible × tenure. When the curated
+# illustrative_premiums.json HAS a real sample for a policy we anchor the base
+# to it (assumed=False); otherwise we use the flat base rate (assumed=True)
+# and the UI labels the value "Estimate".
+# ---------------------------------------------------------------------------
+
+# ₹500 per ₹1L SI per year — typical Indian retail health entry-tier base.
+BULK_BASE_INR_PER_LAKH = 500
+
+BULK_AGE_BANDS = [
+    (30, 1.0),    # 18–30
+    (45, 1.5),    # 30–45
+    (60, 2.5),    # 45–60
+    (200, 4.0),   # 60+
+]
+
+BULK_LOCATION_LOADING = {
+    "metro": 1.2,
+    "tier1": 1.0,
+    "tier-1": 1.0,
+    "tier_1": 1.0,
+    "tier2": 1.0,
+    "tier-2": 1.0,
+    "tier_2": 1.0,
+    "tier3": 0.85,
+    "tier-3": 0.85,
+    "tier_3": 0.85,
+}
+
+# Family-floater uplift over individual (1.6× family floater per spec).
+BULK_FAMILY_FLOATER_MULT = 1.6
+
+# Deductible discount — higher voluntary deductible lowers the premium.
+# Linear approximation; sources: PolicyBazaar deductible guides.
+BULK_DEDUCTIBLE_DISCOUNT = {
+    0: 1.0,
+    25000: 0.92,
+    50000: 0.85,
+    100000: 0.75,
+}
+
+# Tenure loading — multi-year policies typically get a 5–10% per-year discount.
+BULK_TENURE_MULT = {
+    1: 1.0,
+    2: 0.95,
+    3: 0.90,
+}
+
+
+def _bulk_age_mult(age: int) -> tuple[float, str]:
+    for ceiling, mult in BULK_AGE_BANDS:
+        if age < ceiling:
+            band = (
+                "18-30" if ceiling == 30 else
+                "30-45" if ceiling == 45 else
+                "45-60" if ceiling == 60 else
+                "60+"
+            )
+            return mult, band
+    return 4.0, "60+"
+
+
+def _bulk_location_mult(tier: Optional[str]) -> tuple[float, str]:
+    key = (tier or "metro").lower().strip()
+    return BULK_LOCATION_LOADING.get(key, 1.0), key
+
+
+def _bulk_family_size_from_dependents(dependents: Optional[str], family_size: Optional[int]) -> int:
+    """Coerce the profile's free-text `dependents` string OR explicit
+    family_size into an integer headcount (self + dependents)."""
+    if isinstance(family_size, int) and family_size > 0:
+        return family_size
+    if not dependents:
+        return 1
+    s = str(dependents).lower()
+    # Count keyword hits + digit-prefixed counts (e.g. "2 kids", "1 child").
+    import re as _re
+    headcount = 1  # self
+    has_spouse = any(k in s for k in ("spouse", "wife", "husband", "partner"))
+    if has_spouse:
+        headcount += 1
+    # Children: try "N kid(s)/child/children" first, else any "kid/child" keyword = +1
+    kid_match = _re.search(r"(\d+)\s*(kid|child|son|daughter)", s)
+    if kid_match:
+        headcount += max(1, int(kid_match.group(1)))
+    elif any(k in s for k in ("kid", "child", "son", "daughter")):
+        headcount += 1
+    # Parents — explicit "parent(s)" keyword adds +1 each on a single mention.
+    if "parent" in s:
+        headcount += 1
+    # Family-of-N pattern: "family of 4"
+    fof = _re.search(r"family\s+of\s+(\d+)", s)
+    if fof:
+        headcount = max(headcount, int(fof.group(1)))
+    # Bare integer at sentence start ("3 dependents") — only honour if no keywords matched
+    if headcount == 1 and not has_spouse:
+        m = _re.search(r"(\d+)", s)
+        if m:
+            try:
+                headcount = max(1, int(m.group(1)))
+            except ValueError:
+                pass
+    return max(1, headcount)
+
+
+def _round_inr(x: float) -> int:
+    return int(round(x / 10) * 10)
+
+
+@dataclass
+class BulkPolicyPremium:
+    policy_id: str
+    premium_inr_annual: int
+    breakdown: dict
+    sum_insured_inr: int
+    tenure_years: int
+    deductible_inr: int
+    assumed: bool
+    notes: list[str] = field(default_factory=list)
+
+
+def bulk_estimate(
+    policy_ids: list[str],
+    profile: Optional[dict] = None,
+    overrides: Optional[dict] = None,
+) -> dict[str, BulkPolicyPremium]:
+    """Compute heuristic per-policy premiums for the widget.
+
+    profile keys (all optional): age, dependents, location_tier, family_size,
+    smoker, pre_existing_conditions.
+    overrides[policy_id]: sum_insured_inr / tenure_years / deductible_inr.
+    """
+    profile = profile or {}
+    overrides = overrides or {}
+
+    age = int(profile.get("age") or 35)
+    location_tier = profile.get("location_tier") or "metro"
+    family_size = _bulk_family_size_from_dependents(
+        profile.get("dependents"), profile.get("family_size")
+    )
+
+    # B6 SLOT_UNION pricing inputs — read from the same profile dict so the
+    # bulk widget and the per-policy estimate() agree by construction.
+    health_conditions = profile.get("health_conditions")
+    existing_cover_inr = profile.get("existing_cover_inr")
+    dependents = profile.get("dependents")
+    parents_age_max = profile.get("parents_age_max")
+    parents_has_ped = profile.get("parents_has_ped")
+    # desired_sum_insured_inr — when present, becomes the default SI for
+    # any policy without an explicit overrides entry (per-policy override
+    # still wins, since this is the DEFAULT).
+    desired_si = profile.get("desired_sum_insured_inr")
+
+    data = _load_data()
+    base_premiums_curated = data.get("base_premiums", {})
+
+    age_mult, age_band = _bulk_age_mult(age)
+    loc_mult, loc_label = _bulk_location_mult(location_tier)
+    family_mult = BULK_FAMILY_FLOATER_MULT if family_size >= 2 else 1.0
+    health_mult, health_label = _health_loading(health_conditions)
+    ec_mult, ec_label = _existing_cover_loading(existing_cover_inr)
+    parents_mult, parents_label = _parents_loading(
+        dependents, parents_age_max, parents_has_ped
+    )
+
+    out: dict[str, BulkPolicyPremium] = {}
+    for pid in policy_ids:
+        ov = overrides.get(pid) or {}
+        # Override precedence: per-policy override > desired_sum_insured_inr
+        # from profile > ₹10L hard default. This is how
+        # desired_sum_insured_inr propagates through the widget.
+        sum_insured_inr = int(
+            ov.get("sum_insured_inr") or desired_si or 1_000_000
+        )
+        tenure_years = int(ov.get("tenure_years") or 1)
+        if tenure_years not in BULK_TENURE_MULT:
+            tenure_years = 1
+        deductible_inr = int(ov.get("deductible_inr") or 0)
+        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))
+
+        notes: list[str] = []
+        assumed = True
+
+        # Anchor base to curated sample if we have one, else flat per-lakh rate.
+        anchored_base: Optional[int] = None
+        if pid in base_premiums_curated:
+            try:
+                ce = estimate(
+                    age=age,
+                    sum_insured_inr=sum_insured_inr,
+                    city_tier="metro" if loc_label == "metro" else ("tier1" if "1" in loc_label else "tier2"),
+                    smoker=bool(profile.get("smoker", False)),
+                    family_size=max(0, family_size - 1),
+                    policy_id=pid,
+                    pre_existing_conditions=profile.get("pre_existing_conditions") or "none",
+                    copayment_pct=0.0,
+                    # B6 — pass SLOT_UNION pricing inputs through so the
+                    # curated path absorbs health/existing-cover/parents
+                    # loadings inside estimate(). We then mark these as
+                    # 1.0× in the breakdown to avoid double-counting.
+                    health_conditions=health_conditions,
+                    existing_cover_inr=existing_cover_inr,
+                    dependents=dependents,
+                    parents_age_max=parents_age_max,
+                    parents_has_ped=parents_has_ped,
+                )
+                # estimate() already folded age/location/family AND the B6
+                # loadings — unwind so the widget can display the same
+                # multiplicative bullets uniformly.
+                anchored_base = ce.point_estimate_inr
+                assumed = False
+                notes.append("Anchored to curated public-quote sample.")
+            except Exception:
+                anchored_base = None
+
+        si_lakhs = max(1, sum_insured_inr // 100_000)
+        flat_base = BULK_BASE_INR_PER_LAKH * si_lakhs
+
+        if anchored_base is not None:
+            # Apply tenure + deductible only — the curated path already
+            # absorbed age/location/family + B6 loadings inside estimate().
+            tenure_mult = BULK_TENURE_MULT.get(tenure_years, 1.0)
+            ded_mult = BULK_DEDUCTIBLE_DISCOUNT.get(deductible_inr, 1.0)
+            final = anchored_base * tenure_mult * ded_mult
+            breakdown = {
+                "base_inr": int(anchored_base),
+                "age_loading_x": 1.0,
+                "location_loading_x": 1.0,
+                "family_loading_x": 1.0,
+                "tenure_discount_x": round(tenure_mult, 3),
+                "deductible_discount_x": round(ded_mult, 3),
+            }
+        else:
+            tenure_mult = BULK_TENURE_MULT.get(tenure_years, 1.0)
+            ded_mult = BULK_DEDUCTIBLE_DISCOUNT.get(deductible_inr, 1.0)
+            final = (
+                flat_base
+                * age_mult
+                * loc_mult
+                * family_mult
+                * health_mult
+                * ec_mult
+                * parents_mult
+                * tenure_mult
+                * ded_mult
+            )
+            breakdown = {
+                "base_inr": int(flat_base),
+                "age_loading_x": round(age_mult, 3),
+                "age_band": age_band,
+                "location_loading_x": round(loc_mult, 3),
+                "location_tier": loc_label,
+                "family_loading_x": round(family_mult, 3),
+                "family_size": family_size,
+                "tenure_discount_x": round(tenure_mult, 3),
+                "deductible_discount_x": round(ded_mult, 3),
+            }
+            notes.append(
+                "Heuristic estimate — no exact actuarial data for this policy. "
+                "Base ₹500 per ₹1L SI per year × age × location × family × tenure × deductible."
+            )
+
+        # B6 — surface non-1.0× SLOT_UNION loadings in the breakdown
+        # regardless of which branch produced the base. UI can render
+        # "Diabetes/BP loading × 1.20" bullets when the user has the
+        # corresponding profile slot captured.
+        if health_mult != 1.0:
+            breakdown["health_loading_x"] = round(health_mult, 3)
+            breakdown["health_loading_reason"] = health_label
+        if ec_mult != 1.0:
+            breakdown["existing_cover_loading_x"] = round(ec_mult, 3)
+            breakdown["existing_cover_loading_reason"] = ec_label
+        if parents_mult != 1.0:
+            breakdown["parents_loading_x"] = round(parents_mult, 3)
+            breakdown["parents_loading_reason"] = parents_label
+        if desired_si and not ov.get("sum_insured_inr"):
+            breakdown["desired_si_default_inr"] = int(desired_si)
+
+        out[pid] = BulkPolicyPremium(
+            policy_id=pid,
+            premium_inr_annual=_round_inr(final),
+            breakdown=breakdown,
+            sum_insured_inr=sum_insured_inr,
+            tenure_years=tenure_years,
+            deductible_inr=deductible_inr,
+            assumed=assumed,
+            notes=notes,
+        )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Profile-level premium BAND — used by the chat-UI "Est. premium ₹X–₹Y/yr"
+# chip that sits next to the profile-completeness pill. Aggregates the bulk
+# heuristic across a representative basket of marketplace policies so the
+# user sees what their personal premium envelope looks like as the profile
+# fills in (reactively updates with each completeness change).
+# ---------------------------------------------------------------------------
+
+# Representative basket for the band — 26 curated marketplace policies that
+# span every major insurer + product tier. Mirrors keys in
+# 40-data/premiums/illustrative_premiums.json so anchored samples are used
+# where available and the flat per-lakh fallback fills the rest.
+_DEFAULT_BAND_POLICY_IDS: list[str] = [
+    "hdfc-ergo__optima-secure",
+    "hdfc-ergo__optima-restore",
+    "hdfc-ergo__optima-plus",
+    "hdfc-ergo__energy",
+    "care-health__care-supreme",
+    "care-health__care-classic",
+    "care-health__care-senior",
+    "care-health__care-advantage",
+    "aditya-birla__activ-assure-diamond",
+    "aditya-birla__group-activ-health",
+    "bajaj-allianz__health-guard",
+    "bajaj-allianz__silver-health",
+    "bajaj-allianz__tax-gain",
+    "icici-lombard__elevate",
+    "icici-lombard__health-advantedge",
+    "niva-bupa__reassure",
+    "niva-bupa__health-premia",
+    "niva-bupa__aspire",
+    "new-india__asha-kiran",
+    "new-india__mediclaim",
+    "tata-aig__medicare",
+    "tata-aig__medicare-premier",
+    "manipalcigna__prohealth-prime-active",
+    "star-health__family-health-optima",
+    "star-health__comprehensive",
+    "star-health__senior-citizens-red-carpet",
+]
+
+
+def _round_to_500(x: float) -> int:
+    """Round to nearest ₹500 — band-display granularity (per spec)."""
+    return int(round(float(x) / 500.0) * 500)
+
+
+def _median(xs: list[int]) -> int:
+    n = len(xs)
+    if n == 0:
+        return 0
+    s = sorted(xs)
+    mid = n // 2
+    if n % 2 == 1:
+        return int(s[mid])
+    return int((s[mid - 1] + s[mid]) / 2)
+
+
+def estimate_premium_band(
+    profile: Optional[dict] = None,
+    candidate_policy_ids: Optional[list[str]] = None,
+    sum_insured_default: int = 1_000_000,
+) -> dict:
+    """Compute the user's predicted-premium BAND across a representative basket.
+
+    Returns: {min_inr, median_inr, max_inr, sample_size, assumed}. Rounded
+    to the nearest ₹500. `assumed` is True whenever ANY policy in the basket
+    used the heuristic fallback (which is effectively always for now).
+    """
+    profile = profile or {}
+    pids = candidate_policy_ids or list(_DEFAULT_BAND_POLICY_IDS)
+
+    # Reuse B2's bulk heuristic so the chip and the slider widget agree by
+    # construction. Default to ₹10L SI per policy unless the caller overrides.
+    overrides = {pid: {"sum_insured_inr": sum_insured_default} for pid in pids}
+    try:
+        rows = bulk_estimate(policy_ids=pids, profile=profile, overrides=overrides)
+    except Exception:
+        rows = {}
+
+    premiums = [int(r.premium_inr_annual) for r in rows.values() if r.premium_inr_annual]
+    any_assumed = any(r.assumed for r in rows.values()) if rows else True
+
+    if not premiums:
+        return {
+            "min_inr": 0,
+            "median_inr": 0,
+            "max_inr": 0,
+            "sample_size": 0,
+            "assumed": True,
+        }
+
+    return {
+        "min_inr": _round_to_500(min(premiums)),
+        "median_inr": _round_to_500(_median(premiums)),
+        "max_inr": _round_to_500(max(premiums)),
+        "sample_size": len(premiums),
+        "assumed": bool(any_assumed),
+    }

backend/profile_persistence.py

@@ -0,0 +1,312 @@
+"""Post-turn auto-persistence + returning-user recall helpers.
+
+Coupled features (KI-Z7, 2026-05-15):
+
+  Feature A — auto_persist_session(session)
+    Called from /api/chat AFTER single_brain.handle_turn returns and BEFORE
+    the ChatResponse is built. Reads the union of all 13 slot_union fields
+    from session.profile and pushes them to:
+      - profile_store.save_profile(...)      — canonical JSON on disk
+      - profile_rag.upsert_profile_chunk(...) — Chroma vector chunk
+    Gated on session.profile.name being non-empty (anonymous turns never
+    persist — KI-118).
+
+    Wrapped in try/except internally; persistence failure NEVER raises and
+    NEVER affects the reply path.
+
+  Feature B — extract_potential_name(text)
+    Cheap regex heuristic that recovers a first name from a turn-1 user
+    utterance ("Hi I'm Priya", "My name is Rajesh", "Anjali here"). Returns
+    None when no clear name is present (e.g. "I'm 34 years old"). Used by
+    single_brain.handle_turn so a returning user is recognised BEFORE
+    Gemini's first tool-call iteration.
+
+  Feature B — try_recall_by_name(session, name)
+    Loads the named profile JSON via profile_store.load_profile and hydrates
+    every empty slot on session.profile. Returns True on a successful merge
+    so single_brain can stamp `is_returning_user=True` for the RULE 4
+    "welcome back" greeting.
+
+  Feature B — recall_by_name_payload(name, session_id)
+    Builds the response payload for the POST /api/profile/recall-by-name
+    endpoint: {found, profile, predicted_band, session_id}. predicted_band
+    is computed via premium_calculator.estimate_premium_band against the
+    just-hydrated profile.
+
+Design notes:
+  - This module sits between profile_store + profile_rag and is the SINGLE
+    write path the /api/chat hot loop reaches; brain_tools.save_profile_field
+    still only mutates the in-memory Profile (B6 owns that file).
+  - No async required for the JSON write; profile_rag.upsert_profile_chunk
+    is async (embedder), so auto_persist_session is async too.
+  - All callers MUST await it and swallow exceptions defensively. We do the
+    defensive swallow internally as belt-and-suspenders so callers can
+    simply `await auto_persist_session(session)` without try/except.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Optional
+
+_log = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Feature A — post-turn persistence
+# ---------------------------------------------------------------------------
+
+
+# The 13 fields that make up the "slot_union" — what we persist on every
+# auto_persist_session call. Kept in sync with the schemas in
+# needs_finder.Profile and brain_tools.save_profile_field's accepted fields.
+_UNION_FIELDS: tuple[str, ...] = (
+    "name",
+    "age",
+    "dependents",
+    "income_band",
+    "existing_cover_inr",
+    "primary_goal",
+    "location_tier",
+    "parents_to_insure",
+    "parents_age_max",
+    "parents_has_ped",
+    "health_conditions",
+    "budget_band",
+    "desired_sum_insured_inr",
+)
+
+
+def _build_union_dict(profile) -> dict[str, Any]:
+    """Build the persistence payload — dict of all 13 union fields."""
+    return {f: getattr(profile, f, None) for f in _UNION_FIELDS}
+
+
+async def auto_persist_session(session) -> bool:
+    """Persist the live session profile to disk + Chroma.
+
+    No-op (returns False) when:
+      - session is None
+      - session.profile.name is empty / None
+      - either underlying write raises (logged, then swallowed)
+
+    Returns True iff BOTH save_profile() AND upsert_profile_chunk() ran
+    without raising. Persistence failure NEVER bubbles out — the chat
+    reply must not be blocked by a stuck disk or a Chroma hiccup.
+    """
+    if session is None:
+        return False
+    profile = getattr(session, "profile", None)
+    if profile is None:
+        return False
+    name = (getattr(profile, "name", None) or "").strip()
+    if not name:
+        # Anonymous turn — never write to disk, never embed (KI-118).
+        return False
+
+    union = _build_union_dict(profile)
+    saved_json = False
+    saved_chunk = False
+
+    # 1) Canonical JSON on disk.
+    try:
+        from backend.profile_store import save_profile
+
+        saved_json = save_profile(
+            name,
+            profile,
+            session_id=getattr(session, "session_id", None),
+        )
+    except Exception as e:  # noqa: BLE001
+        _log.warning(
+            "auto_persist_session: save_profile failed (name=%r): %s: %s",
+            name, type(e).__name__, str(e)[:200],
+        )
+
+    # 2) Vector chunk (gated on a derivable name_slug — same gate as the
+    #    POST /api/profile path).
+    try:
+        from backend.profile_store import _normalise_name
+        from backend.profile_rag import upsert_profile_chunk
+
+        name_slug = _normalise_name(name)
+        if name_slug:
+            await upsert_profile_chunk(name_slug, union)
+            saved_chunk = True
+    except Exception as e:  # noqa: BLE001
+        _log.warning(
+            "auto_persist_session: upsert_profile_chunk failed (name=%r): %s: %s",
+            name, type(e).__name__, str(e)[:200],
+        )
+
+    return saved_json and saved_chunk
+
+
+# ---------------------------------------------------------------------------
+# Feature B — turn-1 name heuristic + returning-user recall
+# ---------------------------------------------------------------------------
+
+
+# Match an explicit self-introduction. Three forms cover the common cases:
+#   1. "I'm <name>" / "I am <name>"
+#   2. "My name is <name>" / "this is <name>"
+#   3. "<name> here"
+# We deliberately require a verb-ish anchor — bare "Priya." with no
+# surrounding context is too noisy on turn 1 (it could be a question subject)
+# and the existing brain_tools.save_profile_field path will pick it up
+# safely if the user repeats it.
+_NAME_RE = re.compile(
+    r"""
+    (?:
+        \b(?:i\s*am|i'?m|my\s+name\s+is|this\s+is|name'?s)\s+
+        (?P<n1>[A-Z][a-zA-Z]{1,30}(?:\s+[A-Z][a-zA-Z]{1,30})?)
+        \b
+      |
+        ^\s*(?P<n2>[A-Z][a-zA-Z]{1,30}(?:\s+[A-Z][a-zA-Z]{1,30})?)\s+here\b
+    )
+    """,
+    re.VERBOSE | re.IGNORECASE,
+)
+
+# Words that look name-like to the regex (capitalised at sentence start)
+# but are NOT names. Filter post-match so "I'm 34" and "I am okay" never
+# resolve to "okay" / "34" as a name.
+_NAME_STOPWORDS: set[str] = {
+    "ok", "okay", "fine", "good", "great", "well", "yes", "no", "yeah",
+    "nope", "sure", "looking", "trying", "thinking", "interested",
+    "here", "back", "ready", "done", "free", "busy", "tired", "young",
+    "old", "married", "single", "alone", "happy", "sad",
+    "from", "in", "at", "on", "with", "for", "to",
+    "the", "a", "an",
+    # Time + age
+    "twenty", "thirty", "forty", "fifty", "sixty",
+}
+
+
+def extract_potential_name(text: str) -> Optional[str]:
+    """Return a probable first-name capture from a turn-1 user utterance.
+
+    Examples:
+        "Hi I'm Priya"            -> "Priya"
+        "Hello, my name is Rajesh" -> "Rajesh"
+        "Anjali here"             -> "Anjali"
+        "I'm 34 years old"        -> None
+        "I am okay, thanks"       -> None
+        ""                        -> None
+
+    Caller should slug + try_recall_by_name; no DB or LLM cost.
+    """
+    if not text or not text.strip():
+        return None
+    # Normalize whitespace, keep original casing for the regex.
+    s = text.strip()
+    m = _NAME_RE.search(s)
+    if not m:
+        return None
+    raw = (m.group("n1") or m.group("n2") or "").strip()
+    if not raw:
+        return None
+    # Reject digit-laden captures ("I'm 34") and stop-words ("I'm okay").
+    first_token = raw.split()[0]
+    if first_token.lower() in _NAME_STOPWORDS:
+        return None
+    if not first_token.isalpha():
+        return None
+    if len(first_token) < 2:
+        return None
+    return raw
+
+
+def try_recall_by_name(session, name: str) -> bool:
+    """Look up a stored profile by name and hydrate `session.profile`.
+
+    Wraps session_state.rehydrate_by_name so the call-site (single_brain
+    handle_turn entry) doesn't need to know which helper is canonical.
+
+    Returns True iff a stored profile was found AND at least one slot was
+    merged into the live session. False on no-match or any error.
+    """
+    if not name or not name.strip():
+        return False
+    try:
+        from backend.session_state import rehydrate_by_name
+
+        return bool(rehydrate_by_name(session, name))
+    except Exception as e:  # noqa: BLE001
+        _log.warning(
+            "try_recall_by_name failed (name=%r): %s: %s",
+            name, type(e).__name__, str(e)[:200],
+        )
+        return False
+
+
+async def recall_by_name_payload(
+    name: str,
+    session_id: str,
+) -> dict[str, Any]:
+    """Build the response payload for POST /api/profile/recall-by-name.
+
+    Returns:
+        {
+          "found": bool,
+          "profile": dict | None,         # the hydrated union dict
+          "predicted_band": dict | None,  # {min_inr, median_inr, max_inr, ...}
+          "session_id": str,
+        }
+
+    Side effect: when a match is found, the live in-memory session for
+    `session_id` is hydrated (so the next /api/chat turn sees the recalled
+    slots in session.profile WITHOUT requiring a separate /api/profile POST).
+    """
+    out: dict[str, Any] = {
+        "found": False,
+        "profile": None,
+        "predicted_band": None,
+        "session_id": session_id,
+    }
+    if not name or not name.strip() or not session_id:
+        return out
+
+    try:
+        from backend.session_state import get_session
+
+        sess = get_session(session_id)
+    except Exception as e:  # noqa: BLE001
+        _log.warning(
+            "recall_by_name_payload: get_session failed (session_id=%r): %s: %s",
+            session_id, type(e).__name__, str(e)[:200],
+        )
+        return out
+
+    found = try_recall_by_name(sess, name)
+    if not found:
+        return out
+
+    # Build the union dict snapshot post-hydration.
+    union = _build_union_dict(sess.profile)
+    out["found"] = True
+    out["profile"] = union
+
+    # Predicted-premium band — same path /api/profile/predicted-premium-band
+    # uses, so the banner number matches the chip number exactly.
+    try:
+        from backend.premium_calculator import estimate_premium_band
+
+        out["predicted_band"] = estimate_premium_band(union)
+    except Exception as e:  # noqa: BLE001
+        _log.warning(
+            "recall_by_name_payload: estimate_premium_band failed (name=%r): %s: %s",
+            name, type(e).__name__, str(e)[:200],
+        )
+        out["predicted_band"] = None
+
+    return out
+
+
+__all__ = [
+    "auto_persist_session",
+    "extract_potential_name",
+    "try_recall_by_name",
+    "recall_by_name_payload",
+]

backend/scorecard.py

@@ -488,17 +488,33 @@ def _profile_tuned_weights(profile: Optional[dict]) -> dict[str, float]:
             w["Waiting-Period Friction"] -= 0.04
 
     # ---- DEPENDENTS ----
+    # Family signals push two specific dials per task spec:
+    #   maternity coverage  -> sits inside Coverage Breadth
+    #   room-rent capping   -> sits inside Cost Predictability
+    # Both go UP when a spouse / kid is on the policy because multi-occupant
+    # families absorb sub-limit pain harder than singles.
+    #
+    # We DON'T let dependents pull Renewal Protection or Claim Experience
+    # downward when the buyer is already in the senior bracket — for a 55+
+    # buyer with a family, both renewal lock-in and claim reliability matter
+    # MORE, not less. Earlier versions had the family penalty silently cancel
+    # the age boost, so senior+family ended up with renewal-weight BELOW
+    # default. Now the family discount applies only to younger buyers.
     deps = (profile.get("dependents") or "").lower()
+    is_senior = isinstance(age, int) and age >= 50
     if any(k in deps for k in ("kid", "child")):
         w["Coverage Breadth"] += 0.03              # paediatric + day-care + immunisation
-        w["Bonus & Loyalty"] += 0.01               # free checkups for family
-        w["Cost Predictability"] -= 0.02           # family floater premiums are higher
-        w["Renewal Protection"] -= 0.02
+        w["Cost Predictability"] += 0.02           # room-rent caps hurt families more
+        w["Bonus & Loyalty"] -= 0.03               # de-emphasise sweeteners
+        if not is_senior:
+            w["Renewal Protection"] -= 0.02
     if any(k in deps for k in ("spouse", "wife", "husband", "partner")):
-        w["Coverage Breadth"] += 0.02              # maternity becomes relevant
+        w["Coverage Breadth"] += 0.03              # maternity becomes relevant
+        w["Cost Predictability"] += 0.02           # room-rent cap matters when both hospitalise
         w["Waiting-Period Friction"] += 0.02       # maternity 36mo wait matters
-        w["Bonus & Loyalty"] -= 0.02
-        w["Renewal Protection"] -= 0.02
+        w["Bonus & Loyalty"] -= 0.04
+        if not is_senior:
+            w["Renewal Protection"] -= 0.03
 
     if profile.get("parents_to_insure") or "parent" in deps:
         w["Coverage Breadth"] += 0.04

backend/single_brain.py

@@ -82,9 +82,9 @@ YOUR JOB:
 
 REQUIRED slots before recommending: name, age, dependents, location_tier, income_band, primary_goal, health_conditions.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 ABSOLUTE RULE — NO POLICY NAMES WITHOUT RETRIEVE
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 NEVER mention a policy name, UIN, insurer, or product (Star Health,
 HDFC Ergo, Niva Bupa, Care, Aditya Birla, ICICI Lombard, Bajaj Allianz,
 Manipal Cigna, Acko, Go Digit, Max Bupa, Reliance General, SBI General,
@@ -102,9 +102,9 @@ If retrieve_policies returns nothing for that name, say "I couldn't find
 that policy in our index. Let me suggest some alternatives" and call
 retrieve_policies with a broader query based on the profile.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 RULE 1 (HIGHEST PRIORITY) — save_profile_field is MANDATORY
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 Every turn, BEFORE you write any prose reply, scan the user's last message for any
 of these facts and call save_profile_field ONCE PER FACT:
   • A name (proper noun) → save_profile_field(field="name", value="...")
@@ -145,33 +145,60 @@ Worked example B (negation — DO NOT SKIP). User says: "No medical issues"
 
 NEVER ask the user for a fact you can already extract from their last message. Capture FIRST, then ask only for what's missing.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 RULE 2 — retrieve_policies query MUST be profile-aware
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 Only call retrieve_policies AFTER all 7 required slots are saved AND the user has confirmed your recap.
 
-Build the query string from the profile snapshot. Required ingredients:
+Build the query string from the profile snapshot. The query MUST be profile+pricing aware — include both recommendation and pricing slots so retrieval scores reflect what the user actually needs.
+
+Required ingredients:
   family-shape (individual / family floater / parents-cover),
   city tier (metro / tier-2 / tier-3),
-  sum-insured band (~5-7× annual income, e.g. "10-15 lakh"),
-  age band (e.g. "adult 30-40"),
-  health-condition keywords (or "no PED"),
-  primary goal keyword.
+  sum-insured band — use `desired_sum_insured_inr` if captured (RULE 2.5), else derive ~5-7× annual income (e.g., "10-15 lakh"),
+  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",
+  parents-cover signal — when dependents mentions parents add "parents age ~XX" using parents_age_max (if captured).
+
+Worked example A (no PED, no existing cover). Profile = {age=34, location_tier=metro, income_band=10L-25L, dependents=spouse+1 kid, primary_goal=first_buy, health_conditions=["none"], desired_sum_insured_inr=1500000, existing_cover_inr=0}:
+  retrieve_policies(query="family floater plan metro sum insured 15 lakh adult 30-40 with spouse and one child no PED fresh base policy first-time buyer", top_k=8)
 
-Worked example. Profile = {age=34, location_tier=metro, income_band=10L-25L, dependents=spouse+1 kid, primary_goal=first_buy, health_conditions=[]}:
-  retrieve_policies(query="family floater plan metro sum insured 15-20 lakh adult 30-40 with spouse and one child no pre-existing diseases first-time buyer", top_k=8)
+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)
 
 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.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
+RULE 2.5 — Pricing inputs (SOFT capture, post-recap)
+═══════════════════════════════════
+After all 7 slots are saved AND the user has confirmed the recap (RULE 4 implicit confirmation or explicit yes), BEFORE you call retrieve_policies, ask — in ONE compact prompt:
+  "A few quick pricing inputs (you can skip any):
+   1. How much sum insured? (e.g., ₹5L / ₹10L / ₹25L / ₹1Cr)
+   2. Premium budget? (e.g., ₹10–15K/year, or ₹50K+ for premium covers)
+   3. Any existing health cover from work or otherwise? (e.g., '5L through employer' or 'no')  [SKIP if existing_cover_inr already captured]
+   4. Approximate age of the eldest parent you'd cover?  [ASK ONLY IF dependents mentions parents AND parents_age_max not yet captured]"
+
+When the user answers, call save_profile_field once per provided value:
+  save_profile_field(field="desired_sum_insured_inr", value="1000000")  # ₹10L
+  save_profile_field(field="budget_band",            value="10K-20K")
+  save_profile_field(field="existing_cover_inr",     value="500000")    # 5L corporate top-up; 'no' / 'none' → value="0"
+  save_profile_field(field="parents_age_max",        value="68")        # eldest parent's age, only if covering parents
+
+Gender hint: if the user mentions gender, keep it for conversational context only — Profile has no `gender` slot. Do NOT call save_profile_field(field="gender", ...) — it returns `field_not_on_profile_dataclass` and wastes a tool-call iteration.
+
+Then call retrieve_policies and INCLUDE the new inputs in the query (e.g., "...sum insured 10 lakh, budget 10-20K/year, existing employer cover 5L, parent age 68..."). If the user skips ("just show me options", "you decide"), proceed with retrieve_policies using profile defaults — DO NOT block. SOFT capture, not a hard gate.
+
+═══════════════════════════════════
 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.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 RULE 4 — Returning-user greeting (pre-populated profile)
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 If the KNOWN PROFILE block below is non-empty AT TURN 1 (no chat history,
 session.profile arrived pre-populated from a prior conversation), your FIRST
 reply MUST:
@@ -196,9 +223,9 @@ fields. Your flow on that turn:
 Explicit confirmation is only required when the user's reply is a literal
 "yes/no/that's right" with no new data. Bypass the WAIT in any other case.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 RULE 5 — Comparison view ("compare #1 and #3")
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 When the user asks to compare two or more shortlisted policies ("compare
 #1 and #3", "what's the difference between Plan A and Plan B",
 "#2 vs #4"):
@@ -211,9 +238,9 @@ When the user asks to compare two or more shortlisted policies ("compare
   3. Cite each cell with [Source: ..., UIN]. Do NOT just dump retrieved
      text — explicitly contrast.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 RULE 6 — Out-of-scope refusal (non-health products)
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 You ONLY advise on Indian health insurance. If the user asks about life
 insurance, term plans, ULIPs, car / motor / two-wheeler insurance, home
 insurance, travel insurance, mutual funds, or any non-health product,
@@ -223,9 +250,9 @@ politely refuse and redirect:
    coverage?"
 Do NOT call retrieve_policies for out-of-scope queries.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 RULE 7 — Soft close after the customer picks one
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 Once you have recommended AND the user has chosen a single policy ("I'll
 go with #2", "let's pick the HDFC one", "sounds good", "I'll take that",
 "let's do the first one", "sign me up", "buy this", "I want to purchase"):
@@ -246,25 +273,13 @@ go with #2", "let's pick the HDFC one", "sounds good", "I'll take that",
      you like me to walk through the purchase steps, or summarise the key
      benefits?"
 
-WORKED EXAMPLE
-  User: "I'll go with that one"
-  Your flow:
-    i.   IDENTIFY which policy "that one" refers to. With no ordinal cue,
-         default to the most recent recommendation =
-         session.last_recommendation_ids[0].
-    ii.  Call mark_recommendation(policy_ids=[chosen_id], is_final=true)
-         FIRST. This is non-negotiable — the recommendation MUST be
-         recorded for analytics before any prose is written.
-    iii. THEN write the prose reply offering next steps.
-  DO NOT skip step (ii). Offering "would you like purchase steps?" without
-  the mark_recommendation tool call is a RULE 7 violation.
-
-Do not re-pitch alternatives after the user has chosen — only act on
-their next instruction.
-
-═══════════════════════════════════════════════════════════
+DO NOT skip STEP 1. Offering "would you like purchase steps?" without
+the mark_recommendation tool call is a RULE 7 violation. Do not re-pitch
+alternatives after the user has chosen — only act on their next instruction.
+
+═══════════════════════════════════
 RULE 8 — Indic-language mirroring
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 If the user's last message is in an Indian language (Hindi, Marathi,
 Tamil, Telugu, Bengali, Kannada, Gujarati, Punjabi, Malayalam, etc.) or
 Hinglish (Latin-script Hindi), respond in the SAME language. Use the same
@@ -272,9 +287,9 @@ tools regardless of language — tool args (field names, policy queries)
 remain English; only your prose reply mirrors the user's language.
 Citations stay in the canonical [Source: ..., UIN] format.
 
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 GROUND RULES
-═══════════════════════════════════════════════════════════
+═══════════════════════════════════
 - NEVER invent policies, UINs, premiums, or sums insured. Only cite what retrieve_policies returns.
 - If retrieve_policies returns zero chunks after both attempts, ask the user one clarifying question.
 - Be concise: 2-3 sentence turns. No emoji unless the user used one first.
@@ -327,7 +342,8 @@ TOOL_SCHEMAS: list[dict] = [
             "Persist a captured profile field on the live session. Call once "
             "per field every time the user reveals something new (name, age, "
             "dependents, location_tier, income_band, primary_goal, "
-            "health_conditions, existing_cover_inr, budget_band, gender)."
+            "health_conditions, existing_cover_inr, budget_band, "
+            "desired_sum_insured_inr, gender)."
         ),
         "parameters": {
             "type": "OBJECT",
@@ -338,15 +354,16 @@ TOOL_SCHEMAS: list[dict] = [
                         "Field name. One of: name, age, dependents, "
                         "location_tier, income_band, primary_goal, "
                         "health_conditions, existing_cover_inr, budget_band, "
-                        "gender."
+                        "desired_sum_insured_inr, gender."
                     ),
                 },
                 "value": {
                     "type": "STRING",
                     "description": (
-                        "Value as a string. Numbers (age, existing_cover_inr) "
-                        "may be sent as a digit string; health_conditions may "
-                        "be a comma-joined string of conditions."
+                        "Value as a string. Numbers (age, existing_cover_inr, "
+                        "desired_sum_insured_inr) may be sent as a digit "
+                        "string or with units ('10L', '1 crore'); "
+                        "health_conditions may be a comma-joined string."
                     ),
                 },
             },
@@ -447,7 +464,7 @@ def _profile_to_snapshot(profile) -> dict:
     for fld in (
         "name", "age", "dependents", "location_tier", "income_band",
         "primary_goal", "health_conditions", "existing_cover_inr",
-        "budget_band",
+        "budget_band", "desired_sum_insured_inr",
     ):
         try:
             v = getattr(profile, fld, None)
@@ -978,6 +995,36 @@ async def handle_turn(
     # save_profile_field calls within THIS conversation — not a
     # returning user, do NOT trigger RULE 4 Welcome Back.
     _current_turn = int(getattr(session, "turn_idx", 1) or 1)
+
+    # KI-Z7 (2026-05-15) — turn-1 name heuristic. If this is the first turn
+    # on this session AND the profile has no name captured yet, sniff a
+    # name out of `user_text` and try to load the named profile JSON. On a
+    # hit, session.profile is hydrated in-place so the KNOWN PROFILE block
+    # below already contains the recalled slots — RULE 4 (Welcome Back) then
+    # fires correctly on this same Gemini iteration. Best-effort: no error
+    # bubbles out.
+    if _current_turn == 1 and not (getattr(session.profile, "name", None) or ""):
+        try:
+            from backend.profile_persistence import (
+                extract_potential_name,
+                try_recall_by_name,
+            )
+
+            _maybe_name = extract_potential_name(user_text)
+            if _maybe_name:
+                _recalled = try_recall_by_name(session, _maybe_name)
+                if _recalled:
+                    _log.info(
+                        "single_brain turn-1 recall: name=%r matched stored "
+                        "profile; hydrated session=%s",
+                        _maybe_name, getattr(session, "session_id", "?"),
+                    )
+        except Exception as _recall_err:  # noqa: BLE001 — must never break turn
+            _log.warning(
+                "single_brain turn-1 recall failed: %s: %s",
+                type(_recall_err).__name__, str(_recall_err)[:200],
+            )
+
     _has_prior_profile = any(
         getattr(session.profile, fld, None) not in (None, "", [])
         for fld in (

frontend/src/app/page.tsx

@@ -104,6 +104,16 @@ export default function Page() {
   // tighten as they fill in slots. Debounced 500ms to coalesce bursts.
   const [premiumBand, setPremiumBand] = useState<PredictedPremiumBandResponse | null>(null);
 
+  // KI-Z7 (2026-05-15) — Feature B. Welcome-back banner state. Populated
+  // when /api/chat returns `returning_user_recalled: true` on the
+  // assistant turn that hydrated the session from a stored named-profile.
+  // Cleared by either the "Use this profile" / "Update my info" actions
+  // OR by handleClearChat.
+  const [welcomeBack, setWelcomeBack] = useState<{
+    name: string;
+    bandText: string | null;
+  } | null>(null);
+
   // Re-fetch profile completeness whenever sessionId changes (after first chat
   // turn) — drives the score-gate on marketplace cards + detail modal.
   useEffect(() => {
@@ -604,6 +614,9 @@ export default function Page() {
     // Always wipe the visible chat + local storage.
     setMessages([]);
     setInput("");
+    // KI-Z7 — clear the welcome-back banner so a brand-new visitor doesn't
+    // see stale "Welcome back, …" copy after the session reset.
+    setWelcomeBack(null);
     // KI-073 (2026-05-15) — clear the profile-completeness chip immediately
     // so the header doesn't show stale "55% DONE" for a brand-new visitor
     // while the new session_id fetch is in flight.
@@ -752,6 +765,33 @@ export default function Page() {
         latencyMs: res.latency_ms,
         blocked: res.blocked,
       });
+      // KI-Z7 (2026-05-15) — Feature B. Surface the "Welcome back" banner
+      // when the backend recalled a stored named-profile on this turn.
+      // The predicted-premium band is fetched separately below by the
+      // usual completeness-pct effect, but we ALSO pre-load it eagerly
+      // here so the banner has a value to render on first paint.
+      if (res.returning_user_recalled && res.session_id) {
+        getPredictedPremiumBand(res.session_id)
+          .then((band) => {
+            let bandText: string | null = null;
+            if (band && band.min_inr && band.max_inr) {
+              const minK = Math.round(band.min_inr / 1000);
+              const maxK = Math.round(band.max_inr / 1000);
+              bandText = `₹${minK}k-₹${maxK}k/year`;
+            }
+            // Display name from the freshly-refreshed completeness fetch
+            // (it queries the same session.profile we just hydrated).
+            getProfileCompleteness(res.session_id)
+              .then((pc) => {
+                const display =
+                  (pc?.profile as { name?: string } | undefined)?.name ||
+                  "there";
+                setWelcomeBack({ name: display, bandText });
+              })
+              .catch(() => setWelcomeBack({ name: "there", bandText }));
+          })
+          .catch(() => setWelcomeBack({ name: "there", bandText: null }));
+      }
       // KI-030 (2026-05-14) — playback moved into the in-DOM <audio> element
       // owned by the Message component (autoplay on mount). Detached
       // `new Audio()` instances were invisible to
@@ -1462,6 +1502,51 @@ export default function Page() {
                 Clear chat
               </button>
             </div>
+            {/* KI-Z7 (2026-05-15) — Feature B. Welcome-back banner. Renders
+                when the backend matched + hydrated a stored named-profile on
+                this turn. "Use this profile" dismisses the banner (keeps the
+                hydrated profile in place); "Update my info" opens the profile
+                builder so the user can revise any fact before continuing. */}
+            {welcomeBack && (
+              <div className="mb-3 rounded-xl border border-[var(--primary)] bg-[var(--primary)]/10 px-3 py-2 text-sm flex items-center justify-between gap-2">
+                <div className="flex-1">
+                  <span className="font-semibold text-[var(--primary)]">
+                    Welcome back, {welcomeBack.name}!
+                  </span>{" "}
+                  <span className="text-[var(--muted-foreground)]">
+                    Your profile is loaded.
+                  </span>
+                  {welcomeBack.bandText && (
+                    <span className="text-[var(--muted-foreground)]">
+                      {" "}Last predicted premium:{" "}
+                      <strong className="text-[var(--foreground)]">
+                        {welcomeBack.bandText}
+                      </strong>
+                      .
+                    </span>
+                  )}
+                </div>
+                <div className="flex items-center gap-1 shrink-0">
+                  <button
+                    onClick={() => setWelcomeBack(null)}
+                    className="px-2 py-1 rounded-md text-xs border border-[var(--primary)] text-[var(--primary)] hover:bg-[var(--primary)] hover:text-white transition"
+                    title="Continue with the loaded profile"
+                  >
+                    Use this profile
+                  </button>
+                  <button
+                    onClick={() => {
+                      setWelcomeBack(null);
+                      setShowProfile(true);
+                    }}
+                    className="px-2 py-1 rounded-md text-xs border border-[var(--border)] text-[var(--muted-foreground)] hover:border-[var(--primary)] hover:text-[var(--foreground)] transition"
+                    title="Open the profile builder to revise"
+                  >
+                    Update my info
+                  </button>
+                </div>
+              </div>
+            )}
             <div ref={scrollRef} className="flex-1 overflow-y-auto scrollbar-thin space-y-4 mb-4 pr-1">
               {messages.map((m) => <Message key={m.id} m={m} />)}
               {(busy || voicePhase) && <ThinkingDots phase={voicePhase} />}

frontend/src/components/PolicyCompareModal.tsx

@@ -0,0 +1,372 @@
+"use client";
+
+// PolicyCompareModal — side-by-side comparison modal opened from the chat
+// reply. Renders one column per cited policy with three slots:
+//   1. Header  — insurer logo + policy name + insurer + scorecard chip
+//   2. Premium — pluggable widget (B2) via props.renderPremiumFor(policyId)
+//   3. Scorecard — pluggable widget (B3) via props.renderScorecardFor(policyId)
+//   4. Policy details — expandable section with source URL
+// Visual style copied from MarketplacePanel's PolicyCard so the chat-side
+// compare matches the marketplace-side compare (same fonts, borders, radii).
+
+import { useEffect, useState, type ReactNode } from "react";
+import { Citation, ScorecardResponse, getScorecard } from "@/lib/api";
+
+// ----- local visual helpers (forked from page.tsx so this file is
+// self-contained; the originals stay in page.tsx untouched). -----
+
+const INSURER_COLOR: Record<string, string> = {
+  "aditya-birla":  "bg-orange-600",
+  "bajaj-allianz": "bg-blue-700",
+  "care-health":   "bg-emerald-700",
+  "hdfc-ergo":     "bg-rose-700",
+  "icici-lombard": "bg-orange-500",
+  "manipalcigna":  "bg-fuchsia-700",
+  "new-india":     "bg-indigo-700",
+  "niva-bupa":     "bg-cyan-700",
+  "star-health":   "bg-amber-600",
+  "tata-aig":      "bg-slate-700",
+};
+
+const INSURER_LOGO_URL: Record<string, string> = {
+  "aditya-birla":  "https://www.adityabirlacapital.com/healthinsurance/static/assets/images/abhi-logo.svg",
+  "bajaj-allianz": "https://www.bajajallianz.com/content/dam/bagic/header/logo.png",
+  "care-health":   "https://www.careinsurance.com/upload_master/images/logo.png",
+  "hdfc-ergo":     "https://www.hdfcergo.com/etc.clientlibs/hdfcergo/clientlibs/clientlib-site/resources/images/HDFC-ERGO-Logo.png",
+  "icici-lombard": "https://www.icicilombard.com/content/dam/ilom-website/icon/icici-lombard-logo-new.svg",
+  "manipalcigna":  "https://www.manipalcigna.com/o/manipal-cigna-theme/images/manipal-cigna-logo.svg",
+  "new-india":     "https://www.newindia.co.in/portal/readWriteData/NIAImages/NewLogo.png",
+  "niva-bupa":     "https://transactions.nivabupa.com/_next/static/media/niva-bupa-logo.7b6e7f4e.svg",
+  "star-health":   "https://www.starhealth.in/sites/default/files/star-logo-revised.png",
+  "tata-aig":      "https://www.tataaig.com/etc/designs/tataaig/clientlibs/responsive/images/tataaig-logo.svg",
+};
+
+function insurerInitials(name: string): string {
+  return name.split(/[\s-]+/).map((w) => w[0]).filter(Boolean).join("").slice(0, 2).toUpperCase();
+}
+
+function InsurerLogo({ slug, name, size = 40 }: { slug: string; name: string; size?: number }) {
+  const [failed, setFailed] = useState(false);
+  const url = INSURER_LOGO_URL[slug];
+  const color = INSURER_COLOR[slug] || "bg-slate-500";
+  if (!url || failed) {
+    return (
+      <div
+        className={`rounded-lg ${color} text-white flex items-center justify-center font-bold shrink-0`}
+        style={{ width: size, height: size, fontSize: size * 0.32 }}
+      >
+        {insurerInitials(name)}
+      </div>
+    );
+  }
+  return (
+    <div
+      className="rounded-lg bg-white border border-[var(--border)] flex items-center justify-center shrink-0 overflow-hidden p-1"
+      style={{ width: size, height: size }}
+    >
+      {/* eslint-disable-next-line @next/next/no-img-element */}
+      <img
+        src={url}
+        alt={name}
+        onError={() => setFailed(true)}
+        className="max-w-full max-h-full object-contain"
+      />
+    </div>
+  );
+}
+
+function gradeColor(grade: string): string {
+  const map: Record<string, string> = {
+    A: "bg-emerald-500 text-white",
+    B: "bg-teal-500 text-white",
+    C: "bg-amber-500 text-white",
+    D: "bg-orange-500 text-white",
+    F: "bg-red-500 text-white",
+  };
+  return map[grade] || "bg-stone-400 text-white";
+}
+
+// Dedupe citations by policy_id, preserving order.
+function uniquePolicies(citations: Citation[]): Citation[] {
+  const seen = new Set<string>();
+  const out: Citation[] = [];
+  for (const c of citations) {
+    if (seen.has(c.policy_id)) continue;
+    seen.add(c.policy_id);
+    out.push(c);
+  }
+  return out;
+}
+
+export type PolicyCompareModalProps = {
+  policies: Citation[];
+  onClose: () => void;
+  // B2 + B3 plug points. Both are optional; safe fallbacks render below.
+  renderPremiumFor?: (policyId: string) => ReactNode;
+  renderScorecardFor?: (policyId: string) => ReactNode;
+  // Profile hint for downstream personalized widgets (unused by the shell
+  // itself; pass-through so widgets opened via renderXxxFor can read it).
+  // Typed loosely (any) by contract; harness should narrow when wiring.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  profile?: any;
+  // Hook for "Open in full marketplace" — defaults to no-op + closes modal.
+  onOpenMarketplace?: () => void;
+};
+
+export default function PolicyCompareModal({
+  policies,
+  onClose,
+  renderPremiumFor,
+  renderScorecardFor,
+  profile: _profile,
+  onOpenMarketplace,
+}: PolicyCompareModalProps) {
+  const uniq = uniquePolicies(policies).slice(0, 4);
+  const n = uniq.length;
+
+  return (
+    <div
+      className="fixed inset-0 z-[70] bg-black/50 flex items-stretch sm:items-center justify-center p-0 sm:p-3 animate-fade-up"
+      onClick={onClose}
+      role="dialog"
+      aria-modal="true"
+      aria-label={`Compare ${n} polic${n === 1 ? "y" : "ies"}`}
+    >
+      <div
+        className="bg-[var(--card)] sm:rounded-2xl shadow-xl w-full sm:max-w-6xl sm:w-[80vw] max-h-screen sm:max-h-[92vh] overflow-y-auto scrollbar-thin"
+        onClick={(e) => e.stopPropagation()}
+      >
+        {/* Header */}
+        <div className="sticky top-0 z-10 bg-[var(--card)] border-b border-[var(--border)] px-5 py-4 flex items-center justify-between">
+          <div>
+            <h3 className="text-base font-bold">
+              Compare {n} polic{n === 1 ? "y" : "ies"}
+            </h3>
+            <p className="text-[11px] text-[var(--muted-foreground)] mt-0.5">
+              Premiums, fit scores and policy details — side-by-side.
+            </p>
+          </div>
+          <button
+            onClick={onClose}
+            className="text-[var(--muted-foreground)] hover:text-[var(--foreground)] text-2xl leading-none ml-2"
+            aria-label="Close comparison"
+          >
+            ×
+          </button>
+        </div>
+
+        {/* Body: 1 col on mobile, n cols on desktop */}
+        <div className="p-4 sm:p-5">
+          <div
+            className="grid gap-4 grid-cols-1"
+            style={{
+              gridTemplateColumns:
+                n > 1 ? `repeat(${n}, minmax(0, 1fr))` : undefined,
+            }}
+          >
+            {uniq.map((c) => (
+              <CompareColumn
+                key={c.policy_id}
+                citation={c}
+                premiumSlot={renderPremiumFor?.(c.policy_id)}
+                scorecardSlot={renderScorecardFor?.(c.policy_id)}
+              />
+            ))}
+          </div>
+        </div>
+
+        {/* Footer */}
+        <div className="sticky bottom-0 bg-[var(--card)] border-t border-[var(--border)] px-5 py-3 flex items-center justify-between text-xs">
+          <span className="text-[var(--muted-foreground)]">
+            Comparing the policies cited in this reply. Open the full
+            marketplace for filters and 30+ more options.
+          </span>
+          <button
+            onClick={() => {
+              onOpenMarketplace?.();
+              onClose();
+            }}
+            className="font-semibold text-[var(--primary)] hover:underline"
+          >
+            Open in full marketplace →
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+// One vertical card per cited policy.
+function CompareColumn({
+  citation,
+  premiumSlot,
+  scorecardSlot,
+}: {
+  citation: Citation;
+  premiumSlot?: ReactNode;
+  scorecardSlot?: ReactNode;
+}) {
+  const insurerName = citation.insurer_slug.replace(/-/g, " ");
+  return (
+    <div className="bg-[var(--card)] border border-[var(--border)] rounded-xl p-4 flex flex-col gap-4 min-w-0">
+      {/* Header — logo + insurer + policy name */}
+      <div className="flex items-start gap-3">
+        <InsurerLogo slug={citation.insurer_slug} name={insurerName} size={40} />
+        <div className="flex-1 min-w-0">
+          <div className="text-[10px] uppercase tracking-wider text-[var(--muted-foreground)] truncate">
+            {insurerName}
+          </div>
+          <div className="font-semibold text-sm leading-tight break-words">
+            {citation.policy_name}
+          </div>
+        </div>
+      </div>
+
+      {/* PREMIUM CALCULATOR slot (B2) */}
+      <Section title="Premium calculator">
+        {premiumSlot ?? <PlaceholderWidget label="Premium calculator coming soon" />}
+      </Section>
+
+      {/* YOUR FIT SCORECARD slot (B3) */}
+      <Section title="Your fit scorecard">
+        {scorecardSlot ?? <ScorecardFallback policyId={citation.policy_id} />}
+      </Section>
+
+      {/* POLICY DETAILS expandable */}
+      <PolicyDetails citation={citation} />
+    </div>
+  );
+}
+
+function Section({ title, children }: { title: string; children: ReactNode }) {
+  return (
+    <div>
+      <div className="text-[10px] uppercase tracking-wider text-[var(--muted-foreground)] font-semibold mb-1.5">
+        {title}
+      </div>
+      {children}
+    </div>
+  );
+}
+
+function PlaceholderWidget({ label }: { label: string }) {
+  return (
+    <div className="bg-[var(--muted)] border border-dashed border-[var(--border)] rounded-lg px-3 py-4 text-center text-[11px] text-[var(--muted-foreground)]">
+      {label}
+    </div>
+  );
+}
+
+// Default scorecard preview — fetches `/api/policies/:id/scorecard` and
+// renders a compact grade + one-liner card. Used when the parent doesn't
+// pass a renderScorecardFor() prop.
+function ScorecardFallback({ policyId }: { policyId: string }) {
+  const [sc, setSc] = useState<ScorecardResponse | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(false);
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setError(false);
+    getScorecard(policyId)
+      .then((r) => {
+        if (!cancelled) setSc(r);
+      })
+      .catch(() => {
+        if (!cancelled) setError(true);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [policyId]);
+  if (loading) {
+    return <PlaceholderWidget label="Loading scorecard…" />;
+  }
+  if (error || !sc) {
+    return <PlaceholderWidget label="Scorecard unavailable" />;
+  }
+  return (
+    <div className="bg-[var(--muted)] border border-[var(--border)] rounded-lg p-3">
+      <div className="flex items-center gap-2">
+        <span
+          className={`inline-flex items-center justify-center w-9 h-9 rounded-md font-bold text-sm ${gradeColor(
+            sc.grade,
+          )}`}
+        >
+          {sc.grade}
+        </span>
+        <div className="min-w-0">
+          <div className="text-sm font-semibold leading-tight">
+            {sc.overall_score}
+            <span className="text-[var(--muted-foreground)] text-[10px] font-normal">
+              /100
+            </span>
+          </div>
+          <div className="text-[10px] text-[var(--muted-foreground)] truncate">
+            {sc.one_liner}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function PolicyDetails({ citation }: { citation: Citation }) {
+  const [open, setOpen] = useState(false);
+  const hasSource = !!citation.source_url && citation.source_url.startsWith("http");
+  const pageRange =
+    citation.page_start && citation.page_end
+      ? citation.page_start === citation.page_end
+        ? `p. ${citation.page_start}`
+        : `pp. ${citation.page_start}–${citation.page_end}`
+      : null;
+  return (
+    <div className="border border-[var(--border)] rounded-lg bg-[var(--card)]">
+      <button
+        onClick={() => setOpen((v) => !v)}
+        className="w-full text-left px-3 py-2 text-[11px] font-semibold flex items-center justify-between hover:bg-[var(--muted)] rounded-lg"
+        aria-expanded={open}
+      >
+        <span className="uppercase tracking-wider text-[var(--muted-foreground)]">
+          Policy details
+        </span>
+        <span className="text-[var(--muted-foreground)]">{open ? "−" : "+"}</span>
+      </button>
+      {open && (
+        <div className="px-3 pb-3 pt-1 border-t border-[var(--border)] space-y-2 text-[11px]">
+          <DetailRow label="Policy" value={citation.policy_name} />
+          <DetailRow label="Insurer" value={citation.insurer_slug.replace(/-/g, " ")} />
+          {pageRange && <DetailRow label="Cited" value={pageRange} />}
+          {hasSource ? (
+            <a
+              href={citation.source_url}
+              target="_blank"
+              rel="noopener"
+              className="inline-flex items-center gap-1 text-[var(--primary)] hover:underline font-semibold"
+            >
+              Open policy PDF →
+            </a>
+          ) : (
+            <span className="text-[var(--muted-foreground)] italic">
+              No source PDF link available
+            </span>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function DetailRow({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex gap-2">
+      <span className="text-[var(--muted-foreground)] uppercase tracking-wide text-[10px] w-16 shrink-0">
+        {label}
+      </span>
+      <span className="text-[var(--foreground)] break-words">{value}</span>
+    </div>
+  );
+}

frontend/src/components/PolicyPremiumWidget.tsx

@@ -0,0 +1,401 @@
+"use client";
+
+/**
+ * PolicyPremiumWidget — per-policy slider-driven premium calculator.
+ *
+ * Embedded inside PolicyCompareModal (B1). Fetches an initial estimate from
+ * /api/premium/bulk using the user's profile defaults, then re-fetches
+ * (debounced 300ms) whenever the user moves the SI / tenure / deductible
+ * sliders. When the backend marks the row `assumed: true` (no curated
+ * actuarial data for this policy) the widget shows an "Estimate" badge so
+ * the user understands the number is heuristic, not a quote.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+import {
+  postPremiumBulk,
+  type PremiumBulkProfile,
+  type PremiumBulkRow,
+} from "@/lib/api";
+
+export type PolicyPremiumWidgetProps = {
+  policyId: string;
+  policyName: string;
+  profile?: PremiumBulkProfile;
+  initialSumInsured?: number;
+  initialTenureYears?: 1 | 2 | 3;
+  initialDeductibleInr?: 0 | 25000 | 50000 | 100000;
+  onCalculated?: (premium: number) => void;
+};
+
+const SUM_INSURED_MIN = 500_000;
+const SUM_INSURED_MAX = 10_000_000;
+const SUM_INSURED_STEP = 500_000;
+const TENURE_CHOICES = [1, 2, 3] as const;
+const DEDUCTIBLE_CHOICES = [0, 25_000, 50_000, 100_000] as const;
+
+function formatInr(value: number): string {
+  // Indian-style 1,23,456 grouping.
+  return value.toLocaleString("en-IN");
+}
+
+function formatSiLabel(inr: number): string {
+  if (inr >= 10_000_000) return `${(inr / 10_000_000).toFixed(inr % 10_000_000 === 0 ? 0 : 1)}Cr`;
+  return `${Math.round(inr / 100_000)}L`;
+}
+
+function formatDeductibleLabel(inr: number): string {
+  if (inr === 0) return "₹0";
+  if (inr >= 100_000) return `₹${(inr / 100_000).toFixed(0)}L`;
+  return `₹${Math.round(inr / 1_000)}K`;
+}
+
+function summariseProfile(profile?: PremiumBulkProfile): string | null {
+  if (!profile) return null;
+  const parts: string[] = [];
+  if (typeof profile.age === "number") parts.push(`age ${profile.age}`);
+  if (typeof profile.family_size === "number" && profile.family_size > 1) {
+    parts.push(`family of ${profile.family_size}`);
+  } else if (profile.dependents) {
+    parts.push(profile.dependents);
+  }
+  if (profile.location_tier) parts.push(String(profile.location_tier).toLowerCase());
+  return parts.length ? parts.join(", ") : null;
+}
+
+const BREAKDOWN_LABELS: Record<string, string> = {
+  base_inr: "Base",
+  age_loading_x: "Age loading",
+  location_loading_x: "Location loading",
+  family_loading_x: "Family loading",
+  tenure_discount_x: "Tenure discount",
+  deductible_discount_x: "Deductible discount",
+};
+
+function renderBreakdownBullets(breakdown: Record<string, number | string>): string[] {
+  const bullets: string[] = [];
+  const base = breakdown.base_inr;
+  if (typeof base === "number") bullets.push(`Base: ₹${formatInr(base)}`);
+  for (const key of [
+    "age_loading_x",
+    "location_loading_x",
+    "family_loading_x",
+    "tenure_discount_x",
+    "deductible_discount_x",
+  ]) {
+    const v = breakdown[key];
+    if (typeof v === "number" && Math.abs(v - 1.0) > 0.001) {
+      const label = BREAKDOWN_LABELS[key];
+      bullets.push(`${label}: ${v.toFixed(2)}×`);
+    }
+  }
+  return bullets;
+}
+
+export default function PolicyPremiumWidget({
+  policyId,
+  policyName,
+  profile,
+  initialSumInsured = 1_000_000,
+  initialTenureYears = 1,
+  initialDeductibleInr = 0,
+  onCalculated,
+}: PolicyPremiumWidgetProps) {
+  const [sumInsured, setSumInsured] = useState<number>(initialSumInsured);
+  const [tenureYears, setTenureYears] = useState<number>(initialTenureYears);
+  const [deductibleInr, setDeductibleInr] = useState<number>(initialDeductibleInr);
+  const [row, setRow] = useState<PremiumBulkRow | null>(null);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  // 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]);
+
+  const onCalculatedRef = useRef(onCalculated);
+  useEffect(() => {
+    onCalculatedRef.current = onCalculated;
+  }, [onCalculated]);
+
+  const fetchPremium = useCallback(
+    async (signal: AbortSignal) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const resp = await postPremiumBulk({
+          policy_ids: [policyId],
+          profile: profile ?? {},
+          overrides: {
+            [policyId]: {
+              sum_insured_inr: sumInsured,
+              tenure_years: tenureYears,
+              deductible_inr: deductibleInr,
+            },
+          },
+        });
+        if (signal.aborted) return;
+        const r = resp.per_policy[policyId];
+        if (!r) {
+          setError("No estimate returned for this policy.");
+          return;
+        }
+        setRow(r);
+        onCalculatedRef.current?.(r.premium_inr_annual);
+      } catch (e) {
+        if (signal.aborted) return;
+        setError(e instanceof Error ? e.message : String(e));
+      } finally {
+        if (!signal.aborted) setLoading(false);
+      }
+    },
+    [policyId, profileKey, sumInsured, tenureYears, deductibleInr], // eslint-disable-line react-hooks/exhaustive-deps
+  );
+
+  // 300ms debounce on slider drags; immediate fetch on mount / policy switch.
+  useEffect(() => {
+    const ctrl = new AbortController();
+    const handle = window.setTimeout(() => {
+      void fetchPremium(ctrl.signal);
+    }, 300);
+    return () => {
+      window.clearTimeout(handle);
+      ctrl.abort();
+    };
+  }, [fetchPremium]);
+
+  const profileSummary = summariseProfile(profile);
+  const bullets = row ? renderBreakdownBullets(row.breakdown) : [];
+
+  return (
+    <div className="policy-premium-widget" style={widgetStyle}>
+      <header style={headerStyle}>
+        <div style={{ fontWeight: 600, fontSize: 14 }}>{policyName}</div>
+        {row?.assumed && (
+          <span style={badgeStyle} title="Heuristic — no exact actuarial data for this policy.">
+            Estimate
+          </span>
+        )}
+      </header>
+
+      {profileSummary && (
+        <div style={profileLineStyle}>
+          Your profile defaults: {profileSummary}
+        </div>
+      )}
+
+      <div style={sliderGroupStyle}>
+        <label style={labelStyle}>
+          <span style={labelHeadStyle}>
+            Sum insured
+            <strong>₹{formatSiLabel(sumInsured)}</strong>
+          </span>
+          <input
+            type="range"
+            min={SUM_INSURED_MIN}
+            max={SUM_INSURED_MAX}
+            step={SUM_INSURED_STEP}
+            value={sumInsured}
+            onChange={(e) => setSumInsured(Number(e.target.value))}
+            aria-label="Sum insured"
+            style={{ width: "100%" }}
+          />
+          <div style={tickRowStyle}>
+            <span>₹5L</span>
+            <span>₹1Cr</span>
+          </div>
+        </label>
+
+        <label style={labelStyle}>
+          <span style={labelHeadStyle}>
+            Tenure
+            <strong>{tenureYears} {tenureYears === 1 ? "year" : "years"}</strong>
+          </span>
+          <div role="radiogroup" aria-label="Tenure" style={pillRowStyle}>
+            {TENURE_CHOICES.map((y) => (
+              <button
+                key={y}
+                type="button"
+                role="radio"
+                aria-checked={tenureYears === y}
+                onClick={() => setTenureYears(y)}
+                style={pillStyle(tenureYears === y)}
+              >
+                {y}y
+              </button>
+            ))}
+          </div>
+        </label>
+
+        <label style={labelStyle}>
+          <span style={labelHeadStyle}>
+            Deductible
+            <strong>{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>
+      </div>
+
+      <div style={resultBoxStyle} aria-live="polite">
+        {error ? (
+          <div style={{ color: "#b00020" }}>Failed: {error}</div>
+        ) : loading && !row ? (
+          <div style={{ color: "#666" }}>Calculating estimate…</div>
+        ) : row ? (
+          <>
+            <div style={resultHeadlineStyle}>
+              Estimated premium:&nbsp;
+              <strong>₹{formatInr(row.premium_inr_annual)}</strong>
+              <span style={resultSuffixStyle}>/year</span>
+              {loading && <span style={spinnerHintStyle}> updating…</span>}
+            </div>
+            {bullets.length > 0 && (
+              <ul style={breakdownListStyle}>
+                {bullets.map((b) => (
+                  <li key={b}>{b}</li>
+                ))}
+              </ul>
+            )}
+            {row.notes && row.notes.length > 0 && (
+              <div style={noteStyle}>{row.notes.join(" ")}</div>
+            )}
+          </>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
+/* ------------------------------------------------------------------ */
+/* Inline styles — kept local so the widget drops into any modal      */
+/* without a CSS-module dependency.                                   */
+/* ------------------------------------------------------------------ */
+
+const widgetStyle: React.CSSProperties = {
+  border: "1px solid #e5e7eb",
+  borderRadius: 12,
+  padding: 16,
+  background: "#fff",
+  display: "flex",
+  flexDirection: "column",
+  gap: 12,
+  fontFamily: "system-ui, -apple-system, Segoe UI, Roboto, sans-serif",
+};
+
+const headerStyle: React.CSSProperties = {
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  gap: 8,
+};
+
+const badgeStyle: React.CSSProperties = {
+  fontSize: 11,
+  fontWeight: 600,
+  padding: "2px 8px",
+  borderRadius: 999,
+  background: "#fff8e1",
+  color: "#8a6d00",
+  border: "1px solid #f1d680",
+};
+
+const profileLineStyle: React.CSSProperties = {
+  fontSize: 12,
+  color: "#666",
+};
+
+const sliderGroupStyle: React.CSSProperties = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 14,
+};
+
+const labelStyle: React.CSSProperties = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 6,
+  fontSize: 12,
+  color: "#374151",
+};
+
+const labelHeadStyle: React.CSSProperties = {
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  gap: 8,
+  fontWeight: 500,
+};
+
+const tickRowStyle: React.CSSProperties = {
+  display: "flex",
+  justifyContent: "space-between",
+  fontSize: 11,
+  color: "#9ca3af",
+};
+
+const pillRowStyle: React.CSSProperties = {
+  display: "flex",
+  gap: 6,
+  flexWrap: "wrap",
+};
+
+const pillStyle = (active: boolean): React.CSSProperties => ({
+  border: `1px solid ${active ? "#2563eb" : "#d1d5db"}`,
+  background: active ? "#2563eb" : "#fff",
+  color: active ? "#fff" : "#374151",
+  padding: "4px 10px",
+  borderRadius: 999,
+  fontSize: 12,
+  cursor: "pointer",
+});
+
+const resultBoxStyle: React.CSSProperties = {
+  borderTop: "1px solid #f1f5f9",
+  paddingTop: 12,
+  display: "flex",
+  flexDirection: "column",
+  gap: 8,
+};
+
+const resultHeadlineStyle: React.CSSProperties = {
+  fontSize: 14,
+};
+
+const resultSuffixStyle: React.CSSProperties = {
+  color: "#6b7280",
+  fontWeight: 400,
+};
+
+const spinnerHintStyle: React.CSSProperties = {
+  marginLeft: 8,
+  fontSize: 11,
+  color: "#9ca3af",
+  fontStyle: "italic",
+};
+
+const breakdownListStyle: React.CSSProperties = {
+  margin: 0,
+  paddingLeft: 18,
+  color: "#4b5563",
+  fontSize: 12,
+  lineHeight: 1.5,
+};
+
+const noteStyle: React.CSSProperties = {
+  fontSize: 11,
+  color: "#6b7280",
+  fontStyle: "italic",
+};

frontend/src/components/PolicyScorecardWidget.tsx

@@ -0,0 +1,388 @@
+// PolicyScorecardWidget — profile-aware A/B+/etc grade card for a single
+// policy. Mounted inside PolicyCompareModal once per policy.
+//
+// Why a per-policy widget (rather than a single multi-policy table):
+//   - PolicyCompareModal renders 2-4 of these side-by-side in a flex row.
+//   - Each card is self-contained: header grade + overall score, sub-score
+//     bars, profile rationale bullets, data-completeness warning.
+//   - The fetch is one bulk POST per widget mount (single-policy), but the
+//     SAME endpoint can be batched by a parent that wants to issue one call
+//     for all N policies — we expose `precomputed` for that case.
+//
+// Ranking is UNIQUE TO THE USER's PROFILE. The backend's
+// _profile_tuned_weights() re-balances the 6 sub-score weights based on:
+//   - diabetes / BP / hyper  -> heavier waiting-period + claim-experience
+//   - age >= 50              -> heavier renewal-protection
+//   - dependents = spouse    -> heavier coverage-breadth + cost-predictability
+//   - existing_cover_inr=0   -> heavier cost-predictability (first-time buyer)
+// So the same policy will literally score differently for different users.
+
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import {
+  postScorecardBulk,
+  type BulkScorecardEntry,
+  type BulkScorecardProfile,
+} from "@/lib/api";
+
+export type PolicyScorecardWidgetProps = {
+  policyId: string;
+  policyName: string;
+  profile?: BulkScorecardProfile;
+  // When the parent has already fetched a bulk response, pass the entry
+  // directly — avoids a second network call per widget.
+  precomputed?: BulkScorecardEntry;
+  // Optional callback so the parent can collect entries for analytics /
+  // a ranking row above the cards.
+  onLoaded?: (entry: BulkScorecardEntry) => void;
+  className?: string;
+};
+
+// Sub-score keys we know about — controls render order. Anything else the
+// backend returns gets appended after these in arrival order.
+const SUBSCORE_ORDER: { key: string; label: string }[] = [
+  { key: "coverage_breadth", label: "Coverage Breadth" },
+  { key: "cost_predictability", label: "Cost Predictability" },
+  { key: "waiting_period_friction", label: "Waiting Periods" },
+  { key: "claim_experience", label: "Claim Experience" },
+  { key: "renewal_protection", label: "Renewal Protection" },
+  { key: "bonus_and_loyalty", label: "Bonuses" },
+];
+
+function gradeColor(grade: string): { fg: string; bg: string; ring: string } {
+  // Same palette family for every variant of a letter so a B+ looks like a B-
+  // but slightly stronger.
+  const head = grade.charAt(0).toUpperCase();
+  switch (head) {
+    case "A":
+      return { fg: "#0f5132", bg: "#d1fadf", ring: "#16a34a" };
+    case "B":
+      return { fg: "#0c4a6e", bg: "#dbeafe", ring: "#2563eb" };
+    case "C":
+      return { fg: "#854d0e", bg: "#fef3c7", ring: "#d97706" };
+    case "D":
+      return { fg: "#7c2d12", bg: "#fed7aa", ring: "#ea580c" };
+    case "F":
+      return { fg: "#7f1d1d", bg: "#fecaca", ring: "#dc2626" };
+    default:
+      return { fg: "#374151", bg: "#f3f4f6", ring: "#9ca3af" };
+  }
+}
+
+function barColor(score: number): string {
+  if (score >= 80) return "#16a34a"; // green
+  if (score >= 65) return "#2563eb"; // blue
+  if (score >= 50) return "#d97706"; // amber
+  if (score >= 35) return "#ea580c"; // orange
+  return "#dc2626";                   // red
+}
+
+function rationaleTone(bullet: string): "pos" | "neg" | "neutral" {
+  const lower = bullet.toLowerCase();
+  if (lower.startsWith("strong fit") || lower.startsWith("strongest")) return "pos";
+  if (lower.startsWith("weak fit") || lower.startsWith("watch out")) return "neg";
+  return "neutral";
+}
+
+export default function PolicyScorecardWidget({
+  policyId,
+  policyName,
+  profile,
+  precomputed,
+  onLoaded,
+  className,
+}: PolicyScorecardWidgetProps) {
+  const [entry, setEntry] = useState<BulkScorecardEntry | null>(precomputed ?? null);
+  const [loading, setLoading] = useState(!precomputed);
+  const [error, setError] = useState<string | null>(null);
+
+  // Stabilise profile dependency: callers usually rebuild the object each
+  // render but the values rarely change. Stringify-key the effect so we don't
+  // re-fetch on identity churn.
+  const profileKey = useMemo(
+    () => (profile ? JSON.stringify(profile) : ""),
+    [profile],
+  );
+
+  useEffect(() => {
+    if (precomputed) {
+      setEntry(precomputed);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    postScorecardBulk({
+      policy_ids: [policyId],
+      profile: profile ?? undefined,
+    })
+      .then((resp) => {
+        if (cancelled) return;
+        const e = resp.per_policy?.[policyId];
+        if (!e) {
+          setError("No scorecard returned for this policy.");
+          setEntry(null);
+        } else {
+          setEntry(e);
+          onLoaded?.(e);
+        }
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return;
+        setError(err instanceof Error ? err.message : "Failed to load scorecard.");
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+    // policyId + profileKey + precomputed identity are the real deps; onLoaded
+    // is intentionally excluded to avoid re-fetch loops if the parent passes
+    // an inline arrow.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [policyId, profileKey, precomputed]);
+
+  if (loading) {
+    return (
+      <div
+        className={className}
+        style={{
+          border: "1px solid #e5e7eb",
+          borderRadius: 12,
+          padding: 16,
+          background: "#fff",
+          minHeight: 220,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          color: "#6b7280",
+          fontSize: 13,
+        }}
+        aria-busy="true"
+        aria-live="polite"
+      >
+        Scoring {policyName}…
+      </div>
+    );
+  }
+
+  if (error || !entry) {
+    return (
+      <div
+        className={className}
+        style={{
+          border: "1px solid #fecaca",
+          borderRadius: 12,
+          padding: 16,
+          background: "#fef2f2",
+          color: "#991b1b",
+          fontSize: 13,
+        }}
+        role="alert"
+      >
+        Couldn’t score this policy: {error ?? "unknown error"}
+      </div>
+    );
+  }
+
+  const isNA = entry.overall_grade === "N/A";
+  const colors = gradeColor(entry.overall_grade);
+  const completeness = entry.data_completeness_pct;
+  const showLimitedWarning = completeness < 50 && !isNA;
+
+  // Render sub-scores in the canonical order first, then any extras.
+  const knownKeys = new Set(SUBSCORE_ORDER.map((s) => s.key));
+  const extras = Object.keys(entry.sub_scores).filter((k) => !knownKeys.has(k));
+  const renderable = [
+    ...SUBSCORE_ORDER.filter((s) => entry.sub_scores[s.key] !== undefined),
+    ...extras.map((k) => ({ key: k, label: k.replace(/_/g, " ") })),
+  ];
+
+  return (
+    <div
+      className={className}
+      style={{
+        border: "1px solid #e5e7eb",
+        borderRadius: 12,
+        padding: 16,
+        background: "#fff",
+        display: "flex",
+        flexDirection: "column",
+        gap: 14,
+      }}
+      data-policy-id={policyId}
+    >
+      {/* Header: grade + overall score */}
+      <div style={{ display: "flex", alignItems: "center", gap: 14 }}>
+        <div
+          style={{
+            width: 64,
+            height: 64,
+            borderRadius: 14,
+            background: colors.bg,
+            color: colors.fg,
+            border: `2px solid ${colors.ring}`,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            fontSize: entry.overall_grade.length > 1 ? 26 : 32,
+            fontWeight: 800,
+            letterSpacing: "-0.04em",
+            flexShrink: 0,
+          }}
+          aria-label={`Grade ${entry.overall_grade}`}
+        >
+          {entry.overall_grade}
+        </div>
+        <div style={{ minWidth: 0, flex: 1 }}>
+          <div
+            style={{
+              fontSize: 13,
+              fontWeight: 600,
+              color: "#111827",
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+            }}
+            title={entry.policy_name || policyName}
+          >
+            {entry.policy_name || policyName}
+          </div>
+          <div style={{ display: "flex", alignItems: "baseline", gap: 6, marginTop: 2 }}>
+            <span style={{ fontSize: 22, fontWeight: 700, color: "#111827" }}>
+              {isNA ? "—" : `${entry.overall_score}`}
+            </span>
+            {!isNA && (
+              <span style={{ fontSize: 12, color: "#6b7280" }}>/ 100</span>
+            )}
+            {profile && !isNA && (
+              <span
+                style={{
+                  marginLeft: "auto",
+                  fontSize: 10,
+                  textTransform: "uppercase",
+                  letterSpacing: "0.08em",
+                  color: "#0c4a6e",
+                  background: "#e0f2fe",
+                  padding: "2px 6px",
+                  borderRadius: 4,
+                  fontWeight: 600,
+                }}
+                title="Score weights adjusted for your profile"
+              >
+                Personalised
+              </span>
+            )}
+          </div>
+          {entry.one_liner && (
+            <div style={{ fontSize: 11, color: "#4b5563", marginTop: 2 }}>
+              {entry.one_liner}
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Sub-scores */}
+      {renderable.length > 0 && (
+        <div style={{ display: "flex", flexDirection: "column", gap: 6 }}>
+          {renderable.map(({ key, label }) => {
+            const v = entry.sub_scores[key] ?? 0;
+            return (
+              <div key={key} style={{ display: "flex", flexDirection: "column", gap: 2 }}>
+                <div style={{ display: "flex", justifyContent: "space-between", fontSize: 11 }}>
+                  <span style={{ color: "#374151", textTransform: "capitalize" }}>
+                    {label}
+                  </span>
+                  <span style={{ color: "#6b7280", fontVariantNumeric: "tabular-nums" }}>
+                    {v}
+                  </span>
+                </div>
+                <div
+                  style={{
+                    height: 6,
+                    borderRadius: 999,
+                    background: "#f3f4f6",
+                    overflow: "hidden",
+                  }}
+                >
+                  <div
+                    style={{
+                      width: `${Math.max(0, Math.min(100, v))}%`,
+                      height: "100%",
+                      background: barColor(v),
+                      transition: "width 200ms ease-out",
+                    }}
+                  />
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      )}
+
+      {/* Profile rationale */}
+      {entry.profile_rationale.length > 0 && (
+        <div
+          style={{
+            background: "#f9fafb",
+            border: "1px solid #f3f4f6",
+            borderRadius: 8,
+            padding: 10,
+          }}
+        >
+          <div
+            style={{
+              fontSize: 10,
+              textTransform: "uppercase",
+              letterSpacing: "0.08em",
+              color: "#6b7280",
+              fontWeight: 600,
+              marginBottom: 6,
+            }}
+          >
+            Why this score for you
+          </div>
+          <ul style={{ margin: 0, paddingLeft: 16, display: "flex", flexDirection: "column", gap: 4 }}>
+            {entry.profile_rationale.map((b, i) => {
+              const tone = rationaleTone(b);
+              const color =
+                tone === "pos" ? "#0f5132" : tone === "neg" ? "#991b1b" : "#374151";
+              return (
+                <li key={i} style={{ fontSize: 12, color, lineHeight: 1.4 }}>
+                  {b}
+                </li>
+              );
+            })}
+          </ul>
+        </div>
+      )}
+
+      {/* Limited-data warning */}
+      {showLimitedWarning && (
+        <div
+          style={{
+            display: "flex",
+            alignItems: "center",
+            gap: 8,
+            fontSize: 11,
+            color: "#854d0e",
+            background: "#fef3c7",
+            border: "1px solid #fde68a",
+            borderRadius: 8,
+            padding: "6px 10px",
+          }}
+          role="status"
+        >
+          <span style={{ fontWeight: 700 }}>Limited data:</span>
+          <span>
+            Only {completeness.toFixed(0)}% of scoring fields are filled for this policy —
+            grade may shift once more details are indexed.
+          </span>
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/lib/api.ts

@@ -34,6 +34,11 @@ export type ChatResponse = {
   faithfulness_passed?: boolean;
   faithfulness_reasons?: string[];
   blocked?: boolean;
+  // KI-Z7 (2026-05-15) — Feature B. True when single_brain.handle_turn's
+  // turn-1 name heuristic matched a stored named-profile and hydrated the
+  // live session. Frontend renders a "Welcome back" banner when this is
+  // true on the assistant turn it arrives with.
+  returning_user_recalled?: boolean;
 };
 
 export type ChatMessage = {
@@ -243,6 +248,61 @@ export async function getScorecard(policy_id: string): Promise<ScorecardResponse
   return resp.json();
 }
 
+// ----------------------------------------------------------------------------
+// Bulk profile-tuned scorecards (powers PolicyCompareModal scorecard widget).
+// One POST returns N scorecards in parallel — each weighted by the same
+// profile so the widget can render comparable ranks at a glance.
+// ----------------------------------------------------------------------------
+export type BulkScorecardProfile = {
+  age?: number;
+  dependents?: string;
+  health_conditions?: string[];
+  primary_goal?: string;
+  location_tier?: string;
+  income_band?: string;
+  budget_band?: string;
+  existing_cover_inr?: number;
+  parents_to_insure?: boolean;
+  parents_age_max?: number;
+  parents_has_ped?: boolean;
+};
+
+export type BulkScorecardEntry = {
+  policy_id: string;
+  policy_name: string;
+  insurer_slug: string;
+  overall_grade: string;             // "A" | "A-" | "B+" | ... | "N/A"
+  overall_score: number;             // 0-100
+  sub_scores: Record<string, number>; // {coverage_breadth: 82, ...}
+  profile_rationale: string[];
+  data_completeness_pct: number;     // 0-100
+  one_liner?: string;
+  signals?: Record<string, string[]>;
+};
+
+export type BulkScorecardResponse = {
+  per_policy: Record<string, BulkScorecardEntry>;
+};
+
+export async function postScorecardBulk(args: {
+  policy_ids: string[];
+  profile?: BulkScorecardProfile;
+}): Promise<BulkScorecardResponse> {
+  const resp = await fetch(`${BACKEND_URL}/api/scorecard/bulk`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      policy_ids: args.policy_ids,
+      profile: args.profile ?? null,
+    }),
+  });
+  if (!resp.ok) {
+    const t = await resp.text();
+    throw new Error(`scorecard/bulk failed: ${resp.status} ${t}`);
+  }
+  return resp.json();
+}
+
 export type PreExistingCondition =
   | "none"
   | "diabetes_or_hypertension"
@@ -385,6 +445,50 @@ export async function getProfileCompleteness(session_id?: string): Promise<Profi
   return resp.json();
 }
 
+export type PredictedPremiumBandResponse = {
+  min_inr: number;
+  median_inr: number;
+  max_inr: number;
+  sample_size: number;
+  assumed: boolean;
+};
+
+export async function getPredictedPremiumBand(
+  sessionId: string,
+): Promise<PredictedPremiumBandResponse> {
+  const qs = `?session_id=${encodeURIComponent(sessionId)}`;
+  const resp = await fetch(`${BACKEND_URL}/api/profile/predicted-premium-band${qs}`);
+  if (!resp.ok) throw new Error(`predicted premium band failed: ${resp.status}`);
+  return resp.json();
+}
+
+// KI-Z7 (2026-05-15) — Feature B. POST /api/profile/recall-by-name.
+// Asks the backend to look up a stored named-profile and hydrate the live
+// session_id with it. The chat path runs the same recall server-side on
+// turn 1, so this client helper is only needed for non-chat triggers (e.g.
+// the user types their name into the profile builder AFTER turn 1).
+export type RecallByNameResponse = {
+  found: boolean;
+  profile: Record<string, unknown> | null;
+  predicted_band:
+    | { min_inr: number; median_inr: number; max_inr: number; sample_size: number; assumed: boolean }
+    | null;
+  session_id: string;
+};
+
+export async function postProfileRecallByName(args: {
+  name: string;
+  session_id: string;
+}): Promise<RecallByNameResponse> {
+  const resp = await fetch(`${BACKEND_URL}/api/profile/recall-by-name`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: args.name, session_id: args.session_id }),
+  });
+  if (!resp.ok) throw new Error(`profile recall failed: ${resp.status}`);
+  return resp.json();
+}
+
 export async function postProfileUpdate(req: UserProfile & { session_id: string }): Promise<ProfileCompletenessResponse> {
   const resp = await fetch(`${BACKEND_URL}/api/profile`, {
     method: "POST",
@@ -421,6 +525,67 @@ export async function postPremiumEstimate(req: PremiumEstimateRequest): Promise<
 }
 
 
+// ---------------------------------------------------------------------------
+// /api/premium/bulk — multi-policy slider-driven calculator. Powers
+// PolicyPremiumWidget inside PolicyCompareModal.
+// ---------------------------------------------------------------------------
+
+export type PremiumBulkProfile = {
+  age?: number | null;
+  dependents?: string | null;
+  location_tier?: string | null;
+  family_size?: number | null;
+  smoker?: boolean | null;
+  pre_existing_conditions?: PreExistingCondition | null;
+};
+
+export type PremiumBulkOverride = {
+  sum_insured_inr?: number;
+  tenure_years?: number;
+  deductible_inr?: number;
+};
+
+export type PremiumBulkRequest = {
+  policy_ids: string[];
+  profile?: PremiumBulkProfile;
+  overrides?: Record<string, PremiumBulkOverride>;
+};
+
+export type PremiumBulkRow = {
+  policy_id: string;
+  premium_inr_annual: number;
+  breakdown: Record<string, number | string>;
+  sum_insured_inr: number;
+  tenure_years: number;
+  deductible_inr: number;
+  assumed: boolean;
+  notes: string[];
+};
+
+export type PremiumBulkResponse = {
+  per_policy: Record<string, PremiumBulkRow>;
+  profile_used: PremiumBulkProfile;
+  disclaimer: string;
+};
+
+export async function postPremiumBulk(req: PremiumBulkRequest): Promise<PremiumBulkResponse> {
+  const resp = await fetch(`${BACKEND_URL}/api/premium/bulk`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      policy_ids: req.policy_ids,
+      profile: req.profile ?? {},
+      overrides: req.overrides ?? {},
+    }),
+  });
+  if (!resp.ok) {
+    const t = await resp.text();
+    throw new Error(`premium bulk failed: ${resp.status} ${t}`);
+  }
+  return resp.json();
+}
+
+
 // KI-020 — User-facing chat clear / session restart.
 export interface SessionResetResponse {
   ok: boolean;