fix(single_brain): KI-245..KI-246 — Z6 + W2 bundle (3 bugs + 6 prompt edges)

Z6 — 3 bugs from smoke_v_final:
- Bug A (BLOCKER): "no PED" not captured. RULE 1 health_conditions bullet now
explicitly mandates save_profile_field(health_conditions, "none") on
"no medical issues" / "I'm healthy" / "no PED" etc. + Worked Example B.
Without this the profile stayed incomplete forever and the bot looped.
- Bug B (BLOCKER): mid-session "JSON parse error" smoke trace.
ROOT CAUSE: single_brain.TurnResult.citations dicts don't carry
page_start/page_end fields that CitationOut(pydantic) requires; the
`[CitationOut(**c) for c in turn.citations]` line raised ValidationError
whenever retrieval succeeded, and FastAPI returned its raw 422 envelope
which the smoke test rendered as "the bot reply". Fix: (1) RequestValidationError
handler scoped to /api/chat returns ChatResponse-shaped 200 envelope
instead of raw 422; (2) response-build path now wrapped in try/except
with each citation built field-by-field with page_start/page_end
defaulted to 0. malformed cites are dropped + logged.
- Bug C: hallucinated policy names (Anita T4 "Star Health Family Health
Optima" without retrieve_policies result). ABSOLUTE RULE block listing
forbidden brand tokens added near the top of SYSTEM_PROMPT +
_scan_for_brand_hallucinations debug logger fires WARNING when reply
contains brand string but session.last_retrieved_chunks is empty.

W2 — 6 SYSTEM_PROMPT edge cases:
- RULE 4: returning-user greeting (4-step protocol: greet by name,
summarise, ask "has anything changed?", WAIT before retrieve)
- RULE 5: comparison view ("compare #1 and #3") — single retrieve_policies
call with both policy_filter_ids + markdown side-by-side table with
per-cell citations
- RULE 6: out-of-scope refusal (life/term/ULIP/motor/home/travel/MF) with
canned redirect + explicit no-retrieve
- RULE 7: soft close (mark_recommendation is_final=true on user choice +
offer purchase walkthrough or summary)
- RULE 1 primary_goal: expanded 1-line bullet to 4-row mapping table
covering "switching from corporate", "lost employer cover", "too
expensive" (new cost_optimize value), "Section 80D"
- RULE 8: Indic-language mirroring (Hindi/Marathi/Tamil/Telugu/etc.) —
mirror user's language for prose, keep tool args in English, keep
citation format canonical

Note: cost_optimize is a new primary_goal enum that Path B accepts via
brain_tools pass-through. Legacy normalizer (sales_brain_normalizer)
won't recognize it; OK because legacy path is only reached on first-turn
503 fallback.

SYSTEM_PROMPT char count: 9666 / 10000 budget (~2416 tokens / ~2500 budget).

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

backend/main.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from typing import Optional
 
 from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
+from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
@@ -196,6 +197,50 @@ app.add_middleware(
 )
 
 
+# Bug B (2026-05-15) — /api/chat raw 422 leak. Live smoke saw the frontend
+# render `{"detail":[{"type":"missing","loc":["body","user_text"]...}]}` as
+# the bot reply because a malformed POST (missing user_text) hit FastAPI's
+# default RequestValidationError handler — that body bypasses our
+# ChatResponse envelope and the frontend has no shape-mapping for it.
+# We intercept the chat endpoint specifically and return a clean
+# ChatResponse-shaped JSON so frontend parsing never errors out. Other
+# endpoints keep FastAPI's default 422 behaviour (which their callers
+# already handle).
+@app.exception_handler(RequestValidationError)
+async def _validation_exception_handler(request: Request, exc: RequestValidationError):
+    if request.url.path == "/api/chat":
+        logging.warning(
+            "chat endpoint received malformed body — returning graceful "
+            "ChatResponse-shaped 200 instead of raw 422. errors=%r",
+            exc.errors()[:3],
+        )
+        return JSONResponse(
+            status_code=200,
+            content={
+                "reply_text": (
+                    "Sorry, something went wrong — try again."
+                ),
+                "citations": [],
+                "brain_used": "error_fallback",
+                "intent": "qa",
+                "language": "en",
+                "latency_ms": 0,
+                "session_id": "",
+                "audio_base64": None,
+                "audio_mime": None,
+                "faithfulness_passed": True,
+                "faithfulness_reasons": [],
+                "blocked": False,
+                "profile_updates": {},
+            },
+        )
+    # Default behaviour for every other endpoint.
+    return JSONResponse(
+        status_code=422,
+        content={"detail": exc.errors()},
+    )
+
+
 # ---------- Admin panel + LLM health background loop ----------
 # Mount the password-gated admin endpoints (KI-097). Unauthorized callers
 # get 401 Unauthorized. The earlier IP allowlist gate (ADMIN_IP_ALLOWLIST +
@@ -233,6 +278,28 @@ async def _startup_llm_health_probe():
     asyncio.create_task(llm_health.background_probe_loop())
 
 
+@app.on_event("startup")
+async def _startup_single_brain_warmup():
+    """Pre-warm the Gemini single-brain connection so the FIRST /api/chat turn
+    doesn't eat 4-5s of cold-start latency (TLS + auth + cache init).
+
+    Wrapped in try/except — warmup is an optimization, not a boot
+    requirement. A failed warmup must NEVER crash the server.
+    """
+    try:
+        from backend import single_brain
+        latency = await single_brain.warmup()
+        if latency is not None:
+            logging.info(
+                "single_brain warmup completed at boot (%.2fs)", latency,
+            )
+    except Exception as e:  # noqa: BLE001
+        logging.warning(
+            "single_brain warmup raised at top level (%s: %s) — boot continues",
+            type(e).__name__, e,
+        )
+
+
 async def _startup_purge_dangling_profile_chunks():
     """KI-117 — boot-time self-heal of dangling `doc_type='profile'` chunks.
 
@@ -607,36 +674,98 @@ async def chat(req: ChatRequest, request: Request):
             log_turn({"session_id": session_id, "tts_error": f"{type(e).__name__}: {e}"})
             audio_mime = None
 
-    log_turn({
-        "session_id": session_id,
-        "user_text": req.user_text,
-        "reply_text": turn.reply_text,
-        "brain_used": turn.brain_used,
-        "intent": turn.intent,
-        "language": turn.language,
-        "latency_ms": turn.latency_ms,
-        "retrieved_chunk_ids": turn.retrieved_chunk_ids,
-        "citation_count": len(turn.citations),
-        "faithfulness_passed": turn.faithfulness_passed,
-        "faithfulness_reasons": turn.faithfulness_reasons,
-        "blocked": turn.blocked,
-    })
-
-    return ChatResponse(
-        reply_text=turn.reply_text,
-        citations=[CitationOut(**c) for c in turn.citations],
-        brain_used=turn.brain_used,
-        intent=turn.intent,
-        language=turn.language,
-        latency_ms=turn.latency_ms,
-        session_id=session_id,
-        audio_base64=audio_b64,
-        audio_mime=audio_mime,
-        faithfulness_passed=turn.faithfulness_passed,
-        faithfulness_reasons=turn.faithfulness_reasons,
-        blocked=turn.blocked,
-        profile_updates=turn.profile_updates,
-    )
+    try:
+        log_turn({
+            "session_id": session_id,
+            "user_text": req.user_text,
+            "reply_text": turn.reply_text,
+            "brain_used": turn.brain_used,
+            "intent": turn.intent,
+            "language": turn.language,
+            "latency_ms": turn.latency_ms,
+            "retrieved_chunk_ids": turn.retrieved_chunk_ids,
+            "citation_count": len(turn.citations),
+            "faithfulness_passed": turn.faithfulness_passed,
+            "faithfulness_reasons": turn.faithfulness_reasons,
+            "blocked": turn.blocked,
+        })
+    except Exception:  # noqa: BLE001 — log IO must never block a reply
+        pass
+
+    # 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,
+    # doc_type, source_url, score}). Without this normalisation the
+    # Pydantic constructor below would raise ValidationError, the
+    # exception would escape /api/chat, and FastAPI would return a raw
+    # 500 (or its default JSON error envelope) that the frontend can't
+    # parse as a ChatResponse. We patch every citation dict to satisfy
+    # CitationOut's required fields and wrap the whole response build in
+    # an explicit try/except so a malformed citation can never silently
+    # bypass our envelope.
+    try:
+        safe_citations: list[CitationOut] = []
+        for c in turn.citations or []:
+            if not isinstance(c, dict):
+                continue
+            try:
+                safe_citations.append(
+                    CitationOut(
+                        policy_id=str(c.get("policy_id", "") or ""),
+                        policy_name=str(c.get("policy_name", "") or ""),
+                        insurer_slug=str(c.get("insurer_slug", "") or ""),
+                        page_start=int(c.get("page_start", 0) or 0),
+                        page_end=int(c.get("page_end", 0) or 0),
+                        source_url=str(c.get("source_url", "") or ""),
+                        score=float(c.get("score", 0.0) or 0.0),
+                    )
+                )
+            except Exception as _cite_err:  # noqa: BLE001
+                logging.warning(
+                    "drop malformed citation (session=%s): %s — payload=%r",
+                    session_id, _cite_err, c,
+                )
+
+        return ChatResponse(
+            reply_text=turn.reply_text,
+            citations=safe_citations,
+            brain_used=turn.brain_used,
+            intent=turn.intent,
+            language=turn.language,
+            latency_ms=turn.latency_ms,
+            session_id=session_id,
+            audio_base64=audio_b64,
+            audio_mime=audio_mime,
+            faithfulness_passed=turn.faithfulness_passed,
+            faithfulness_reasons=turn.faithfulness_reasons,
+            blocked=turn.blocked,
+            profile_updates=turn.profile_updates,
+        )
+    except Exception as _resp_err:  # noqa: BLE001
+        # Anything else (TypeError/AttributeError/ValidationError) on the
+        # response-build path — return the standard error_fallback shape
+        # so the frontend always parses cleanly. Bug B catch-all.
+        logging.exception(
+            "chat response-build failed (session=%s): %s",
+            session_id, _resp_err,
+        )
+        return ChatResponse(
+            reply_text=(
+                "Sorry, something went wrong — try again"
+            ),
+            citations=[],
+            brain_used="error_fallback",
+            intent="qa",
+            language="en",
+            latency_ms=int((time.time() - t_chat0) * 1000),
+            session_id=session_id,
+            audio_base64=None,
+            audio_mime=None,
+            faithfulness_passed=True,
+            faithfulness_reasons=[],
+            blocked=False,
+            profile_updates={},
+        )
 
 
 @app.get("/api/coverage", response_model=CoverageResponse)

backend/single_brain.py

@@ -76,6 +76,26 @@ 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,
+Tata AIG, etc.) UNLESS:
+  (a) retrieve_policies returned that exact policy_id in the current
+      session, AND
+  (b) you cite it in the format [Source: Policy Name (insurer), UIN].
+
+If the user asks about a specific policy and you have NO retrieve_policies
+result for it, say "I don't have that policy in my recommendations — let
+me search for it" and call retrieve_policies with the policy name as the
+query, top_k=1, policy_filter_ids=None.
+
+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
 ═══════════════════════════════════════════════════════════
@@ -87,10 +107,18 @@ of these facts and call save_profile_field ONCE PER FACT:
        (metro = Bangalore/Mumbai/Delhi/Chennai/Hyderabad/Kolkata/Pune/Ahmedabad)
   • Family members ("wife", "husband", "kid", "parents") → save_profile_field(field="dependents", value="...")
   • Income / salary / lakhs → save_profile_field(field="income_band", value="10L-25L" or similar)
-  • "First policy" / "upgrade" / "tax planning" → save_profile_field(field="primary_goal", value="first_buy" or "upgrade" or "tax_planning")
-  • "diabetes" / "BP" / "no health issues" → save_profile_field(field="health_conditions", value="diabetes" or "" or "none")
-
-Worked example. User says: "Hi I'm Priya, 34, Bangalore, with husband and one kid"
+  • Primary-goal natural phrasings → save_profile_field(field="primary_goal", value=...):
+       "first policy" / "switching from corporate" / "leaving job" / "lost employer cover" → first_buy
+       "upgrade" / "better coverage" / "more cover" / "increase sum insured" → upgrade
+       "save tax" / "Section 80D" / "tax benefit" → tax_planning
+       "too expensive" / "cheaper option" / "premium too high" → cost_optimize
+  • "diabetes" / "BP" / pre-existing conditions → save_profile_field(field="health_conditions", value="diabetes" or "BP, thyroid")
+  • "no health issues" / "no medical issues" / "no PED" / "nothing" / "I'm healthy" / "no conditions" / "all good" →
+        save_profile_field(field="health_conditions", value="none")
+        ← MANDATORY even though it's a negation. "none" tells the system the slot is captured.
+        Without this call the profile stays incomplete forever and the bot loops asking for PED.
+
+Worked example A. User says: "Hi I'm Priya, 34, Bangalore, with husband and one kid"
   → You MUST call:
        save_profile_field(field="name",            value="Priya")
        save_profile_field(field="age",             value="34")
@@ -98,6 +126,12 @@ Worked example. User says: "Hi I'm Priya, 34, Bangalore, with husband and one ki
        save_profile_field(field="dependents",      value="self+spouse+1 kid")
   → THEN write a short prose reply asking for the remaining slots (income, goal, health).
 
+Worked example B (negation — DO NOT SKIP). User says: "No medical issues"
+  → You MUST call:
+       save_profile_field(field="health_conditions", value="none")
+  → No exceptions. The same applies to "no health issues", "no PED",
+    "nothing", "I'm healthy", "no conditions", "all good".
+
 NEVER ask the user for a fact you can already extract from their last message. Capture FIRST, then ask only for what's missing.
 
 ═══════════════════════════════════════════════════════════
@@ -124,6 +158,69 @@ 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:
+  1. Greet by name: "Welcome back, [name]!"
+  2. Summarise what you remember in 1-2 short bullets (e.g. age, city,
+     dependents, primary_goal, health_conditions).
+  3. Ask: "Has anything changed since last time, or should we go with this
+     profile?"
+  4. WAIT for explicit user confirmation BEFORE calling retrieve_policies.
+Do NOT skip the confirmation step even if all 7 slots look complete.
+
+═══════════════════════════════════════════════════════════
+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"):
+  1. Call retrieve_policies(policy_filter_ids=[id_of_A, id_of_B], top_k=4)
+     in ONE call so both policies' chunks come back together.
+  2. Produce an explicit side-by-side comparison — markdown table with
+     columns | Feature | Policy A | Policy B | OR paired bullets
+     ("Sum insured: A = ₹10L, B = ₹15L"). Cover at minimum: sum insured,
+     premium, room rent, PED waiting period, key exclusions.
+  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,
+politely refuse and redirect:
+  "I specialise in Indian health insurance — for [life / car / ULIP / etc.],
+   you'd want a different advisor. Anything else I can help with on health
+   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"):
+  1. Call mark_recommendation(policy_ids=[chosen_id], is_final=true).
+  2. Offer next steps in one short reply:
+     "Great choice! Would you like me to walk you through the purchase
+      steps, or summarise the key benefits one more time?"
+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
+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
 ═══════════════════════════════════════════════════════════
@@ -131,7 +228,6 @@ GROUND RULES
 - 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.
 - Indian context: use lakh / crore, ₹, IRDAI, Section 80D. NEVER say "dollars" / "$".
-- Returning users may have a pre-populated profile — greet them by name, summarise what you remember, ask to confirm or update.
 """
 
 
@@ -523,6 +619,72 @@ async def _gemini_call(
     )
 
 
+# ---------- boot warmup -----------------------------------------------------
+
+
+async def warmup() -> Optional[float]:
+    """Pre-warm the Gemini connection on FastAPI startup.
+
+    The first real /api/chat turn carries 4-5s of cold-start latency:
+    HTTPS connection establishment, TLS handshake, Gemini auth, and the
+    first response cache init. Firing a tiny dummy request at boot pushes
+    that cost off the user's critical path.
+
+    Conditional on USE_SINGLE_BRAIN: if the flag is off, the cold start
+    will never matter because single_brain.handle_turn won't run; skip.
+
+    Returns the wall-clock latency in seconds on success, None on skip or
+    failure. Never raises — the caller (boot hook) treats any failure as
+    a non-fatal warning.
+    """
+    flag = os.environ.get("USE_SINGLE_BRAIN", "false").strip().lower()
+    if flag not in ("1", "true", "yes", "on"):
+        _log.info("single_brain.warmup skipped — USE_SINGLE_BRAIN is off")
+        return None
+
+    api_key = os.environ.get("GOOGLE_API_KEY", "").strip()
+    if not api_key:
+        _log.warning("single_brain.warmup skipped — GOOGLE_API_KEY not set")
+        return None
+
+    model = _resolve_model()
+    url = f"{GEMINI_BASE_URL}/{model}:generateContent?key={api_key}"
+    body = {
+        "systemInstruction": {"parts": [{"text": "warmup ping"}]},
+        "contents": [{"role": "user", "parts": [{"text": "ping"}]}],
+        "generationConfig": {"maxOutputTokens": 10},
+    }
+    headers = {"Content-Type": "application/json"}
+    client_timeout = httpx.Timeout(connect=2.0, read=8.0, write=2.0, pool=2.0)
+
+    t0 = time.perf_counter()
+    try:
+        async with httpx.AsyncClient(timeout=client_timeout) as client:
+            resp = await client.post(url, headers=headers, json=body)
+        elapsed = time.perf_counter() - t0
+        if resp.status_code >= 400:
+            _log.warning(
+                "single_brain.warmup non-2xx (HTTP %d, %.2fs) — boot continues",
+                resp.status_code, elapsed,
+            )
+            return elapsed
+        # Discard payload; we only care about latency + that the round-trip
+        # succeeded so the next real call hits a warm socket + auth cache.
+        _ = resp.text
+        _log.info(
+            "single_brain.warmup OK (model=%s, latency=%.2fs)",
+            model, elapsed,
+        )
+        return elapsed
+    except Exception as e:  # noqa: BLE001
+        elapsed = time.perf_counter() - t0
+        _log.warning(
+            "single_brain.warmup failed after %.2fs (%s: %s) — boot continues",
+            elapsed, type(e).__name__, str(e)[:200],
+        )
+        return None
+
+
 def _extract_parts(payload: dict) -> list[dict]:
     """Pull the `parts` list out of the first candidate. Empty list on
     any missing-key path so the caller decides what to do."""
@@ -548,6 +710,49 @@ def _parts_text(parts: list[dict]) -> str:
     )
 
 
+# Bug C defensive detector. Brands/products that MUST come from a
+# retrieve_policies result. If the bot emits any of these in its reply
+# while session.last_retrieved_chunks is empty, log a WARNING so future
+# smoke logs can flag hallucinations. Detection-only — does NOT block.
+_BRAND_HALLUCINATION_TOKENS = (
+    "star health", "hdfc ergo", "niva bupa", "max bupa", "care health",
+    "aditya birla", "icici lombard", "bajaj allianz", "manipal cigna",
+    "manipalcigna", "acko", "go digit", "godigit", "reliance general",
+    "sbi general", "tata aig", "iffco tokio", "cholamandalam",
+    "national insurance", "new india assurance", "oriental insurance",
+    "united india", "family health optima", "optima secure",
+    "reassure", "health companion", "easy health", "activ health",
+    "health advantedge", "complete health",
+)
+
+
+def _scan_for_brand_hallucinations(reply_text: str, session) -> None:
+    """If the bot mentions an insurer/product brand but session has no
+    retrieved chunks, log a WARNING. Detection-only (Bug C secondary
+    defense — the system-prompt rule is primary). Swallow any
+    exception — bookkeeping must never break a chat turn.
+    """
+    try:
+        if not reply_text:
+            return
+        last_chunks = getattr(session, "last_retrieved_chunks", None) or []
+        if last_chunks:
+            return  # retrieve_policies has run; brand mentions are sourced
+        haystack = reply_text.lower()
+        hits = [tok for tok in _BRAND_HALLUCINATION_TOKENS if tok in haystack]
+        if hits:
+            _log.warning(
+                "single_brain possible policy hallucination — "
+                "reply mentions brand(s)=%r but session.last_retrieved_chunks "
+                "is empty. session=%s reply_snippet=%r",
+                hits,
+                getattr(session, "session_id", "?"),
+                reply_text[:200],
+            )
+    except Exception:  # noqa: BLE001 — observational only
+        pass
+
+
 def _parts_function_calls(parts: list[dict]) -> list[dict]:
     """Pull every functionCall block out of parts. Each entry is
     {"name": "...", "args": {...}}."""
@@ -739,6 +944,13 @@ async def handle_turn(
         "Sorry — I lost my train of thought there. Could you say that again?"
     )
 
+    # Bug C secondary defense — log a WARNING if the reply name-drops an
+    # insurer/product brand even though no retrieve_policies result was
+    # cached on the session. The system-prompt ABSOLUTE RULE is the
+    # primary defense; this only exists so a future regression shows up
+    # in smoke logs instead of going silent.
+    _scan_for_brand_hallucinations(reply_text, session)
+
     # Citations: deduped by chunk_id; same shape orchestrator emits.
     seen_ids: set[str] = set()
     citations: list[dict] = []