feat(llm-chain): KI-087 — NIM-first election preference; non-NIM only when NIM pool empty

User architectural decision: NIM is the strategic free provider (ADR-019:
single-key, $0 cost, 110+ models, no daily token cap). Groq has a hard
100K tokens/day free-tier cap that we burned through today. OpenRouter
charges a real USD balance. Both should serve as **emergency fallback
only**, not as primary just because their probe latency is lower.

Pre-KI-087: election scored by `latency × success_rate`. Groq's 161ms
LPU TTFT consistently beat NIM's 500ms-1s, so every probe round elected
Groq as PRIMARY across all 3 chains. Result: every chat call hit Groq
first, ate Groq's daily TPD inside 50 turns, then started returning 429s.

KI-087: election now prefers ANY eligible NIM candidate over ALL non-NIM
candidates. Within the NIM pool, the standard latency × success_rate
score still picks the fastest healthy NIM model. Only when the NIM pool
is empty (every NIM model is down, degraded, or quota-exhausted via
KI-085 credit gating) does election fall through to Groq/OpenRouter as
primary.

BACKUP rule is unchanged in spirit: cross-provider against PRIMARY. So
when PRIMARY is NIM (typical), BACKUP is the best non-NIM candidate
(Groq / OpenRouter / Groq Llama-3.3) — the cross-provider safety net
survives KI-087.

Expected production impact:
- Brain success rate climbs from 30% → 80-95%. NIM under modest load
(post-KI-084 probe cuts) consistently answers in 4-5s, comfortably
under the 12s elected-call timeout.
- Groq daily TPD stops getting burned by election (probes no longer
use Groq except when NIM is wholly unavailable). Groq stays
viable as a TRUE emergency fallback for an actual NIM outage.
- OpenRouter USD balance preserved — no spurious paid calls when
NIM has free capacity.

Together with KI-080 (sticky election), KI-084 (probe overhead cut +
429 demote), KI-085 (proactive credit gating), KI-087 is the LLM-chain
architecture's final shape.

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

backend/admin.py

@@ -584,3 +584,250 @@ async def admin_performance(
         "usage_24h":  _read_usage_24h(),
         "snapshot_ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
     }
+
+
+# ---------------------------------------------------------------------------
+# /api/admin/llm-health — KI-086 LLM Health & Credits snapshot
+#
+# Surfaces KI-080..KI-085 telemetry on the existing admin "LLM Chain" tab so
+# the operator can see at a glance:
+#   - per-chain elected PRIMARY + BACKUP (KI-080)
+#   - each candidate's latest probe latency + success rate (KI-080)
+#   - credits remaining + unit + reset deadline (KI-085)
+#   - degraded-until window when a candidate was demoted on 429 (KI-084)
+#   - per-turn served-model distribution from the last N llm_usage.jsonl rows
+#
+# Response shape — three top-level keys (chains / candidates / recent_turns) +
+# a snapshot_ts. All durations on the wire are seconds-from-now (relative,
+# never absolute monotonic) so the frontend doesn't need to know the server's
+# monotonic clock origin.
+# ---------------------------------------------------------------------------
+
+
+# Map of the on-wire chain role name → human-friendly label. The roles
+# themselves match llm_health.get_primary() input strings exactly.
+_LLM_HEALTH_CHAIN_ROLES = ("brain", "fast_brain", "judge")
+
+
+def _chain_names_map() -> dict[str, list[str]]:
+    """Live (post-admin-override) chain config — read off the module so admin
+    reorders applied earlier in the same process are reflected immediately."""
+    from backend.providers import nvidia_nim_llm as nim
+    return {
+        "brain":      list(getattr(nim, "BRAIN_CHAIN", [])),
+        "fast_brain": list(getattr(nim, "FAST_BRAIN_CHAIN", [])),
+        "judge":      list(getattr(nim, "JUDGE_CHAIN", [])),
+    }
+
+
+def _seconds_until_monotonic(deadline: Optional[float]) -> Optional[float]:
+    """Convert a monotonic-time deadline (as stamped in ModelHealth) into a
+    seconds-from-now value the frontend can render as an ETA. Returns None
+    when the deadline is missing OR already in the past; the caller decides
+    how to render `None` vs `0`."""
+    if deadline is None:
+        return None
+    import time as _time
+    rem = deadline - _time.monotonic()
+    if rem <= 0:
+        return 0.0
+    return round(rem, 1)
+
+
+def _probe_age_seconds(iso_ts: Optional[str]) -> Optional[float]:
+    """Wall-clock seconds since a probe iso8601 timestamp. Cheap wrapper
+    around llm_health._iso_age_seconds for the wire payload."""
+    age = llm_health._iso_age_seconds(iso_ts)
+    if age is None:
+        return None
+    return max(0.0, round(age, 1))
+
+
+def _success_rate_for(h) -> Optional[float]:
+    """Last-N probes success rate as a float fraction. Returns None when no
+    probe history yet."""
+    hist = getattr(h, "probe_history", None) or []
+    if not hist:
+        return None
+    hits = sum(1 for r in hist if r.get("ok"))
+    return round(hits / len(hist), 4)
+
+
+def _candidate_snapshot(model: str, health, chain_membership: list[str],
+                        now_mono: float) -> dict:
+    """Per-candidate row for Section B. Always returns a dict — even when
+    the model has never been probed yet (status='unknown', everything else
+    None) — so the frontend table doesn't have to handle missing rows."""
+    if health is None:
+        return {
+            "model":              model,
+            "provider":           llm_health.provider_of(model),
+            "chain_membership":   chain_membership,
+            "status":             "unknown",
+            "latency_ms":         None,
+            "success_rate":       None,
+            "probe_age_seconds":  None,
+            "last_error":         None,
+            "credits_remaining":  None,
+            "credits_unit":       None,
+            "credits_low_water":  None,
+            "credits_reset_in_seconds": None,
+            "degraded_for_seconds":    None,
+        }
+    deg_until = getattr(health, "degraded_until_monotonic", 0.0) or 0.0
+    deg_for = None
+    if deg_until and deg_until > now_mono:
+        deg_for = round(deg_until - now_mono, 1)
+    return {
+        "model":             model,
+        "provider":          llm_health.provider_of(model),
+        "chain_membership":  chain_membership,
+        "status":            health.status,
+        "latency_ms":        health.latency_ms,
+        "success_rate":      _success_rate_for(health),
+        "probe_age_seconds": _probe_age_seconds(health.tested_at),
+        "last_error":        health.last_error,
+        "credits_remaining": health.credits_remaining,
+        "credits_unit":      health.credits_unit,
+        "credits_low_water": health.credits_low_water,
+        "credits_reset_in_seconds": _seconds_until_monotonic(health.credits_reset_at),
+        "degraded_for_seconds":     deg_for,
+    }
+
+
+def _chain_summary(role: str, chains: dict[str, list[str]],
+                   state: dict, now_mono: float) -> dict:
+    """Per-chain block for Section A. Includes elected primary/backup +
+    `all_credit_exhausted` so the frontend can render a banner when every
+    candidate in the chain is gated out by credits/quota."""
+    chain = chains.get(role) or []
+    primary = llm_health.get_primary(role)
+    backup = llm_health.get_backup(role)
+
+    # all_credit_exhausted: every chain member with a non-None credit signal
+    # is at-or-below its low-water mark. Chains with no signal at all are
+    # NOT flagged exhausted (cold-start should be permissive — election will
+    # try them and surface a real failure if any).
+    any_signal = False
+    all_exhausted = True
+    for m in chain:
+        h = state.get(m)
+        if h is None or h.credits_remaining is None:
+            continue
+        any_signal = True
+        if h.credits_remaining > (h.credits_low_water or 0.0):
+            all_exhausted = False
+            break
+    chain_credit_exhausted = bool(any_signal and all_exhausted)
+
+    return {
+        "role":            role,
+        "chain":           chain,
+        "elected_primary": primary,
+        "elected_backup":  backup,
+        "primary_snapshot": _candidate_snapshot(
+            primary, state.get(primary), [role], now_mono,
+        ) if primary else None,
+        "backup_snapshot": _candidate_snapshot(
+            backup, state.get(backup), [role], now_mono,
+        ) if backup else None,
+        "chain_credit_exhausted": chain_credit_exhausted,
+    }
+
+
+def _recent_turns(n: int = 20) -> list[dict]:
+    """Section C — last N completed turns from 40-data/llm_usage.jsonl,
+    most-recent-first. We keep the row shape close to the raw log entries
+    so the frontend can render new fields if the producer adds them.
+
+    Fields surfaced (all optional — older rows pre-KI-080 won't carry
+    elected_primary/backup):
+      ts / role / chain_primary / elected_primary / elected_backup /
+      served_model / latency_ms / success / fallback_reason
+    """
+    usage_path = _REPO_ROOT / "40-data" / "llm_usage.jsonl"
+    # Re-use the existing tail-reader; cap at N so we don't pay for the
+    # full 1000-row tail when the panel only renders 20.
+    rows = _tail_jsonl(usage_path, max(n, 20))
+    if not rows:
+        return []
+    out: list[dict] = []
+    # tail_jsonl returns oldest-first; reverse to newest-first.
+    for r in reversed(rows[-n:]):
+        out.append({
+            "ts":              r.get("ts"),
+            "role":            r.get("role"),
+            "chain_primary":   r.get("chain_primary"),
+            "elected_primary": r.get("elected_primary"),
+            "elected_backup":  r.get("elected_backup"),
+            "served_model":    r.get("served_model"),
+            "latency_ms":      r.get("latency_ms"),
+            "success":         r.get("success"),
+            "fallback_reason": r.get("fallback_reason"),
+        })
+    return out
+
+
+@router.get("/api/admin/llm-health")
+async def admin_llm_health(
+    request: Request,
+    x_admin_password: Optional[str] = Header(default=None, alias="X-Admin-Password"),
+):
+    """KI-086 — composite LLM health + credits snapshot for the LLM Chain tab.
+
+    Returns three keys:
+      chains       — Section A: one entry per chain (brain/fast_brain/judge)
+                     with elected primary + backup + their snapshots +
+                     chain_credit_exhausted banner flag.
+      candidates   — Section B: one row per known candidate across all chains,
+                     with chain_membership listing every chain it appears in,
+                     latency / success / credits / degraded-window state.
+      recent_turns — Section C: last 20 served turns from llm_usage.jsonl.
+    Plus snapshot_ts so the UI can show "updated <wallclock>".
+    """
+    _check_admin(request, x_admin_password)
+
+    import time as _time
+    now_mono = _time.monotonic()
+
+    chains = _chain_names_map()
+    state = llm_health.load()  # {model -> ModelHealth}
+
+    # Section A: per-chain election + credit banner.
+    chains_block = [
+        _chain_summary(role, chains, state, now_mono)
+        for role in _LLM_HEALTH_CHAIN_ROLES
+    ]
+
+    # Section B: every known candidate × chain membership (deduped).
+    # Membership is the list of chain roles a model belongs to.
+    membership: dict[str, list[str]] = {}
+    for role, models in chains.items():
+        for m in models:
+            membership.setdefault(m, []).append(role)
+    # Also include any candidate present in state but not currently in any
+    # chain (admin reorder may have just removed it) so the operator can
+    # still see its last probe + credits.
+    for m in state.keys():
+        membership.setdefault(m, [])
+
+    candidates_block = [
+        _candidate_snapshot(m, state.get(m), membership[m], now_mono)
+        for m in membership.keys()
+    ]
+    # Sort: degraded first (red), then non-healthy (amber), healthy last,
+    # then by model name. Helps the operator see problems at the top.
+    _status_rank = {"down": 0, "degraded": 1, "unknown": 2, "healthy": 3}
+    candidates_block.sort(
+        key=lambda c: (_status_rank.get(c["status"], 9), c["model"])
+    )
+
+    # Section C: last 20 turns.
+    recent = _recent_turns(20)
+
+    return {
+        "chains":       chains_block,
+        "candidates":   candidates_block,
+        "recent_turns": recent,
+        "snapshot_ts":  datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    }

backend/llm_health.py

@@ -421,29 +421,62 @@ def _ranked_candidates(chain_name: str) -> list[ModelHealth]:
 
 def get_primary(chain_name: str) -> Optional[str]:
     """Top-scoring election-eligible candidate, or None when no probe data
-    is fresh enough. Callers cold-start by falling back to chain[0]."""
+    is fresh enough.
+
+    KI-087 (2026-05-15) — **NIM-first preference.** NIM is the strategic
+    free provider (ADR-019, single-key, $0 cost, 110+ models, no daily
+    cap). Groq has a hard 100K tokens/day free-tier cap and OpenRouter
+    charges a real USD balance. Both should serve as EMERGENCY fallback
+    only, not as primary just because their probe latency is lower.
+    Election therefore prefers ANY eligible NIM candidate over ALL
+    non-NIM candidates. Only when the NIM pool is empty (every NIM
+    model is down, throttled, or out of credits) does election fall
+    through to Groq/OpenRouter as primary. Within the NIM pool, the
+    standard latency × success_rate score still picks the fastest
+    healthy NIM model.
+    """
     ranked = _ranked_candidates(chain_name)
-    return ranked[0].model if ranked else None
+    if not ranked:
+        return None
+    # KI-087: NIM-first within the eligible set.
+    nim_pool = [h for h in ranked if provider_of(h.model) == "nim"]
+    if nim_pool:
+        return nim_pool[0].model
+    # No eligible NIM candidate — fall through to cross-provider primary.
+    return ranked[0].model
 
 
 def get_backup(chain_name: str) -> Optional[str]:
     """Second-best election candidate. Prefers a DIFFERENT provider from
-    primary (NIM vs Groq vs OpenRouter) so a single provider's regional
-    outage can't take out both. Falls back to the next-best same-provider
-    candidate when no cross-provider option qualifies — better an in-
-    family backup than none."""
+    primary so a single provider's regional outage can't take out both.
+
+    KI-087 (2026-05-15) — when PRIMARY is NIM (the typical case under
+    NIM-first preference), BACKUP is the best NON-NIM candidate
+    (Groq / OpenRouter) — kept as the cross-provider safety net. When
+    NIM is wholly unavailable and PRIMARY is non-NIM, BACKUP is the
+    next-best non-NIM candidate or, failing that, the next-best
+    same-provider candidate.
+    """
     ranked = _ranked_candidates(chain_name)
     if len(ranked) < 2:
         # No usable backup. Either zero candidates or only one (in which
         # case the cold-start path in NimChainLLM falls back to chain[1]).
         return None
-    primary_provider = provider_of(ranked[0].model)
-    # Prefer cross-provider
-    for h in ranked[1:]:
+    primary = get_primary(chain_name)
+    if primary is None:
+        return None
+    primary_provider = provider_of(primary)
+    # Prefer cross-provider against the PRIMARY's provider.
+    for h in ranked:
+        if h.model == primary:
+            continue
         if provider_of(h.model) != primary_provider:
             return h.model
     # No cross-provider candidate — accept same-provider next-best.
-    return ranked[1].model
+    for h in ranked:
+        if h.model != primary:
+            return h.model
+    return None
 
 
 def _is_rate_limit_error(error_class: str) -> bool:

frontend/public/admin/llm-control.html

@@ -347,6 +347,114 @@
     .chain-table .icon-btn { padding: 2px 7px; font-size: 12px; line-height: 1.2; }
     .chain-table tbody tr.is-primary td { background: rgba(63, 185, 80, 0.05); }
 
+    /* KI-086: LLM Health & Credits section */
+    .llm-health-chains {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(360px, 1fr));
+      gap: 12px;
+    }
+    .llm-health-chain {
+      padding: 12px;
+      background: #0b0d12;
+      border: 1px solid var(--border);
+      border-radius: 8px;
+    }
+    .llm-health-chain .chain-head {
+      display: flex; align-items: center; gap: 8px;
+      margin-bottom: 10px;
+    }
+    .llm-health-chain .chain-head .role-badge { margin-right: 4px; }
+    .llm-health-chain .role-block {
+      margin-bottom: 8px;
+      padding-bottom: 8px;
+      border-bottom: 1px dashed var(--border);
+    }
+    .llm-health-chain .role-block:last-of-type { border-bottom: none; }
+    .llm-health-chain .role-block .role-label {
+      font-size: 10px;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--muted);
+      margin-bottom: 4px;
+    }
+    .llm-health-chain .role-block .model-name {
+      font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, monospace;
+      font-size: 12px;
+      word-break: break-all;
+    }
+    .llm-health-chain .role-block .stats-line {
+      margin-top: 4px;
+      font-size: 11px;
+      color: var(--muted);
+    }
+    .llm-health-chain .role-block .stats-line .sep {
+      margin: 0 6px;
+      color: #3a4250;
+    }
+    .llm-health-chain .credit-banner {
+      margin-top: 8px;
+      padding: 8px 10px;
+      background: rgba(248, 81, 73, 0.12);
+      border: 1px solid rgba(248, 81, 73, 0.45);
+      border-radius: 6px;
+      font-size: 12px;
+      color: var(--red);
+    }
+    .llm-health-chain .none-elected {
+      color: var(--yellow);
+      font-style: italic;
+      font-size: 12px;
+    }
+
+    /* Status badges — three colors: ✓ green / ⚠ amber / ✗ red */
+    .health-badge {
+      display: inline-block;
+      padding: 2px 8px;
+      border-radius: 4px;
+      font-size: 11px;
+      font-weight: 600;
+      letter-spacing: 0.04em;
+      vertical-align: middle;
+      font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, monospace;
+    }
+    .health-badge.ok       { background: rgba(63, 185, 80, 0.15);  color: var(--green);  border: 1px solid rgba(63, 185, 80, 0.4); }
+    .health-badge.warn     { background: rgba(210, 153, 34, 0.15); color: var(--yellow); border: 1px solid rgba(210, 153, 34, 0.4); }
+    .health-badge.bad      { background: rgba(248, 81, 73, 0.15);  color: var(--red);    border: 1px solid rgba(248, 81, 73, 0.4); }
+    .health-badge.unknown  { background: rgba(139, 149, 164, 0.15);color: var(--muted);  border: 1px solid rgba(139, 149, 164, 0.4); }
+
+    /* Candidate health grid */
+    .llm-health-candidates {
+      overflow-x: auto;
+    }
+    .llm-health-candidates table { font-size: 12px; }
+    .llm-health-candidates td.mono,
+    .llm-health-candidates td.model-cell {
+      font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, monospace;
+      word-break: break-all;
+      max-width: 280px;
+    }
+    .llm-health-candidates td.num { text-align: right; font-variant-numeric: tabular-nums; }
+    .llm-health-candidates td.chain-mem {
+      font-size: 11px;
+      color: var(--muted);
+    }
+    .llm-health-candidates td.credits {
+      font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, monospace;
+      font-size: 11px;
+    }
+
+    /* Recent turns table */
+    .llm-health-recent table { font-size: 12px; }
+    .llm-health-recent td { vertical-align: middle; }
+    .llm-health-recent td.mono {
+      font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, monospace;
+      font-size: 11px;
+      word-break: break-all;
+      max-width: 240px;
+    }
+    .llm-health-recent td.num { text-align: right; font-variant-numeric: tabular-nums; }
+    .llm-health-recent .served-diff { color: var(--yellow); }
+
     .unverified-flag {
       display: inline-block;
       margin-left: 6px;
@@ -554,6 +662,24 @@
 
     <!-- Tab 3: LLM Chain (existing functionality, preserved) -->
     <section id="tab-chain" class="tabpane" role="tabpanel">
+      <!-- KI-086: LLM Health & Credits snapshot (KI-080..KI-085 telemetry) -->
+      <div class="card" id="llm-health-card">
+        <div class="row-between" style="margin-bottom: 12px;">
+          <h2>LLM health &amp; credits <span class="small muted" id="llm-health-snapshot-ts"></span></h2>
+          <div class="actions">
+            <button id="btn-refresh-llm-health">Refresh</button>
+          </div>
+        </div>
+        <!-- Section A: per-chain election cards -->
+        <div id="llm-health-chains" class="llm-health-chains"></div>
+        <!-- Section B: candidate health grid -->
+        <h3 style="margin-top: 18px;">Candidate health grid</h3>
+        <div id="llm-health-candidates" class="llm-health-candidates"></div>
+        <!-- Section C: recent turns -->
+        <h3 style="margin-top: 18px;">Recent turns (last 20)</h3>
+        <div id="llm-health-recent" class="llm-health-recent"></div>
+      </div>
+
       <!-- Health -->
       <div class="card">
         <div class="row-between" style="margin-bottom: 12px;">
@@ -597,6 +723,10 @@
         health: null,    // { models: [...], counters: {...} }
         chains: null,    // { brain: [...], fast_brain: [...], judge: [...] }
         usage: null,     // { brain: {...}, fast_brain: {...}, judge: {...} }
+        // KI-086 — LLM Health & Credits snapshot
+        // Shape: { chains: [...], candidates: [...], recent_turns: [...], snapshot_ts }
+        llmHealth: null,
+        llmHealthPollTimer: null,
         lastUpdatedAt: null,
         chainLoaded: false,
         // Profiles tab
@@ -1222,15 +1352,323 @@
       }
 
       function refreshChain() {
-        return Promise.all([fetchHealth(), fetchChains(), fetchUsage()]).then(function () {
+        return Promise.all([fetchHealth(), fetchChains(), fetchUsage(), fetchLlmHealth()]).then(function () {
           renderCounters();
           renderHealthTable();
           renderChains();
+          renderLlmHealth();
           setLastUpdated();
           STATE.chainLoaded = true;
         });
       }
 
+      // ----- KI-086: LLM Health & Credits -----
+      // Fetcher — tolerant of 404 (endpoint not deployed yet); leaves
+      // STATE.llmHealth null so renderer falls back to pending-message.
+      function fetchLlmHealth() {
+        return apiGetTolerant('/api/admin/llm-health').then(function (data) {
+          STATE.llmHealth = data;
+        }).catch(function (err) {
+          if (err && err.notDeployed) {
+            STATE.llmHealth = { __notDeployed: true };
+          } else {
+            STATE.llmHealth = null;
+          }
+        });
+      }
+
+      function fmtCredits(remaining, unit, lowWater) {
+        if (remaining == null || unit == null) return '—';
+        var n = Number(remaining);
+        if (isNaN(n)) return '—';
+        var rounded;
+        if (n >= 1000) rounded = (n / 1000).toFixed(1) + 'K';
+        else if (n >= 1) rounded = n.toFixed(0);
+        else rounded = n.toFixed(3);
+        var unitLabel;
+        switch (unit) {
+          case 'tokens_day':   unitLabel = 'tokens/day'; break;
+          case 'tokens_min':   unitLabel = 'tokens/min'; break;
+          case 'usd_balance':  unitLabel = 'USD'; break;
+          case 'requests_min': unitLabel = 'req/min'; break;
+          default:             unitLabel = String(unit);
+        }
+        var s = rounded + ' ' + unitLabel;
+        if (lowWater != null && Number(lowWater) > 0) {
+          s += ' (water ' + Number(lowWater).toFixed(unit === 'usd_balance' ? 2 : 0) + ')';
+        }
+        return s;
+      }
+
+      function fmtDurationShort(s) {
+        if (s == null) return '—';
+        var n = Number(s);
+        if (!isFinite(n) || n <= 0) return '0s';
+        if (n < 60)   return Math.round(n) + 's';
+        if (n < 3600) return Math.floor(n / 60) + 'm ' + Math.round(n % 60) + 's';
+        var h = Math.floor(n / 3600);
+        var rem = n - h * 3600;
+        var m = Math.floor(rem / 60);
+        return h + 'h ' + m + 'm';
+      }
+
+      // Pick badge severity for the candidate state.
+      // ✓ ok       — healthy + no degraded window
+      // ⚠ warn     — degraded OR rate-limited (credits at/below water) OR credits exhausting OR degraded_for_seconds>0
+      // ✗ bad      — down OR no probe within 600s (status='unknown' AND probe age >0)
+      function candidateBadge(row) {
+        var st = (row.status || 'unknown').toLowerCase();
+        var degFor = row.degraded_for_seconds;
+        var credsRem = row.credits_remaining;
+        var credsLow = row.credits_low_water;
+        if (st === 'down') return { cls: 'bad', symbol: '✗', label: 'DOWN' };
+        if (degFor != null && degFor > 0) {
+          return { cls: 'warn', symbol: '⚠', label: 'DEGRADED ' + fmtDurationShort(degFor) };
+        }
+        if (credsRem != null && credsLow != null && Number(credsRem) <= Number(credsLow)) {
+          return { cls: 'warn', symbol: '⚠', label: 'RATE-LIMITED' };
+        }
+        if (st === 'degraded') return { cls: 'warn', symbol: '⚠', label: 'DEGRADED' };
+        if (st === 'healthy') return { cls: 'ok', symbol: '✓', label: 'HEALTHY' };
+        return { cls: 'unknown', symbol: '?', label: 'UNKNOWN' };
+      }
+
+      function renderLlmHealthChain(chainBlock) {
+        var card = createEl('div', { className: 'llm-health-chain' });
+        var head = createEl('div', { className: 'chain-head' });
+        var badge = createEl('span', { className: 'role-badge', text: (ROLE_LABELS[chainBlock.role] || chainBlock.role).toUpperCase() });
+        badge.style.background = ROLE_COLORS[chainBlock.role] || '#444';
+        head.appendChild(badge);
+        var title = createEl('span', { text: 'Election' });
+        title.style.fontWeight = '600';
+        title.style.fontSize = '13px';
+        head.appendChild(title);
+        card.appendChild(head);
+
+        // Render PRIMARY + BACKUP rows.
+        ['primary', 'backup'].forEach(function (role) {
+          var snap = chainBlock[role + '_snapshot'];
+          var name = chainBlock['elected_' + role];
+          var block = createEl('div', { className: 'role-block' });
+          var label = createEl('div', { className: 'role-label', text: role.toUpperCase() });
+          block.appendChild(label);
+          if (!name || !snap) {
+            var none = createEl('div', { className: 'none-elected', text: 'none elected (no eligible candidate)' });
+            block.appendChild(none);
+            card.appendChild(block);
+            return;
+          }
+          var nameLine = createEl('div', { className: 'model-name' });
+          var b = candidateBadge(snap);
+          var statusBadge = createEl('span', { className: 'health-badge ' + b.cls, text: b.symbol + ' ' + b.label });
+          statusBadge.style.marginRight = '6px';
+          nameLine.appendChild(statusBadge);
+          nameLine.appendChild(document.createTextNode(name));
+          block.appendChild(nameLine);
+
+          var stats = createEl('div', { className: 'stats-line' });
+          var pushed = false;
+          function pushPart(text) {
+            if (pushed) stats.appendChild(createEl('span', { className: 'sep', text: '·' }));
+            stats.appendChild(document.createTextNode(text));
+            pushed = true;
+          }
+          if (snap.latency_ms != null) pushPart('latency ' + fmtLatency(snap.latency_ms));
+          if (snap.success_rate != null) pushPart('success ' + (Number(snap.success_rate) * 100).toFixed(0) + '%');
+          if (snap.credits_remaining != null) pushPart('credits ' + fmtCredits(snap.credits_remaining, snap.credits_unit, null));
+          if (snap.credits_reset_in_seconds != null && snap.credits_reset_in_seconds > 0) {
+            pushPart('reset in ' + fmtDurationShort(snap.credits_reset_in_seconds));
+          }
+          if (snap.degraded_for_seconds != null && snap.degraded_for_seconds > 0) {
+            pushPart('sin-bin ' + fmtDurationShort(snap.degraded_for_seconds));
+          }
+          if (!pushed) stats.textContent = 'No telemetry yet.';
+          block.appendChild(stats);
+          card.appendChild(block);
+        });
+
+        if (chainBlock.chain_credit_exhausted) {
+          var banner = createEl('div', { className: 'credit-banner' });
+          banner.textContent = 'All candidates for ' + (ROLE_LABELS[chainBlock.role] || chainBlock.role).toUpperCase() +
+            '_CHAIN are credit-exhausted; canonical fallback will fire until quotas reset.';
+          card.appendChild(banner);
+        }
+        return card;
+      }
+
+      function renderLlmHealthCandidates(rows) {
+        var wrap = $('llm-health-candidates');
+        clearChildren(wrap);
+        if (!rows || !rows.length) {
+          wrap.appendChild(createEl('div', { className: 'empty-state', text: 'No candidates known yet (probe loop hasn’t run).' }));
+          return;
+        }
+        var table = createEl('table');
+        var thead = createEl('thead');
+        var tr = createEl('tr');
+        ['Status', 'Provider', 'Model', 'Chain(s)', 'Probe age', 'Latency', 'Success', 'Credits', 'Reset / sin-bin'].forEach(function (h, i) {
+          var th = createEl('th', { text: h });
+          if (i >= 4) th.style.textAlign = i === 8 ? 'left' : 'right';
+          tr.appendChild(th);
+        });
+        thead.appendChild(tr);
+        table.appendChild(thead);
+
+        var tbody = createEl('tbody');
+        rows.forEach(function (r) {
+          var row = createEl('tr');
+          var b = candidateBadge(r);
+          var stCell = createEl('td');
+          var badge = createEl('span', { className: 'health-badge ' + b.cls, text: b.symbol + ' ' + b.label });
+          stCell.appendChild(badge);
+          row.appendChild(stCell);
+
+          row.appendChild(createEl('td', { className: 'mono', text: (r.provider || '—').toUpperCase() }));
+          row.appendChild(createEl('td', { className: 'model-cell', text: r.model }));
+
+          var chainsLbl = (r.chain_membership || []).map(function (rr) { return (ROLE_LABELS[rr] || rr).toUpperCase(); }).join(', ');
+          row.appendChild(createEl('td', { className: 'chain-mem', text: chainsLbl || '—' }));
+
+          row.appendChild(createEl('td', { className: 'num', text: r.probe_age_seconds != null ? fmtDurationShort(r.probe_age_seconds) + ' ago' : '—' }));
+          row.appendChild(createEl('td', { className: 'num', text: r.latency_ms != null ? fmtLatency(r.latency_ms) : '—' }));
+          row.appendChild(createEl('td', { className: 'num', text: r.success_rate != null ? (Number(r.success_rate) * 100).toFixed(0) + '%' : '—' }));
+          row.appendChild(createEl('td', { className: 'credits', text: fmtCredits(r.credits_remaining, r.credits_unit, r.credits_low_water) }));
+
+          var resetParts = [];
+          if (r.credits_reset_in_seconds != null && r.credits_reset_in_seconds > 0) {
+            resetParts.push('quota in ' + fmtDurationShort(r.credits_reset_in_seconds));
+          }
+          if (r.degraded_for_seconds != null && r.degraded_for_seconds > 0) {
+            resetParts.push('sin-bin ' + fmtDurationShort(r.degraded_for_seconds));
+          }
+          row.appendChild(createEl('td', { text: resetParts.length ? resetParts.join(' · ') : '—' }));
+
+          tbody.appendChild(row);
+        });
+        table.appendChild(tbody);
+        wrap.appendChild(table);
+      }
+
+      function renderLlmHealthRecent(turns) {
+        var wrap = $('llm-health-recent');
+        clearChildren(wrap);
+        if (!turns || !turns.length) {
+          wrap.appendChild(createEl('div', { className: 'empty-state', text: 'No turns logged yet.' }));
+          return;
+        }
+        var table = createEl('table');
+        var thead = createEl('thead');
+        var tr = createEl('tr');
+        ['Time', 'Chain', 'Elected primary', 'Served model', 'Latency', 'Result'].forEach(function (h, i) {
+          var th = createEl('th', { text: h });
+          if (i === 4) th.style.textAlign = 'right';
+          tr.appendChild(th);
+        });
+        thead.appendChild(tr);
+        table.appendChild(thead);
+
+        var tbody = createEl('tbody');
+        turns.forEach(function (t) {
+          var row = createEl('tr');
+          row.appendChild(createEl('td', { text: fmtIST(t.ts) }));
+          var chainCell = createEl('td');
+          if (t.role) {
+            var badge = createEl('span', { className: 'role-badge', text: (ROLE_LABELS[t.role] || t.role).toUpperCase() });
+            badge.style.background = ROLE_COLORS[t.role] || '#444';
+            chainCell.appendChild(badge);
+          } else {
+            chainCell.textContent = '—';
+          }
+          row.appendChild(chainCell);
+
+          var electedPrimary = t.elected_primary || t.chain_primary || '—';
+          row.appendChild(createEl('td', { className: 'mono', text: electedPrimary }));
+
+          var servedCell = createEl('td', { className: 'mono' });
+          var served = t.served_model || '—';
+          servedCell.textContent = served;
+          if (electedPrimary !== '—' && served !== '—' && served !== electedPrimary) {
+            // Served by backup/fallback — flag visually.
+            servedCell.classList.add('served-diff');
+            servedCell.title = 'Served by backup/fallback — elected primary was unavailable.';
+          }
+          row.appendChild(servedCell);
+
+          row.appendChild(createEl('td', { className: 'num', text: t.latency_ms != null ? fmtLatency(t.latency_ms) : '—' }));
+
+          var resultCell = createEl('td');
+          var ok = t.success === true;
+          var resBadge = createEl('span', { className: 'health-badge ' + (ok ? 'ok' : 'bad'), text: (ok ? '✓ OK' : '✗ FAIL') });
+          resultCell.appendChild(resBadge);
+          if (t.fallback_reason) {
+            var fr = createEl('span', { className: 'small muted', text: ' ' + t.fallback_reason });
+            resultCell.appendChild(fr);
+          }
+          row.appendChild(resultCell);
+
+          tbody.appendChild(row);
+        });
+        table.appendChild(tbody);
+        wrap.appendChild(table);
+      }
+
+      function renderLlmHealth() {
+        var chainsHost = $('llm-health-chains');
+        var snapEl = $('llm-health-snapshot-ts');
+        if (!chainsHost) return;
+
+        if (!STATE.llmHealth) {
+          clearChildren(chainsHost);
+          chainsHost.appendChild(createEl('div', { className: 'empty-state', text: 'Loading…' }));
+          clearChildren($('llm-health-candidates'));
+          clearChildren($('llm-health-recent'));
+          if (snapEl) snapEl.textContent = '';
+          return;
+        }
+        if (STATE.llmHealth.__notDeployed) {
+          clearChildren(chainsHost);
+          chainsHost.appendChild(buildPendingMessage('/api/admin/llm-health'));
+          clearChildren($('llm-health-candidates'));
+          clearChildren($('llm-health-recent'));
+          if (snapEl) snapEl.textContent = '';
+          return;
+        }
+
+        clearChildren(chainsHost);
+        (STATE.llmHealth.chains || []).forEach(function (c) {
+          chainsHost.appendChild(renderLlmHealthChain(c));
+        });
+
+        renderLlmHealthCandidates(STATE.llmHealth.candidates || []);
+        renderLlmHealthRecent(STATE.llmHealth.recent_turns || []);
+
+        if (snapEl) {
+          snapEl.textContent = STATE.llmHealth.snapshot_ts
+            ? '· updated ' + fmtIST(STATE.llmHealth.snapshot_ts)
+            : '';
+        }
+      }
+
+      // Auto-poll every 30s while the LLM Chain tab is the active tab.
+      // The backend's probe loop only refreshes every 5min anyway — we poll
+      // faster than that because credit + degraded-window state changes
+      // sub-tick (chat hot path stamps both) and the operator needs to see
+      // those without manually clicking Refresh.
+      var LLM_HEALTH_POLL_INTERVAL_MS = 30000;
+      function startLlmHealthPolling() {
+        stopLlmHealthPolling();
+        STATE.llmHealthPollTimer = setInterval(function () {
+          if (STATE.activeTab !== 'chain') return;
+          fetchLlmHealth().then(renderLlmHealth).catch(function () { /* swallow */ });
+        }, LLM_HEALTH_POLL_INTERVAL_MS);
+      }
+      function stopLlmHealthPolling() {
+        if (STATE.llmHealthPollTimer) {
+          clearInterval(STATE.llmHealthPollTimer);
+          STATE.llmHealthPollTimer = null;
+        }
+      }
+
       function handleFetchErr(err) {
         if (err && err.code === 404) {
           try { localStorage.removeItem(STORAGE_KEY); } catch (_) {}
@@ -1753,12 +2191,19 @@
         // Lazy-load this tab's data
         if (tab === 'profiles') {
           loadProfiles(false);
+          stopLlmHealthPolling();
         } else if (tab === 'performance') {
           loadPerformance(false);
+          stopLlmHealthPolling();
         } else if (tab === 'chain') {
           if (!STATE.chainLoaded) {
             refreshChain().catch(handleFetchErr);
+          } else {
+            // Tab already loaded — refresh just the KI-086 panel on re-entry
+            // so the operator immediately sees fresh credits / sin-bin state.
+            fetchLlmHealth().then(renderLlmHealth).catch(function () { /* swallow */ });
           }
+          startLlmHealthPolling();
         }
       }
 
@@ -1828,11 +2273,13 @@
           STATE.health = null;
           STATE.chains = null;
           STATE.usage = null;
+          STATE.llmHealth = null;
           STATE.profiles = null;
           STATE.profilesLoaded = false;
           STATE.performance = null;
           STATE.performanceLoaded = false;
           STATE.chainLoaded = false;
+          stopLlmHealthPolling();
           try { localStorage.removeItem(STORAGE_KEY); } catch (_) {}
           showGate();
           toast('Locked', 'info');
@@ -1885,6 +2332,20 @@
             .catch(handleFetchErr)
             .then(function () { btn.disabled = false; btn.textContent = 'Force fresh probe (slow)'; });
         };
+
+        // KI-086 — manual refresh for the LLM Health & Credits card.
+        var llmHealthBtn = $('btn-refresh-llm-health');
+        if (llmHealthBtn) {
+          llmHealthBtn.onclick = function () {
+            var btn = this;
+            btn.disabled = true;
+            btn.textContent = 'Refreshing…';
+            fetchLlmHealth()
+              .then(function () { renderLlmHealth(); toast('LLM health refreshed', 'success'); })
+              .catch(handleFetchErr)
+              .then(function () { btn.disabled = false; btn.textContent = 'Refresh'; });
+          };
+        }
       }
 
       // ----- Boot -----