Deploy: Stack A (NIM brain + Maverick judge + Sarvam voice). D-019.

backend/faithfulness.py

@@ -192,7 +192,20 @@ Be strict. The bot's job is to NOT hallucinate. If a claim is ambiguously suppor
 """
 
 
-async def _gate_llm_judge(reply: str, chunks: list[RetrievedChunk]) -> tuple[bool, list[str]]:
+async def _gate_llm_judge(
+    reply: str,
+    chunks: list[RetrievedChunk],
+    brain_model_used: Optional[str] = None,
+) -> tuple[bool, list[str]]:
+    """LLM judge for faithfulness Gate 4 with cross-family independence guard.
+
+    `brain_model_used` is the EXACT model id that produced `reply` (e.g.
+    'qwen/qwen3-next-80b-a3b-instruct'). It and its family are excluded from
+    the judge's chain so the brain never grades its own homework. If the
+    exclusion would empty the chain, NimChainLLM relaxes the family
+    constraint but still enforces exact-model exclusion — strictly weaker
+    than letting the same model grade itself.
+    """
     if not reply or len(reply) < 30:
         return True, []
     if not chunks:
@@ -209,6 +222,17 @@ REPLY:
 
 Verify."""
 
+    # Compute exclusion set for cross-grading independence
+    exclude_models: list[str] = []
+    exclude_families: list[str] = []
+    if brain_model_used:
+        exclude_models.append(brain_model_used)
+        try:
+            from backend.providers.nvidia_nim_llm import NimChainLLM
+            exclude_families.append(NimChainLLM._family_of(brain_model_used))
+        except Exception:
+            pass  # family helper unavailable → still enforce exact-model exclusion
+
     try:
         judge = _get_judge()
         res = await judge.chat(
@@ -219,6 +243,8 @@ Verify."""
             temperature=0.0,
             max_tokens=400,
             response_format={"type": "json_object"},
+            exclude_models=exclude_models or None,
+            exclude_families=exclude_families or None,
         )
         data = json.loads(res.text)
         supported = bool(data.get("supported", False))
@@ -244,8 +270,14 @@ async def check_faithfulness(
     chunks: list[RetrievedChunk],
     user_text: str = "",
     run_llm_judge: bool = True,
+    brain_model_used: Optional[str] = None,
 ) -> FaithfulnessVerdict:
-    """Run all gates. Return verdict with reasons + a safe reply to show user if blocked."""
+    """Run all gates. Return verdict with reasons + a safe reply to show user if blocked.
+
+    `brain_model_used` is forwarded to Gate 4 so the judge can never be the
+    same model (or same family) as the brain that produced `reply` —
+    enforces the cross-grading independence invariant.
+    """
     verdict = FaithfulnessVerdict(passed=True)
 
     # Gate 1 — retrieval floor
@@ -280,7 +312,7 @@ async def check_faithfulness(
     HIGH_CONFIDENCE_FLOOR = 0.50
     top_score = max((c.score for c in chunks), default=0.0) if chunks else 0.0
     if verdict.passed and run_llm_judge and top_score < HIGH_CONFIDENCE_FLOOR:
-        ok4, unsupported = await _gate_llm_judge(reply, chunks)
+        ok4, unsupported = await _gate_llm_judge(reply, chunks, brain_model_used=brain_model_used)
         if not ok4:
             verdict.passed = False
             verdict.reasons.append("gate4_llm_judge: claims unsupported")

backend/orchestrator.py

@@ -238,6 +238,11 @@ async def handle_turn(
     raw = llm_result.text
     reply = strip_think_tags(raw)
 
+    # Capture the EXACT model that produced the reply — flows into the
+    # faithfulness LLM-judge so it can never grade its own homework
+    # (same model OR same family is excluded from the judge chain).
+    brain_model_actual = getattr(llm_result, "model", None) or getattr(pick.provider, "model", None)
+
     # 5. FAITHFULNESS GATE — every reply runs through 4-gate verification.
     #    If any gate fails, replace the reply with a safe refusal. The original
     #    blocked reply is logged to logs/hallucinations.jsonl for audit.
@@ -246,6 +251,7 @@ async def handle_turn(
         chunks=chunks,
         user_text=user_text,
         run_llm_judge=True,
+        brain_model_used=brain_model_actual,
     )
 
     # 5a. CROSS-CHECK RETRY — if faithfulness blocked AND the failure isn't
@@ -262,8 +268,11 @@ async def handle_turn(
                 secondary = NvidiaNimLLM(model=NIM_JUDGE_MODEL)
                 second = await secondary.chat(messages=messages, temperature=0.1, max_tokens=1500)
                 second_reply = strip_think_tags(second.text)
+                # Cross-check brain was NIM_JUDGE_MODEL — pass its id so the
+                # judge for THIS retry also excludes that model+family.
                 second_verdict = await check_faithfulness(
                     reply=second_reply, chunks=chunks, user_text=user_text, run_llm_judge=True,
+                    brain_model_used=getattr(second, "model", None) or NIM_JUDGE_MODEL,
                 )
                 if second_verdict.passed:
                     reply = second_reply

backend/providers/nvidia_nim_llm.py

@@ -311,21 +311,64 @@ class NimChainLLM(LLMProvider):
             )
         return NvidiaNimLLM(model=model_id, api_key=self.api_key, timeout=timeout)
 
+    @staticmethod
+    def _family_of(model_id: str) -> str:
+        """Coarse family bucket for cross-grading-independence checks.
+
+        Two models in the SAME family must never be paired as brain ↔ judge
+        because they share weights / training corpus / decision surface, so
+        the judge would effectively grade its own siblings' output.
+        Families: 'qwen', 'mistral', 'meta', 'openai', 'deepseek', 'moonshot',
+        'minimax', 'nvidia', 'unknown'.
+        """
+        m = model_id.lower()
+        # Strip provider prefix first so 'groq:llama-3.3-70b' → 'meta' (it IS Meta Llama)
+        if ":" in m:
+            m = m.split(":", 1)[1]
+        if "qwen" in m: return "qwen"
+        if "mistral" in m: return "mistral"
+        if "llama" in m or m.startswith("meta/"): return "meta"
+        if "gpt-oss" in m or m.startswith("openai/"): return "openai"
+        if "deepseek" in m: return "deepseek"
+        if "kimi" in m or m.startswith("moonshot"): return "moonshot"
+        if "minimax" in m: return "minimax"
+        if "nemotron" in m or m.startswith("nvidia/"): return "nvidia"
+        return "unknown"
+
     async def chat(
         self,
         messages: list[ChatMessage],
         temperature: float = 0.2,
         max_tokens: int = 1024,
         response_format: Optional[dict] = None,
+        exclude_models: Optional[list[str]] = None,
+        exclude_families: Optional[list[str]] = None,
     ) -> LLMResult:
+        # Apply caller's exclusion list FIRST (brain doesn't grade own homework).
+        # exclude_models: skip exact model IDs (handles same-model collision)
+        # exclude_families: skip everything in those families (handles weight-sharing siblings)
+        chain = self.chain
+        if exclude_models or exclude_families:
+            excl_m = set(exclude_models or [])
+            excl_f = set(exclude_families or [])
+            chain = [m for m in chain
+                     if m not in excl_m and self._family_of(m) not in excl_f]
+            if not chain:
+                # Every candidate excluded — relax family constraint, keep exact model
+                # constraint (the strict one). Better to use a same-family model than
+                # to fail the request entirely.
+                chain = [m for m in self.chain if m not in excl_m]
+
         # Filter out models known-down (from background probe loop). If all
         # models are down, filter_chain returns the full chain unchanged so
         # we still try — the infrastructure may have recovered between probes.
+        # Use the post-exclusion `chain` (NOT self.chain) so brain↔judge
+        # independence is preserved even after health filtering.
         try:
             from backend import llm_health
-            chain_to_try = llm_health.filter_chain(self.chain)
+            chain_to_try = llm_health.filter_chain(chain)
         except Exception:
-            chain_to_try = self.chain  # health monitor failure must never block calls
+            chain_to_try = chain  # health monitor failure must never block calls
 
         chain_primary = self.chain[0] if self.chain else None
         call_t0 = time.time()