feat(llm-chain): KI-079 — Groq earlier in FAST_BRAIN_CHAIN + escalate to BRAIN_CHAIN on timeout before canonical fallback

Live 10-turn probe (commit 078ff45) showed 7/10 fact-find turns timing
out at exactly 26.6s with _fallback_reason="timeout" — ALL failures are
real timeouts, not parse errors. Root cause: FAST_BRAIN_CHAIN's first 5
candidates were all NIM-hosted; under NIM per-key concurrency limits
they queued together and the chain burned its 22s total_budget_s inside
NIM before reaching Groq Llama-3.3 70B at the chain bottom.

FIX 1 (nvidia_nim_llm.py)
- Move groq:llama-3.3-70b-versatile from FAST_BRAIN_CHAIN[5] (last) to
FAST_BRAIN_CHAIN[1] (right after Nemotron primary). All other
candidates kept. Nemotron remains primary (KI-035 latency win).
- New worst-case time-to-cross-provider on a NIM hang: ~6-7s (per-link
6s timeout × 1 link) vs the prior ~22s.

FIX 2 (fact_find_brain.py)
- Add _TIMEOUT_S_ESCALATION = 15.0 alongside existing _TIMEOUT_S = 25.0.
- On asyncio.TimeoutError from FAST_BRAIN_CHAIN, escalate ONCE to
get_brain_llm() (BRAIN_CHAIN — Qwen 80B primary + 8 fallbacks incl.
OpenRouter + Groq) inside a shorter 15s budget before falling to the
canonical-question fallback. New _fallback_reason values:
"timeout_after_escalation" and "llm_error_after_escalation" — the
KI-078 telemetry stamp already wires these into brain_used.
- Worst-case end-to-end wall time before canonical: 25 + 15 = 40s, but
realistic escalation-success path lands in 3-8s because the heavy
brain hits a different NIM pool primary (Qwen 80B) and falls through
to OpenRouter / Groq on its own.

NOT TOUCHED
- _TIMEOUT_S = 25.0 (kept; KI-079 is additive)
- KI-074 greedy multi-slot canonical fallback
- frontend/**
- CLAUDE.md, 80-audit/ENTERPRISE_AUDIT.md (separate sync commit)

VERIFICATION
- python3 -m py_compile both files: OK
- Inline test: FactFindOutcome accepts both new _fallback_reason values
- Inline test: FAST_BRAIN_CHAIN[0:3] = ['nvidia/nemotron-3-nano-30b-a3b',
'groq:llama-3.3-70b-versatile', 'qwen/qwen3-next-80b-a3b-instruct']
- pytest tests/test_routing_regression.py -x -q: 15 passed, 13 subtests

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

backend/fact_find_brain.py

@@ -59,11 +59,17 @@ class FactFindOutcome:
     # bailed and `_canonical_fallback` was used, this stamps WHY so the
     # orchestrator can append it to `brain_used` and admin telemetry can
     # measure the fallback-reason mix. One of:
-    #   "timeout"     — asyncio.wait_for(_TIMEOUT_S) expired
-    #   "llm_error"   — chain raised (non-timeout) before returning
+    #   "timeout"     — asyncio.wait_for(_TIMEOUT_S) expired on FAST_BRAIN_CHAIN
+    #   "llm_error"   — FAST_BRAIN_CHAIN raised (non-timeout) before returning
     #   "no_trailer"  — reply had no <FF>...</FF> JSON block, or it failed parse
     #   "empty_reply" — trailer stripped to an empty user-facing reply
-    # None when the brain succeeded.
+    # KI-079 (2026-05-15) — added two escalation-path reasons. When FAST
+    # chain times out we re-try once against BRAIN_CHAIN (heavier; Qwen 80B
+    # primary, more cross-provider fallbacks) inside a shorter budget. The
+    # _fallback_reason then captures the escalation outcome:
+    #   "timeout_after_escalation"   — both FAST + BRAIN chains timed out
+    #   "llm_error_after_escalation" — BRAIN chain raised on the retry
+    # None when the brain succeeded (either FAST primary OR BRAIN escalation).
     _fallback_reason: Optional[str] = None
 
 
@@ -293,7 +299,15 @@ def _bump_brain_history(session, slot_driving: Optional[str]) -> int:
 # after a Space rebuild; the 12s wait_for was killing the brain BEFORE
 # the cross-provider fallback links (Groq, OpenRouter) ever got tried.
 # 25s gives NIM cold-start headroom + leaves room for one chain fallback.
-_TIMEOUT_S = 25.0
+_TIMEOUT_S = 25.0             # FAST_BRAIN_CHAIN primary attempt budget
+# KI-079 (2026-05-15) — if FAST exhausted, try BRAIN_CHAIN (Qwen 80B primary
+# + more cross-provider fallbacks incl. OpenRouter + Groq) with a SHORTER
+# budget so the user doesn't wait 25+15=40s on a fully-dead network. Total
+# worst-case latency before canonical fallback: 25 + 15 = 40s, but the FAST
+# chain only hits 25s when NIM is wedged — the BRAIN escalation then has a
+# Qwen primary on a different NIM pool + OpenRouter + Groq, so realistic
+# escalation success cases land in 3-8s.
+_TIMEOUT_S_ESCALATION = 15.0
 
 
 async def drive_fact_find(
@@ -345,19 +359,47 @@ async def drive_fact_find(
                 messages.append(ChatMessage(role=role, content=content))
     messages.append(ChatMessage(role="user", content=user_text or ""))
 
-    # Hard 12-second timeout. The fast-brain chain already has its own budget
-    # but we wrap with asyncio.wait_for as a belt-and-braces stop.
-    llm = get_fast_brain_llm()
+    # Hard 25-second timeout on FAST_BRAIN_CHAIN. The fast-brain chain already
+    # has its own per-link + total-chain budget but we wrap with asyncio.wait_for
+    # as a belt-and-braces stop.
+    llm_fast = get_fast_brain_llm()
     try:
         result = await asyncio.wait_for(
-            llm.chat(messages=messages, temperature=0.6, max_tokens=420),
+            llm_fast.chat(messages=messages, temperature=0.6, max_tokens=420),
             timeout=_TIMEOUT_S,
         )
     except asyncio.TimeoutError:
+        # KI-079 (2026-05-15) — fast brain timed out. Before falling to the
+        # canonical-question fallback, escalate ONCE to BRAIN_CHAIN (Qwen 80B
+        # primary, more cross-provider fallbacks) with a shorter budget so the
+        # user doesn't wait 25+15=40s on a dead network.
         logging.warning(
-            "fact_find_brain timeout (session=%s, %.1fs)", session_id, time.time() - t0
+            "KI-079: fast brain timeout (session=%s, %.1fs) → escalating to heavy brain",
+            session_id, time.time() - t0,
         )
-        return _canonical_fallback(session, user_text, reason="timeout")
+        from backend.providers.nvidia_nim_llm import get_brain_llm
+        llm_heavy = get_brain_llm()
+        try:
+            result = await asyncio.wait_for(
+                llm_heavy.chat(messages=messages, temperature=0.6, max_tokens=420),
+                timeout=_TIMEOUT_S_ESCALATION,
+            )
+        except asyncio.TimeoutError:
+            logging.warning(
+                "KI-079: heavy brain ALSO timed out (session=%s, total=%.1fs)",
+                session_id, time.time() - t0,
+            )
+            return _canonical_fallback(
+                session, user_text, reason="timeout_after_escalation"
+            )
+        except Exception as e2:
+            logging.warning(
+                "KI-079: heavy brain escalation failed (session=%s): %s: %s",
+                session_id, type(e2).__name__, str(e2)[:200],
+            )
+            return _canonical_fallback(
+                session, user_text, reason="llm_error_after_escalation"
+            )
     except Exception as e:
         logging.warning(
             "fact_find_brain LLM call failed (session=%s): %s: %s",

backend/providers/nvidia_nim_llm.py

@@ -226,14 +226,25 @@ FAST_BRAIN_CHAIN = [
     # TTFT, not capability. Nemotron Nano 30B hits ~1.6s; Qwen 80B is
     # ~2-3s. Moved Nemotron to primary; Qwen 80B stays as next fallback so
     # if Nemotron's NIM pool degrades we still get quality.
+    #
+    # KI-079 (2026-05-15) — moved Groq Llama-3.3 70B from chain bottom to
+    # candidate #2 (right after Nemotron primary). Live 10-turn probe
+    # (commit 078ff45) showed 7/10 fact-find turns timing out at 26.6s with
+    # _fallback_reason="timeout" — ALL the slow links were NIM-hosted, so
+    # NIM per-key concurrency had them queueing together and the chain
+    # burned its 22s total_budget_s inside NIM before ever reaching Groq.
+    # With Groq as #2, a Nemotron hang (~6s per-link timeout) falls
+    # through to Groq's LPU (~0.3s TTFT) in ~6-7s total — well inside the
+    # 22s chain budget AND the 25s wait_for cap.
     "nvidia/nemotron-3-nano-30b-a3b",     # ~1.6s TTFT (Reddit bench), NIM
+    # CROSS-PROVIDER FALLBACK #1 — Groq Llama-3.3 70B (LPU, lowest TTFT of
+    # all free-tier options). Promoted to #2 in KI-079 so a single NIM
+    # degradation falls through to a non-NIM provider in ~6s, not 22s.
+    "groq:llama-3.3-70b-versatile",
     "qwen/qwen3-next-80b-a3b-instruct",   # ~2-3s, NIM
     "openai/gpt-oss-120b",
     "qwen/qwen3.5-122b-a10b",
     "deepseek-ai/deepseek-v4-flash",
-    # CROSS-PROVIDER FALLBACK — Groq Llama-3.3 70B (LPU, lowest TTFT of all
-    # free-tier options; OK for a fast-brain call when NIM is down).
-    "groq:llama-3.3-70b-versatile",
 ]
 
 # Judge chain — non-Qwen, non-DeepSeek (different family from brain primary)