fix(admin): KI-267 — Health column + consolidated LLM Health header

C2 — Health column on both admin tables:
- backend/llm_health.py:
* ModelHealth.last_status_code: Optional[int] field (HTTP code from probe/chat
failures) + back-compat default in _load_into_memory.
* New helpers _classify_error_reason() + _extract_status_code() (regex with
digit-boundary so Status429 / http_429 / HTTPStatusError:503 all match).
* _absorb_probe_result, report_failure, report_success stamp last_status_code
(cleared on success).
* status_summary now emits effective_status + last_status_code +
health_reason per row. Categories: "rate limit (429)" / "out of credits" /
"network issue" / "service unavailable ({code})" / "auth error ({code})" /
"stale" / first 40 chars fallback.
- backend/admin.py: _candidate_snapshot exposes the new fields.
- frontend/public/admin/llm-control.html:
* NEW renderHealthCell(snap) + buildCandidatesMap(payload) helpers.
* "Currently In Use" + "All Eligible Models" tables get a "Health" column.
* Renders green dot + "Live" or red dot + "Off — {reason}". Tier-0 Gemini
rows synth a healthy snapshot since the NIM probe loop doesn't cover it
(Gemini health comes from chat-path report_failure).
* Reused existing .health-dot.ok / .health-dot.bad CSS — no new styles.

C1 — Consolidated LLM Health header into one line:
- New header row: bold "LLM Health" + muted meta "Last refresh: Xm Ys ago ·
Next in: Xm Ys" + right-aligned "Refresh now" button.
- Dropped legacy #llm-health-snapshot-ts + #llm-health-stale-badge spans
(FRESH/STALE pill removed — timing line conveys it).
- renderUpdatedLabel rewritten for the new ago/next spans.
- tickFooters badge block removed.
- "Probing…" / "auto-probe" strings replaced with "Refreshing…" / "next
refresh". Backend endpoint /api/admin/probe unchanged.
- "Refresh" button label → "Refresh now"; reset string updated.

KI-258b — Countdown never shows "due now":
- renderUpdatedLabel now projects forward to the next interval boundary:
elapsed = (now - probeAt)
intoNext = ((elapsed % PROBE_INTERVAL_MS) + PROBE_INTERVAL_MS) % PROBE_INTERVAL_MS
untilNext = PROBE_INTERVAL_MS - intoNext
So an overdue auto-probe rolls over and the countdown always shows real
minutes:seconds the user can act on.

Verification:
- python -m py_compile clean on llm_health.py + admin.py.
- node --check on the inline <script> block: OK.
- grep llm-health-stale-badge / auto-probe: 0 hits.
- Classifier unit tests: 11/11 categories correct.
- Render simulation: 10 synthetic snapshots produce expected dot+label+tooltip.

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

backend/admin.py

@@ -678,10 +678,13 @@ def _candidate_snapshot(model: str, health, chain_membership: list[str],
             "provider":           llm_health.provider_of(model),
             "chain_membership":   chain_membership,
             "status":             "unknown",
+            "effective_status":   "unknown",
             "latency_ms":         None,
             "success_rate":       None,
             "probe_age_seconds":  None,
             "last_error":         None,
+            "last_status_code":   None,
+            "health_reason":      None,
             "credits_remaining":  None,
             "credits_unit":       None,
             "credits_low_water":  None,
@@ -692,15 +695,29 @@ def _candidate_snapshot(model: str, health, chain_membership: list[str],
     deg_for = None
     if deg_until and deg_until > now_mono:
         deg_for = round(deg_until - now_mono, 1)
+    # KI-202 — operator-facing reason for the admin Health column. None when
+    # the row is healthy (renders "Live" only) or has no error signal yet.
+    eff = llm_health.effective_status(health)
+    if eff == "stale":
+        health_reason = "stale"
+    elif eff == "healthy":
+        health_reason = None
+    else:
+        health_reason = llm_health._classify_error_reason(
+            health.last_error, health.last_status_code,
+        )
     return {
         "model":             model,
         "provider":          llm_health.provider_of(model),
         "chain_membership":  chain_membership,
         "status":            health.status,
+        "effective_status":  eff,
         "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,
+        "last_status_code":  health.last_status_code,
+        "health_reason":     health_reason,
         "credits_remaining": health.credits_remaining,
         "credits_unit":      health.credits_unit,
         "credits_low_water": health.credits_low_water,

backend/llm_health.py

@@ -194,6 +194,94 @@ def _headers_for(model_id: str, api_key: str) -> dict[str, str]:
     return h
 
 
+# KI-202 (2026-05-15) — categorize a `last_error` string + optional HTTP
+# status code into the short operator-facing reason rendered by the admin
+# Health columns. Centralised here so backend and any other consumer agree
+# on the same vocabulary ("network issue" / "rate limit (429)" / etc.).
+# Use lookbehind/lookahead on non-digit so we still match e.g. "Status429",
+# "http_429", "HTTPStatusError:503" — \b word-boundary alone treats "_" as
+# a word char so "http_429" wouldn't match.
+_RATE_LIMIT_RE = re.compile(r"(?<!\d)429(?!\d)|rate[_\s-]?limit", re.IGNORECASE)
+_AUTH_RE       = re.compile(r"(?<!\d)40[13](?!\d)|unauthor|forbidden",  re.IGNORECASE)
+_QUOTA_RE      = re.compile(r"(?<!\d)402(?!\d)|quota|out[\s_-]?of[\s_-]?credit|insufficient[_\s]?funds|payment[_\s]?required", re.IGNORECASE)
+_TIMEOUT_RE    = re.compile(r"timeout|timed[_\s-]?out|connect(ion)?[_\s-]?(refused|reset|error)|network|dns|name[_\s-]?or[_\s-]?service", re.IGNORECASE)
+_5XX_RE        = re.compile(r"(?<!\d)5\d{2}(?!\d)|service[_\s-]?unavailable|bad[_\s-]?gateway|gateway[_\s-]?timeout|internal[_\s-]?server", re.IGNORECASE)
+
+
+def _classify_error_reason(last_error: Optional[str],
+                            last_status_code: Optional[int] = None) -> Optional[str]:
+    """Map a stored `last_error` string (+ optional HTTP code) into a short
+    operator-facing reason for the admin Health column. Returns None when
+    there is no error signal at all (caller renders just "Live" or "Off —
+    unknown" depending on status).
+
+    Categories (matches the display contract in the admin spec):
+      - "network issue"            — timeout / connection refused / DNS
+      - "out of credits"           — HTTP 402 / quota / insufficient funds
+      - "rate limit (429)"         — HTTP 429 / rate-limit keywords
+      - "service unavailable (5xx)"— HTTP 5xx
+      - "auth error (4xx)"         — HTTP 401 / 403
+      - "stale"                    — explicitly surfaced by effective_status()
+      - first-40-chars fallback    — anything else, truncated so the cell
+                                     doesn't blow up the table width.
+    """
+    if not last_error:
+        return None
+
+    # Prefer the explicit status code when present — it's unambiguous.
+    if last_status_code is not None:
+        code = int(last_status_code)
+        if code == 429:
+            return "rate limit (429)"
+        if code == 402:
+            return "out of credits"
+        if code in (401, 403):
+            return f"auth error ({code})"
+        if 500 <= code < 600:
+            return f"service unavailable ({code})"
+
+    text = str(last_error)
+
+    if _RATE_LIMIT_RE.search(text):
+        return "rate limit (429)"
+    if _QUOTA_RE.search(text):
+        return "out of credits"
+    if _AUTH_RE.search(text):
+        # Try to surface the code if it's embedded in the string.
+        m = re.search(r"(?<!\d)(40[13])(?!\d)", text)
+        return f"auth error ({m.group(1)})" if m else "auth error"
+    if _TIMEOUT_RE.search(text):
+        return "network issue"
+    if _5XX_RE.search(text):
+        m = re.search(r"(?<!\d)(5\d{2})(?!\d)", text)
+        return f"service unavailable ({m.group(1)})" if m else "service unavailable"
+
+    # Final fallback — truncate so the table cell stays readable.
+    snippet = text.strip().splitlines()[0] if text.strip() else ""
+    return snippet[:40] if snippet else None
+
+
+def _extract_status_code(err: str) -> Optional[int]:
+    """Best-effort scrape of an HTTP status code out of an error string —
+    used by the probe path to backfill `last_status_code` from the existing
+    `http_{code}` / `HTTPStatusError:{code}` tags without changing every
+    probe-result producer. Returns None when no 3-digit HTTP code is found."""
+    if not err:
+        return None
+    # Surround-by-non-digit boundary so we still catch "http_429" / "Status429"
+    # where \b would fail because '_' is a word char.
+    m = re.search(r"(?<!\d)(\d{3})(?!\d)", err)
+    if not m:
+        return None
+    try:
+        code = int(m.group(1))
+    except ValueError:
+        return None
+    if 100 <= code < 600:
+        return code
+    return None
+
+
 def provider_of(model_id: str) -> str:
     """Coarse provider bucket — used by the election routine to prefer a
     cross-provider backup so a NIM regional outage can't take out both
@@ -221,6 +309,13 @@ class ModelHealth:
     last_success_at: Optional[str] = None
     last_failure_at: Optional[str] = None
     last_error: Optional[str] = None
+    # KI-202 (2026-05-15) — explicit HTTP status code from the most recent
+    # failed probe / chat call. `last_error` is a free-form string ("timeout",
+    # "http_429", "net: TimeoutException: ..."); `last_status_code` is the
+    # parsed integer (or None when the failure wasn't HTTP-shaped). Surfaced
+    # in admin Health columns so the operator can see "Off — rate limit (429)"
+    # vs "Off — service unavailable (503)" at a glance.
+    last_status_code: Optional[int] = None
     latency_ms: Optional[int] = None
     consecutive_failures: int = 0
     tested_at: Optional[str] = None
@@ -312,6 +407,7 @@ def _load_into_memory() -> None:
                     # records missing the five credits_* fields).
                     v.setdefault("probe_history", [])
                     v.setdefault("degraded_until_monotonic", 0.0)
+                    v.setdefault("last_status_code", None)
                     v.setdefault("credits_remaining", None)
                     v.setdefault("credits_unit", None)
                     v.setdefault("credits_reset_at", None)
@@ -642,6 +738,11 @@ def report_failure(chain_name: str, model: str, error_class: str) -> None:
         h.degraded_until_monotonic = time.monotonic() + degrade_for_s
         h.last_failure_at = _now_iso()
         h.last_error = f"chat_failure: {error_class}"
+        # KI-202 — `error_class` from NimChainLLM._classify_error is
+        # `Status429`, `HTTPStatusError:503`, `TimeoutException`, etc.
+        # Pull the trailing 3-digit code out so the admin Health column
+        # can render a code-specific label.
+        h.last_status_code = _extract_status_code(error_class)
         h.probe_history.append({
             "ok": False,
             "latency_ms": None,
@@ -676,6 +777,7 @@ def report_success(chain_name: str, model: str, latency_ms: int) -> None:
         h = _STATE.get(model) or ModelHealth(model=model)
         h.last_success_at = _now_iso()
         h.last_error = None
+        h.last_status_code = None
         h.latency_ms = int(latency_ms)
         h.consecutive_failures = 0
         h.tested_at = _now_iso()
@@ -1059,12 +1161,17 @@ def _absorb_probe_result(model: str, ok: bool, err: str, latency: Optional[int])
         if ok:
             h.last_success_at = _now_iso()
             h.last_error = None
+            h.last_status_code = None
             h.latency_ms = latency
             h.consecutive_failures = 0
             h.status = "healthy" if (latency or 0) < 5000 else "degraded"
         else:
             h.last_failure_at = _now_iso()
             h.last_error = err
+            # KI-202 — backfill last_status_code from the err tag so the
+            # admin Health column can render code-specific reasons (429 /
+            # 503 / etc.) without changing every producer.
+            h.last_status_code = _extract_status_code(err)
             h.consecutive_failures += 1
             if h.consecutive_failures >= DOWN_AFTER_CONSECUTIVE_FAILS:
                 h.status = "down"
@@ -1152,14 +1259,26 @@ def status_summary() -> dict:
         # rows whose stored 'healthy' verdict is older than STALE_AGE_SEC.
         eff = effective_status(h)
         summary["by_status"][eff] = summary["by_status"].get(eff, 0) + 1
+        # KI-202 — operator-facing reason string for the admin Health
+        # column. None when there is no error signal (caller renders just
+        # "Live" or "Off — stale"/"Off — unknown" based on `effective_status`).
+        if eff == "stale":
+            health_reason = "stale"
+        elif eff in ("healthy",):
+            health_reason = None
+        else:
+            health_reason = _classify_error_reason(h.last_error, h.last_status_code)
         summary["models"].append({
             "model": m,
             "status": eff,
+            "effective_status": eff,
             "stored_status": h.status,  # preserved for debug / drift detection
             "latency_ms": h.latency_ms,
             "last_success_at": h.last_success_at,
             "last_failure_at": h.last_failure_at,
             "last_error": h.last_error,
+            "last_status_code": h.last_status_code,
+            "health_reason": health_reason,
             "tested_at": h.tested_at,
             # KI-085 — surface credits state for the admin UI.
             "credits_remaining": h.credits_remaining,

frontend/public/admin/llm-control.html

@@ -585,6 +585,9 @@
       gap: 6px;
       font-variant-numeric: tabular-nums;
     }
+    /* LEGACY (KI-208) — .stale-badge rules retained but no longer referenced by
+       the LLM Health header (consolidated into a single-line refresh-meta row).
+       Still used by per-table footers via setFooter(). Safe to keep. */
     .stale-badge {
       display: inline-block;
       padding: 1px 7px;
@@ -610,6 +613,26 @@
       border-color: rgba(248, 81, 73, 0.40);
     }
 
+    /* KI-208 — consolidated LLM Health header row: heading + last refresh +
+       next refresh + refresh button on one flex line. */
+    .llm-health-header-row {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      flex-wrap: wrap;
+      margin-bottom: 8px;
+    }
+    .llm-health-header-row h2 { margin: 0; }
+    .llm-refresh-meta {
+      color: var(--muted, #888);
+      font-size: 12px;
+      display: inline-flex;
+      gap: 6px;
+      align-items: center;
+    }
+    .llm-refresh-meta .dot-sep { opacity: 0.5; }
+    #btn-refresh-llm-health { margin-left: auto; }
+
     /* A5 — Persona drift panel + recommendation history panel */
     .collapsible {
       border: 1px solid var(--border);
@@ -795,8 +818,15 @@
            may live inside this section: the h2 header (with snapshot timestamp
            span), the refresh button, and the chains container that holds the
            two generated tables (Currently In Use + All Eligible Models). -->
-      <h2>LLM health <span class="small muted" id="llm-health-snapshot-ts"></span> <span id="llm-health-stale-badge"></span></h2>
-      <button id="btn-refresh-llm-health">Refresh</button>
+      <div class="llm-health-header-row">
+        <h2>LLM Health</h2>
+        <span class="llm-refresh-meta">
+          <span>Last refresh: <span id="llm-last-refresh-ago">--</span></span>
+          <span class="dot-sep">·</span>
+          <span>Next in: <span id="llm-next-refresh-in">--</span></span>
+        </span>
+        <button id="btn-refresh-llm-health">Refresh now</button>
+      </div>
       <div id="llm-health-chains" class="llm-simple-tables"></div>
       <div id="llm-health-footer" class="table-footer"></div>
     </section>
@@ -1409,22 +1439,27 @@
       }
 
       function renderUpdatedLabel() {
-        var el = $('last-updated');
-        if (!el) return;
-        // Only show the LLM-Chain probe staleness when that tab is active —
-        // it's irrelevant on Profiles / Performance.
+        var ago = $('llm-last-refresh-ago');
+        var next = $('llm-next-refresh-in');
+        if (!ago || !next) return;
+        // Only render the LLM-Chain refresh timing when that tab is active —
+        // irrelevant on Profiles / Performance.
         if (STATE.activeTab !== 'chain') {
-          el.textContent = '';
+          ago.textContent = '--';
+          next.textContent = '--';
           return;
         }
         var probeAt = probeTimestampMs();
-        if (!probeAt) { el.textContent = ''; return; }
+        if (!probeAt) { ago.textContent = '--'; next.textContent = '--'; return; }
         var now = Date.now();
-        var since = formatMinSec(now - probeAt);
-        var nextAt = probeAt + PROBE_INTERVAL_MS;
-        var untilNext = nextAt > now ? formatMinSec(nextAt - now) : 'due now';
-        var wallClock = new Date(probeAt).toLocaleTimeString();
-        el.textContent = 'Updated ' + wallClock + ' · ' + since + ' ago · next auto-probe in ' + untilNext;
+        ago.textContent = formatMinSec(now - probeAt) + ' ago';
+        // KI-258b — never display "due now". If the auto-probe is overdue,
+        // project forward to the NEXT interval boundary so the countdown
+        // always shows a real minutes:seconds value the user can act on.
+        var elapsed = now - probeAt;
+        var intoNext = ((elapsed % PROBE_INTERVAL_MS) + PROBE_INTERVAL_MS) % PROBE_INTERVAL_MS;
+        var untilNext = PROBE_INTERVAL_MS - intoNext;
+        next.textContent = formatMinSec(untilNext);
       }
 
       setInterval(renderUpdatedLabel, 1000);
@@ -1739,6 +1774,62 @@
         return td;
       }
 
+      // KI-202 (2026-05-15) — operator-facing Health cell renderer. Reads
+      // the per-model snapshot built from `healthPayload.candidates` (a
+      // {model -> snapshot} map populated by renderLlmSimpleTables before
+      // each row). Returns a <td> element so the caller can append directly.
+      //
+      // Display contract (matches admin spec):
+      //   Live              — green dot + "Live"            (effective_status='healthy')
+      //   Off — [reason]    — red dot   + "Off — reason"    (everything else)
+      // Reasons come from backend `health_reason`; fallback "unknown" when
+      // the field is absent. The full `last_error` (when present) is
+      // surfaced via a tooltip on hover.
+      function renderHealthCell(snap) {
+        var td = createEl('td', { className: 'health-cell' });
+        td.style.whiteSpace = 'nowrap';
+        var dot = createEl('span', { className: 'health-dot' });
+        dot.style.marginRight = '6px';
+        if (!snap) {
+          // No snapshot for this model — render "Off — unknown" rather
+          // than blank so the operator sees the gap.
+          dot.className = 'health-dot bad';
+          td.appendChild(dot);
+          td.appendChild(document.createTextNode('Off — unknown'));
+          return td;
+        }
+        var eff = (snap.effective_status || snap.status || 'unknown').toLowerCase();
+        var isLive = (eff === 'healthy');
+        dot.className = 'health-dot ' + (isLive ? 'ok' : 'bad');
+        td.appendChild(dot);
+        if (isLive) {
+          td.appendChild(document.createTextNode('Live'));
+        } else {
+          var reason = snap.health_reason;
+          if (!reason) {
+            if (eff === 'stale')        reason = 'stale';
+            else if (eff === 'unknown') reason = 'unknown';
+            else                        reason = 'unknown';
+          }
+          td.appendChild(document.createTextNode('Off — ' + reason));
+        }
+        if (snap.last_error) {
+          td.title = String(snap.last_error);
+        }
+        return td;
+      }
+
+      // Build {model -> candidate snapshot} from healthPayload.candidates
+      // so renderHealthCell() can look up by model id in O(1).
+      function buildCandidatesMap(healthPayload) {
+        var out = {};
+        var cands = (healthPayload && healthPayload.candidates) || [];
+        cands.forEach(function (c) {
+          if (c && c.model) out[c.model] = c;
+        });
+        return out;
+      }
+
       // KI-200 — accepts the full llm-health payload so we can read
       // `gemini_available` (when backend exposes it). Caller signature
       // updated below in renderLlmHealth().
@@ -1746,6 +1837,8 @@
         var chains = (healthPayload && healthPayload.chains) || [];
         var chainsByRole = {};
         chains.forEach(function (c) { if (c && c.role) chainsByRole[c.role] = c; });
+        // KI-202 — model -> candidate snapshot map, used by renderHealthCell().
+        var candByModel = buildCandidatesMap(healthPayload);
 
         // ---- Table 1: Currently In Use ----
         var liveBlock = createEl('div', { className: 'simple-table-block' });
@@ -1753,9 +1846,10 @@
         var liveTable = createEl('table');
         var liveThead = createEl('thead');
         var liveHr = createEl('tr');
-        ['Use', 'Current Model', 'Provider', 'Tier'].forEach(function (h, i) {
+        // KI-202 — Health column appended at end (5 cols total).
+        ['Use', 'Current Model', 'Provider', 'Tier', 'Health'].forEach(function (h, i) {
           var th = createEl('th', { text: h });
-          if (i >= 2) th.style.textAlign = 'center';
+          if (i >= 2 && i <= 3) th.style.textAlign = 'center';
           liveHr.appendChild(th);
         });
         liveThead.appendChild(liveHr);
@@ -1789,6 +1883,19 @@
           tierCell.textContent = live.tier;
           tr.appendChild(tierCell);
 
+          // KI-202 — HEALTH cell. Tier-0 (Gemini) currently has no
+          // health snapshot in `candidates` (probe loop only covers NIM/
+          // OpenRouter chain entries), so fall back to a "Live" pill when
+          // gemini_available flag is set / defaulted true. For Tier-1 NIM
+          // rows we look up by model id in the candidates map.
+          var healthSnap = candByModel[live.model];
+          if (!healthSnap && live.isTier0) {
+            // Synthesize a "live" snapshot — Gemini availability is assumed
+            // until backend exposes a per-Gemini health row.
+            healthSnap = { effective_status: 'healthy' };
+          }
+          tr.appendChild(renderHealthCell(healthSnap));
+
           liveTbody.appendChild(tr);
         });
         liveTable.appendChild(liveTbody);
@@ -1801,10 +1908,13 @@
         var availTable = createEl('table');
         var availThead = createEl('thead');
         var availHr = createEl('tr');
-        var availCols = ['Model', 'Provider', 'Tier'].concat(SIMPLE_USE_ORDER.map(function (r) { return SIMPLE_USE_LABELS[r]; }));
+        // KI-202 — Health column appended at end.
+        var availCols = ['Model', 'Provider', 'Tier']
+          .concat(SIMPLE_USE_ORDER.map(function (r) { return SIMPLE_USE_LABELS[r]; }))
+          .concat(['Health']);
         availCols.forEach(function (h, i) {
           var th = createEl('th', { text: h });
-          if (i >= 1) th.style.textAlign = 'center';
+          if (i >= 1 && i < availCols.length - 1) th.style.textAlign = 'center';
           availHr.appendChild(th);
         });
         availThead.appendChild(availHr);
@@ -1834,6 +1944,13 @@
             tr.appendChild(renderRoleLabelCell(entry.roles[role]));
           });
 
+          // KI-202 — HEALTH cell. Same Tier-0 fallback as Table 1.
+          var entryHealthSnap = candByModel[entry.model];
+          if (!entryHealthSnap && entry.tier === 'T0') {
+            entryHealthSnap = { effective_status: 'healthy' };
+          }
+          tr.appendChild(renderHealthCell(entryHealthSnap));
+
           availTbody.appendChild(tr);
         });
         availTable.appendChild(availTbody);
@@ -1959,15 +2076,15 @@
 
       function renderLlmHealth() {
         var chainsHost = $('llm-health-chains');
-        var snapEl = $('llm-health-snapshot-ts');
         if (!chainsHost) return;
 
+        // KI-208 — snapshot timestamp moved out of the header into the
+        // consolidated "Last refresh / Next in" row driven by renderUpdatedLabel.
         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) {
@@ -1975,7 +2092,6 @@
           chainsHost.appendChild(buildPendingMessage('/api/admin/llm-health'));
           clearChildren($('llm-health-candidates'));
           clearChildren($('llm-health-recent'));
-          if (snapEl) snapEl.textContent = '';
           return;
         }
 
@@ -1985,12 +2101,6 @@
 
         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.
@@ -2757,21 +2867,8 @@
         }
         if (!probeAt) probeAt = STATE.llmHealthLoadedAt;
         setFooter('llm-health-footer', probeAt);
-        // LLM-health stale badge sits next to the section header — render
-        // separately so it's visible even when the body is empty.
-        var badgeHost = $('llm-health-stale-badge');
-        if (badgeHost) {
-          clearChildren(badgeHost);
-          if (probeAt) {
-            var ageMs = Date.now() - probeAt;
-            var stale = ageMs > STALE_THRESHOLD_MS;
-            var badge = createEl('span', {
-              className: 'stale-badge ' + (stale ? '' : 'fresh'),
-              text: stale ? 'STALE' : 'FRESH'
-            });
-            badgeHost.appendChild(badge);
-          }
-        }
+        // KI-208 — FRESH/STALE header badge removed; the consolidated header
+        // row's "Last refresh / Next in" timing conveys freshness instead.
       }
       setInterval(tickFooters, 1000);
 
@@ -2977,13 +3074,13 @@
           llmHealthBtn.onclick = function () {
             var btn = this;
             btn.disabled = true;
-            btn.textContent = 'Probing…';
+            btn.textContent = 'Refreshing…';
             apiPost('/api/admin/probe', null)
               .catch(function () { /* tolerate probe failure; still re-fetch cached state */ })
               .then(function () { return fetchLlmHealth(); })
-              .then(function () { renderLlmHealth(); toast('LLM health refreshed (fresh probe)', 'success'); })
+              .then(function () { renderLlmHealth(); toast('LLM health refreshed', 'success'); })
               .catch(handleFetchErr)
-              .then(function () { btn.disabled = false; btn.textContent = 'Refresh'; });
+              .then(function () { btn.disabled = false; btn.textContent = 'Refresh now'; });
           };
         }
       }