refactor(regime): collapse the monitor page, fix the OAS rebuild window

The page had twelve stacked blocks, several of them different views of the
same numbers. The quadrant plot and the score-history chart drew the same two
series from the same query key, which read as two datasets; they are now one
card with a Time | Path toggle. The two pillar disclosures become one grouped
table, and three prose blocks (data quality, basket, coverage) become one
provenance chip strip. Page text is now limited to what changes how the reader
interprets today's number; the rest moved to the methodology doc.

Removes three stale-threshold bugs of one class. The quadrant fell back to v2's
60/60 dividers when quadrant_config was absent -- the real values are 50/40 and
they feed alert_service, so the chart could disagree with what actually fires.
The gauge fell back to v2's 30/60/80 band ticks, and drew a divider line that
always landed on its own "elevated" tick. The time series' reference lines were
at 30/60/80, which correspond to nothing in v3; they are now per-axis dashed
lines read from the same quadrant_config. Rendering also surfaced a live
clipping bug inherited from the old chart: margin.left -18 against YAxis
width 28 left ~10px for a 3-digit label, so every Y tick was cut off.

HY_OAS_WINDOW_DAYS was 400 *calendar* days while a rebuild replays
REBUILD_SESSIONS = 400 *trading* sessions (~579 calendar days), so the oldest
~180 days of any rebuild got no OAS at all and both credit sensors returned
None. State then lands at 80% coverage and Warning at exactly MIN_COVERAGE, so
both still publish bands -- a series that looks homogeneous while its oldest
rows were scored without credit. Widened to 700. This needs no methodology
bump: C1 reads [-1] and W3 reads [-21], both from the end, so widening only
prepends and every live score is bit-identical. Sequenced deliberately, since
acting on the open findings below bumps METHODOLOGY and fires the rebuild.

A just-collected fundamental observation was hidden until its effective date --
one day, three over a weekend -- because the live reading called the
point-in-time function, so refreshing appeared to do nothing. That was the
opposite of what the doc claimed. fundamental_overlay stays the gated record
(it runs for every replayed date during a rebuild); current_observation is the
live reading and reports the effective date instead of blanking the content.
Nothing in the overlay is scored, so showing it early cannot reach a published
number.

Documents four calculation findings. Three are not implemented, since each
changes a published score and so requires a v4 cut: State's top band is a
credit-event band (credit returns 0.0 rather than None below the 3.5 anchor, so
it is pinned at zero at weight 20 -- with everything else pegged State computes
to exactly 80.0, the breaking threshold); V1 saturates at VIX 30; and the
deliberate max(P1,P2,P3) defeats P3's anchoring because P1 is binary.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/services/regime_monitor_service.py

@@ -81,7 +81,16 @@ HY_OAS_STRESSED = 7.0
 # of stress at 3.5 -- the level these anchors call "mild".  The anchors already
 # encode the long-run distribution, so the credit *level* is now purely anchored
 # and credit *dynamics* live in W3 on the Warning axis where they belong.
-HY_OAS_WINDOW_DAYS = 400  # only W3's lookback plus slack is needed now
+# Calendar days, and it must cover the oldest date a rebuild replays -- not just
+# W3's lookback.  REBUILD_SESSIONS is 400 *trading* sessions (~579 calendar
+# days), so a 400-calendar-day fetch left the oldest ~180 days of a rebuild with
+# no OAS at all: C1 and W3 both returned None, State landed at 80% coverage and
+# Warning at exactly MIN_COVERAGE, and *both still published bands* -- a series
+# that looks homogeneous while its oldest rows were scored without credit.
+# Widening only prepends older observations; C1 reads [-1] and W3 reads [-21], so
+# live scores are unchanged and this needs no methodology bump.  Stays under
+# ICE's ~3-year cap so FRED still honours the request.
+HY_OAS_WINDOW_DAYS = 700
 W3_OAS_LOOKBACK = 20
 W3_OAS_FULL_SCALE_PCT = 35.0
 
@@ -477,17 +486,29 @@ def _fundamental_effective_date(overrides: dict) -> date | None:
     return _next_weekday(fetched) if fetched else None
 
 
+def _overlay_timing(
+    overrides: dict, config: dict, as_of: date
+) -> tuple[date | None, bool, int | None, bool]:
+    """Shared effective-date arithmetic: (effective, pending, age_days, stale)."""
+    effective = _fundamental_effective_date(overrides)
+    pending = effective is None or as_of < effective
+    age = None if pending else (as_of - effective).days
+    stale = bool(age is not None and age > int(config.get("fundamental_staleness_days", 80)))
+    return effective, pending, age, stale
+
+
 def fundamental_overlay(overrides: dict, config: dict, as_of: date) -> dict:
     """Point-in-time qualitative overlay. Never feeds State or Warning in v3.
 
     The effective-date gate stays even though nothing is scored from this: the
     400-session rebuild replays historical dates, and stamping today's LLM read
     onto 2024 snapshots would be plain lookahead in the stored record.
+
+    This is the *record*.  For "what do we know right now", use
+    ``current_observation`` -- do not add a bypass flag here, because this runs
+    for every replayed date during a rebuild.
     """
-    effective = _fundamental_effective_date(overrides)
-    pending = effective is None or as_of < effective
-    age = None if pending else (as_of - effective).days
-    stale = bool(age is not None and age > int(config.get("fundamental_staleness_days", 80)))
+    effective, pending, age, stale = _overlay_timing(overrides, config, as_of)
     return {
         "available": not pending and not stale,
         "pending": pending,
@@ -504,6 +525,35 @@ def fundamental_overlay(overrides: dict, config: dict, as_of: date) -> dict:
     }
 
 
+def current_observation(overrides: dict, config: dict, as_of: date) -> dict:
+    """The observation as it stands now, for the live reading only.
+
+    Same shape as ``fundamental_overlay``, but the effective date is *reported*
+    rather than used to blank the content.  A refresh stamps
+    ``_next_weekday(today)``, so gating the live card hid a just-collected read
+    for one day -- three over a weekend -- and refreshing appeared to do
+    nothing.  Nothing here is scored, so showing it early cannot leak into a
+    published number; the stored snapshot keeps the gate.
+    """
+    effective, pending, age, stale = _overlay_timing(overrides, config, as_of)
+    return {
+        # Live availability is about usefulness, not effectiveness: a pending
+        # observation is the freshest thing we have.
+        "available": not stale,
+        "pending": pending,
+        "stale": stale,
+        "effective_date": effective.isoformat() if effective else None,
+        "age_days": age,
+        "capex": overrides.get("capex"),
+        "good_news_stock_down": overrides.get("good_news_stock_down"),
+        "capex_stress": overrides.get("f1_score"),
+        "earnings_stress": overrides.get("f3_score"),
+        "reasoning": overrides.get("reasoning"),
+        "source": overrides.get("source"),
+        "fetched_at": overrides.get("fetched_at"),
+    }
+
+
 def _basket_hash(symbols: list[str]) -> str:
     canonical = ",".join(sorted({s.strip().upper() for s in symbols if s.strip()}))
     return hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:12]
@@ -1042,7 +1092,7 @@ def _delta(current: dict, previous: dict | None) -> float | None:
 async def get_regime_monitor(db: AsyncSession) -> dict:
     latest = await _latest_snapshot_row(db)
     if latest is None:
-        return {"available": False, "reason": "v2 not computed yet"}
+        return {"available": False, "reason": "not computed yet"}
     row, result = latest
     basket_hash = (result.get("basket") or {}).get("hash")
     previous_7 = await _result_at_or_before(
@@ -1071,7 +1121,9 @@ async def get_regime_monitor(db: AsyncSession) -> dict:
     # session, because otherwise refreshing it looks like it did nothing.
     config = await get_regime_config(db)
     overrides = await get_fundamental_overrides(db)
-    live = fundamental_overlay(overrides, config, date.today())
+    live = current_observation(overrides, config, date.today())
+    # Deliberately reads the *snapshot's* overlay, not the live one: this is how
+    # the reader tells "shown here" from "in the stored record".
     live["observed_in_snapshot"] = bool((result.get("fundamental_overlay") or {}).get("available"))
     result["fundamental_context"] = live
     result["available"] = True