Update app.py

app.py

@@ -1,603 +1,272 @@
-
 # ===============================================================
-# Rendered Frame Theory — Live Prediction Console (Open Method)
-# Domains: Atmospheric / Seismic / Magnetic / Solar
-# Full transparency: exact inputs + computed z, τ_eff, Ω_obs, α_R, index, and decision rule.
-# Single-file.
+# Rendered Frame Theory — Forecast Lab Console (Instant Falsifiability Links)
 # ===============================================================
 
-import math
-from datetime import datetime, timezone, timedelta
-
 import gradio as gr
-import httpx
-import numpy as np
-import pandas as pd
-
-APP_NAME = "Rendered Frame Theory — Live Prediction Console (Open Method)"
-UA = {"User-Agent": "RFTSystems/LivePredictionConsole"}
-
-T_EARTH = 365.2422 * 24 * 3600.0
-OMEGA_OBS = 2.0 * math.pi / T_EARTH
-K_TAU = 1.38
-ALPHA_R = 1.02
-
-REGION_BBOX = {
-    "Global": None,
-    "EMEA": (-35.0, -20.0, 70.0, 60.0),
-    "AMER": (-60.0, -170.0, 72.0, -30.0),
-    "APAC": (-50.0, 60.0, 60.0, 180.0),
-}
-RING_OF_FIRE_BBOXES = [
-    (-60.0, 120.0, 60.0, 180.0),
-    (-60.0, -180.0, 60.0, -100.0),
-    (10.0, -90.0, 60.0, -60.0),
-]
-
-
-def utc_now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-
-
-def clamp(x: float, a: float, b: float) -> float:
-    return max(a, min(b, x))
-
-
-def tau_eff_from_z(z: float) -> float:
-    z = max(0.0, float(z))
-    return K_TAU * math.log(1.0 + z)
-
-
-def stable_log_ratio(x: float, x0: float) -> float:
-    x = max(float(x), 1e-30)
-    x0 = max(float(x0), 1e-30)
-    return math.log(x / x0)
-
-
-def index_from_tau(tau: float) -> float:
-    return float(OMEGA_OBS * float(tau) * ALPHA_R)
-
-
-def geocode_location(q: str):
-    q = (q or "").strip()
-    if not q:
-        return None, None, "Empty location"
-    url = "https://geocoding-api.open-meteo.com/v1/search"
-    params = {"name": q, "count": 1, "language": "en", "format": "json"}
-    r = httpx.get(url, params=params, headers=UA, timeout=12)
-    r.raise_for_status()
-    js = r.json()
-    results = js.get("results") or []
-    if not results:
-        return None, None, f"Could not geocode '{q}'"
-    top = results[0]
-    lat = float(top["latitude"])
-    lon = float(top["longitude"])
-    display = f"{top.get('name','')}, {top.get('country_code','')}".strip().strip(",")
-    return lat, lon, display
-
-
-def fetch_openmeteo_hourly(lat: float, lon: float, past_days: int = 1):
-    url = "https://api.open-meteo.com/v1/forecast"
-    params = {
-        "latitude": lat,
-        "longitude": lon,
-        "hourly": "temperature_2m,relative_humidity_2m,pressure_msl,wind_speed_10m",
-        "past_days": past_days,
-        "forecast_days": 1,
-        "timezone": "UTC",
-    }
-    r = httpx.get(url, params=params, headers=UA, timeout=18)
-    r.raise_for_status()
-    js = r.json()
-    hourly = js.get("hourly") or {}
-    return {
-        "time": hourly.get("time") or [],
-        "temp": hourly.get("temperature_2m") or [],
-        "rh": hourly.get("relative_humidity_2m") or [],
-        "p": hourly.get("pressure_msl") or [],
-        "wind": hourly.get("wind_speed_10m") or [],
-    }
-
-
-def fetch_kp_last_24h():
-    url = "https://services.swpc.noaa.gov/json/planetary_k_index_1m.json"
-    r = httpx.get(url, headers=UA, timeout=15)
-    r.raise_for_status()
-    js = r.json()
-    if not isinstance(js, list) or not js:
-        return []
-    vals = []
-    for row in js:
-        kp = row.get("kp_index")
-        if kp is None:
-            continue
-        try:
-            vals.append(float(kp))
-        except Exception:
-            pass
-    return vals[-1440:]
+from datetime import datetime, timezone
+import pandas as pd, numpy as np, httpx, io, csv
+
+from rft_core.geocode import geocode_location
+from data_adapters.noaa_geomag import fetch_k_index
+from data_adapters.goes_xray import fetch_goes_flux
+from data_adapters.metar_weather import fetch_meteo
+from data_adapters.usgs_quakes import fetch_usgs_recent
+
+from scoreboard_core import load_entries
+from scoreboard_jobs import run_daily_cycle
+
+APP_NAME = "Rendered Frame Theory — Forecast Lab Console"
+
+# ---------- Helpers -----------------------------------------------------------
+def classify_kp(kp: float) -> str:
+    if kp >= 7: return f"Kp={kp} (severe storm)"
+    if kp >= 5: return f"Kp={kp} (storm)"
+    if kp >= 4: return f"Kp={kp} (active)"
+    if kp >= 3: return f"Kp={kp} (unsettled)"
+    return f"Kp={kp} (quiet)"
+
+def classify_flux(flux: float) -> str:
+    # GOES 1–8 Å classes
+    if flux >= 1e-4: return f"{flux:.2e} (X-class)"
+    if flux >= 1e-5: return f"{flux:.2e} (M-class)"
+    if flux >= 1e-6: return f"{flux:.2e} (C-class)"
+    if flux >= 1e-7: return f"{flux:.2e} (B-class)"
+    return f"{flux:.2e} (A-class)"
+
+def build_verification_links(lat: float, lon: float, region: str) -> str:
+    """
+    Returns a Markdown block with direct verification links so users can falsify instantly.
+    """
+    # Magnetic (Kp)
+    swpc_kp_page = "https://www.swpc.noaa.gov/products/planetary-k-index"
+    swpc_kp_json  = "https://services.swpc.noaa.gov/products/noaa-planetary-k-index.json"
+
+    # Solar (GOES X-ray)
+    goes_plot_page = "https://www.swpc.noaa.gov/products/goes-x-ray-flux"
+    goes_primary_csv = "https://services.swpc.noaa.gov/text/goes-xray-flux-primary.csv"
+    goes_secondary_csv = "https://services.swpc.noaa.gov/text/goes-xray-flux-secondary.csv"
+
+    # Atmospheric (Open-Meteo)
+    # This is a direct URL to a forecast call for that lat/lon that anyone can open.
+    open_meteo_link = (
+        "https://api.open-meteo.com/v1/forecast"
+        f"?latitude={lat:.5f}&longitude={lon:.5f}"
+        "&hourly=temperature_2m&past_days=1&forecast_days=1&timezone=UTC"
+    )
 
+    # Seismic (USGS)
+    # Past day, minimum magnitude 2.5, global feed.
+    usgs_map = "https://earthquake.usgs.gov/earthquakes/map/"
+    usgs_query = (
+        "https://earthquake.usgs.gov/fdsnws/event/1/query"
+        "?format=geojson&starttime=&endtime=&minmagnitude=2.5"
+    )
+    usgs_past_day_geojson = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.geojson"
+
+    return (
+        "### Verify these results instantly (official sources)\n"
+        f"- **Magnetic (Kp):** {swpc_kp_page}  \n"
+        f"  Live feed JSON: {swpc_kp_json}\n"
+        f"- **Solar (GOES X-ray):** {goes_plot_page}  \n"
+        f"  Live CSV: {goes_primary_csv}  \n"
+        f"  Backup CSV: {goes_secondary_csv}\n"
+        f"- **Atmospheric (Temp history near your location):** {open_meteo_link}\n"
+        f"- **Seismic (USGS map):** {usgs_map}  \n"
+        f"  Past-day M≥2.5 GeoJSON: {usgs_past_day_geojson}\n"
+        "\n"
+        "**Note:** In the current build, the seismic summary is global (past 24h), so it won’t change with location. "
+        "If you want it to be location-aware, we filter USGS by radius around your lat/lon."
+    )
 
-def fetch_goes_xray_1day():
-    url = "https://services.swpc.noaa.gov/json/goes/primary/xrays-1-day.json"
-    r = httpx.get(url, headers=UA, timeout=15)
-    r.raise_for_status()
-    js = r.json()
-    if not isinstance(js, list) or not js:
-        return []
-    out = []
-    for row in js:
-        f = row.get("flux")
-        if f is None:
-            continue
+# ---------- Live domain logic -------------------------------------------------
+def magnetic_block():
+    """
+    Primary: SWPC JSON feed; fallback: Kyoto WDC mirror (open endpoint).
+    """
+    try:
         try:
-            out.append(float(f))
+            data = fetch_k_index(24)
         except Exception:
-            pass
-    return out
-
-
-def fetch_usgs_quakes(hours: int, minmag: float, bbox=None):
-    url = "https://earthquake.usgs.gov/fdsnws/event/1/query"
-    end = datetime.now(timezone.utc)
-    start = end - timedelta(hours=int(hours))
-    params = {
-        "format": "geojson",
-        "starttime": start.isoformat().replace("+00:00", "Z"),
-        "endtime": end.isoformat().replace("+00:00", "Z"),
-        "minmagnitude": str(float(minmag)),
-        "orderby": "time",
-    }
-    if bbox is not None:
-        minlat, minlon, maxlat, maxlon = bbox
-        params.update(
-            {
-                "minlatitude": str(minlat),
-                "minlongitude": str(minlon),
-                "maxlatitude": str(maxlat),
-                "maxlongitude": str(maxlon),
-            }
-        )
-    r = httpx.get(url, params=params, headers=UA, timeout=22)
-    r.raise_for_status()
-    js = r.json()
-    feats = js.get("features") if isinstance(js, dict) else None
-    if not feats:
-        return []
-    out = []
-    for f in feats:
-        props = f.get("properties") or {}
-        out.append({"id": f.get("id"), "mag": props.get("mag"), "place": props.get("place"), "time": props.get("time")})
-    return out
-
-
-def magnetic_agent():
-    kp = fetch_kp_last_24h()
-    if len(kp) < 30:
-        return {"enabled": False, "reason": "NOAA Kp feed too short"}
-    last = float(kp[-1])
-    tail = kp[-360:] if len(kp) >= 360 else kp
-    drift = float(np.std(tail)) if len(tail) >= 10 else 0.0
-    slope = float((tail[-1] - tail[0]) / max(1, len(tail) - 1))
-
-    z = clamp((last / 9.0) + (drift / 2.0) + 2.0 * abs(slope), 0.0, 3.0)
-    tau = tau_eff_from_z(z)
-    idx = index_from_tau(tau)
-
-    if last >= 7.0 or z >= 2.0:
-        pred = "warning"
-        rule = "Kp>=7 OR z>=2.0"
-    elif last >= 5.0 or z >= 1.2:
-        pred = "watch"
-        rule = "Kp>=5 OR z>=1.2"
-    elif last >= 4.0 or z >= 0.8:
-        pred = "monitor"
-        rule = "Kp>=4 OR z>=0.8"
-    else:
-        pred = "hold"
-        rule = "else"
-
-    live = f"Global Kp={last:.1f} | drift={drift:.2f} | slope={slope:.4f}"
-    return {
-        "enabled": True,
-        "domain": "Magnetic",
-        "prediction": pred,
-        "rule_fired": rule,
-        "z": float(z),
-        "tau_eff": float(tau),
-        "omega_obs": float(OMEGA_OBS),
-        "alpha_r": float(ALPHA_R),
-        "index": float(idx),
-        "live_status": live,
-        "truth_source": "NOAA SWPC planetary_k_index_1m (global)",
-        "inputs_used": {"kp_last": last, "kp_drift": drift, "kp_slope": slope, "tail_len": len(tail)},
-        "location_effect": "Location input does not change Magnetic. Kp is a global index.",
-        "do": "Use this to track global geomagnetic storm regime shifts.",
-        "dont": "Do not treat this as a city-level magnetometer or outage predictor.",
-        "what_it_is_not": "Not a local geomagnetic forecast. Not a power-grid impact model.",
-        "why": "z_mag compresses magnitude+variability into a bounded stress coordinate; τ_eff rises as ln(1+z).",
-        "how": "Fetch Kp → compute last/variability/slope → z_mag → τ_eff=1.38 ln(1+z) → Index=Ω_obs·τ_eff·α_R → label via fixed thresholds.",
-    }
-
-
-def solar_agent():
-    flux = fetch_goes_xray_1day()
-    if len(flux) < 50:
-        return {"enabled": False, "reason": "GOES X-ray feed too short"}
-    tail = flux[-120:] if len(flux) >= 120 else flux[-60:]
-    f_mean = float(np.mean(tail))
-    f_peak = float(np.max(tail))
-
-    lr = stable_log_ratio(f_mean, 1e-8)
-    z = clamp(lr / 10.0, 0.0, 3.0)
-    tau = tau_eff_from_z(z)
-    idx = index_from_tau(tau)
-
-    if f_peak >= 1e-4 or z >= 2.2:
-        pred = "flare likely"
-        rule = "peak>=1e-4 OR z>=2.2"
-    elif f_peak >= 1e-5 or z >= 1.5:
-        pred = "flare watch"
-        rule = "peak>=1e-5 OR z>=1.5"
-    elif f_mean >= 1e-6 or z >= 0.9:
-        pred = "monitor"
-        rule = "mean>=1e-6 OR z>=0.9"
-    else:
-        pred = "hold"
-        rule = "else"
-
-    live = f"Global GOES mean={f_mean:.2e} | peak={f_peak:.2e}"
-    return {
-        "enabled": True,
-        "domain": "Solar",
-        "prediction": pred,
-        "rule_fired": rule,
-        "z": float(z),
-        "tau_eff": float(tau),
-        "omega_obs": float(OMEGA_OBS),
-        "alpha_r": float(ALPHA_R),
-        "index": float(idx),
-        "live_status": live,
-        "truth_source": "NOAA SWPC GOES primary xrays-1-day (global)",
-        "inputs_used": {"flux_mean": f_mean, "flux_peak": f_peak, "tail_len": len(tail)},
-        "location_effect": "Location input does not change Solar. GOES flux is global.",
-        "do": "Use this to track global solar radiative regime changes.",
-        "dont": "Do not treat this as a flare time predictor or CME trajectory forecast.",
-        "what_it_is_not": "Not a flare timing model. Not a CME arrival model.",
-        "why": "z_solar is derived from flux relative to baseline via a log ratio; τ_eff rises as ln(1+z).",
-        "how": "Fetch GOES flux → mean/peak → z_solar=clamp(ln(F_mean/1e-8)/10) → τ_eff → Index → label via fixed thresholds.",
-    }
-
-
-def atmospheric_agent(lat: float, lon: float, display: str):
-    wx = fetch_openmeteo_hourly(lat, lon, past_days=1)
-    temp = wx["temp"]
-    p = wx["p"]
-    wind = wx["wind"]
-
-    if len(temp) < 13:
-        return {"enabled": False, "reason": "Open-Meteo hourly series too short"}
-
-    t12 = [float(x) for x in temp[-13:]]
-    dT = float(max(t12) - min(t12))
-
-    dp = None
-    if len(p) >= 13:
-        p12 = [float(x) for x in p[-13:]]
-        dp = float(p12[-1] - p12[0])
-
-    w_mean = None
-    if len(wind) >= 13:
-        w12 = [float(x) for x in wind[-13:]]
-        w_mean = float(np.mean(w12))
-
-    z_dt = clamp(dT / 10.0, 0.0, 2.0)
-    z_dp = clamp((abs(dp) / 12.0) if dp is not None else 0.0, 0.0, 1.5)
-    z = clamp(z_dt + z_dp, 0.0, 3.0)
-    tau = tau_eff_from_z(z)
-    idx = index_from_tau(tau)
-
-    if dT >= 10.0 or (dp is not None and dp <= -10.0):
-        pred = "storm risk"
-        rule = "ΔT>=10 OR ΔP<=-10"
-    elif dT >= 7.0 or (dp is not None and dp <= -6.0):
-        pred = "swing"
-        rule = "ΔT>=7 OR ΔP<=-6"
-    elif dT >= 4.0:
-        pred = "mild swing"
-        rule = "ΔT>=4"
-    else:
-        pred = "stable"
-        rule = "else"
-
-    parts = [f"{display} ΔT(12h)={dT:.1f}°C"]
-    if dp is not None:
-        parts.append(f"ΔP(12h)={dp:.1f} hPa")
-    if w_mean is not None:
-        parts.append(f"wind≈{w_mean:.1f} m/s")
-    live = " | ".join(parts)
-
-    return {
-        "enabled": True,
-        "domain": "Atmospheric",
-        "prediction": pred,
-        "rule_fired": rule,
-        "z": float(z),
-        "tau_eff": float(tau),
-        "omega_obs": float(OMEGA_OBS),
-        "alpha_r": float(ALPHA_R),
-        "index": float(idx),
-        "live_status": live,
-        "truth_source": "Open-Meteo hourly (location-based)",
-        "inputs_used": {"dT_12h": dT, "dP_12h": dp, "wind_mean": w_mean, "lat": lat, "lon": lon},
-        "location_effect": "Location input changes Atmospheric because it queries the selected lat/lon.",
-        "do": "Use this as a short-term stability detector from temperature swing and pressure change.",
-        "dont": "Do not treat this as a rain/snow probability forecast or a full numerical weather model.",
-        "what_it_is_not": "Not a precipitation forecast. Not a synoptic model. Not a radar nowcast.",
-        "why": "z_atm is derived from thermal swing and pressure change as a bounded stress coordinate; τ_eff rises as ln(1+z).",
-        "how": "Geocode → fetch hourly series → compute ΔT and ΔP (last ~12h) → z_atm → τ_eff → Index → label via fixed thresholds.",
-    }
-
-
-def seismic_agent(region: str):
-    if region == "RingOfFire":
-        seen = set()
-        eqs = []
-        for bb in RING_OF_FIRE_BBOXES:
-            chunk = fetch_usgs_quakes(hours=24, minmag=2.5, bbox=bb)
-            for e in chunk:
-                eid = e.get("id")
-                if eid and eid not in seen:
-                    seen.add(eid)
-                    eqs.append(e)
-    else:
-        bbox = REGION_BBOX.get(region, None)
-        eqs = fetch_usgs_quakes(hours=24, minmag=2.5, bbox=bbox)
-
-    N = int(len(eqs))
-    mags = []
-    for e in eqs:
-        m = e.get("mag")
-        if m is None:
-            continue
+            url = "https://wdc.kugi.kyoto-u.ac.jp/kp/kp.json"
+            r = httpx.get(url, timeout=10)
+            j = r.json()
+            data = [{"kp": float(v)} for v in j[-24:]] if isinstance(j, list) else []
+        if not data:
+            return ("hold", "no data")
+        last_kp = float(data[-1]["kp"])
+        drift = np.std([d["kp"] for d in data[-6:]]) if len(data) >= 6 else 0.0
+        rft_pred = "storm soon" if last_kp >= 5 or drift > 1.2 else "quiet"
+        live = classify_kp(round(last_kp, 1))
+        return (rft_pred, live)
+    except Exception:
+        return ("hold", "fetch error")
+
+def solar_block():
+    """
+    Primary: GOES flux CSV; fallback: secondary mirror if blocked.
+    """
+    try:
         try:
-            mags.append(float(m))
+            data = fetch_goes_flux(24)
         except Exception:
-            pass
-    Mmax = float(max(mags)) if mags else 0.0
-
-    z_count = clamp(N / 60.0, 0.0, 1.5)
-    z_mag = clamp(max(0.0, Mmax - 4.0) / 2.5, 0.0, 1.5)
-    z = clamp(z_count + z_mag, 0.0, 3.0)
-    tau = tau_eff_from_z(z)
-    idx = index_from_tau(tau)
-
-    if Mmax >= 6.5 or z >= 2.2:
-        pred = "alert"
-        rule = "Mmax>=6.5 OR z>=2.2"
-    elif Mmax >= 5.5 or z >= 1.5:
-        pred = "watch"
-        rule = "Mmax>=5.5 OR z>=1.5"
-    elif N >= 25 or z >= 1.0:
-        pred = "monitor"
-        rule = "N>=25 OR z>=1.0"
-    else:
-        pred = "quiet"
-        rule = "else"
-
-    scope = "Global" if region == "Global" else region
-    live = f"{scope} quakes(24h,M≥2.5)={N} | max M{Mmax:.1f}"
-
-    return {
-        "enabled": True,
-        "domain": "Seismic",
-        "prediction": pred,
-        "rule_fired": rule,
-        "z": float(z),
-        "tau_eff": float(tau),
-        "omega_obs": float(OMEGA_OBS),
-        "alpha_r": float(ALPHA_R),
-        "index": float(idx),
-        "live_status": live,
-        "truth_source": "USGS FDSN event feed (region-filtered)",
-        "inputs_used": {"count_24h": N, "max_mag_24h": Mmax, "region": region},
-        "location_effect": "Location input does not change Seismic in region mode. It filters by selected region, not by city.",
-        "do": "Use this as a regional seismic stress monitor (regime detection).",
-        "dont": "Do not treat this as a time-and-epicenter earthquake prediction system.",
-        "what_it_is_not": "Not an earthquake time predictor. Not a rupture location predictor.",
-        "why": "z_seis compresses activity density and severity into a bounded stress coordinate; τ_eff rises as ln(1+z).",
-        "how": "Fetch USGS in region → count + max magnitude → z_seis → τ_eff → Index → label via fixed thresholds.",
-    }
-
-
-def run_forecast(location_text: str, seismic_region: str):
-    try:
-        lat, lon, display = geocode_location(location_text)
-    except Exception as e:
-        df = pd.DataFrame([{"Domain": "Error", "RFT Prediction": "DISABLED", "Live Status": f"Geocode error: {e}"}])
-        empty = {"enabled": False, "reason": f"Geocode error: {e}"}
-        return f"❌ Geocode error: {e}", df, empty, empty, empty, empty
-
-    if lat is None:
-        df = pd.DataFrame([{"Domain": "Error", "RFT Prediction": "DISABLED", "Live Status": display}])
-        empty = {"enabled": False, "reason": display}
-        return f"❌ {display}", df, empty, empty, empty, empty
-
+            url = "https://services.swpc.noaa.gov/text/goes-xray-flux-secondary.csv"
+            r = httpx.get(url, timeout=10)
+            reader = csv.DictReader(io.StringIO(r.text))
+            data = [{"flux": float(row["flux"])} for row in reader if row.get("flux")]
+        if not data:
+            return ("hold", "no data")
+        tail = data[-30:] if len(data) >= 30 else data
+        flux_mean = float(np.mean([d["flux"] for d in tail]))
+        rft_pred = "flare watch" if flux_mean > 1e-6 else "calm"
+        live = classify_flux(flux_mean)
+        return (rft_pred, live)
+    except Exception:
+        return ("hold", "fetch error")
+
+def atmos_block(lat: float, lon: float):
     try:
-        atm = atmospheric_agent(lat, lon, display)
-    except Exception as e:
-        atm = {"enabled": False, "reason": f"atmos error: {e}"}
-
-    try:
-        sei = seismic_agent(seismic_region)
-    except Exception as e:
-        sei = {"enabled": False, "reason": f"seismic error: {e}"}
-
+        data = fetch_meteo(lat, lon)
+        if not data:
+            return ("hold", "no data")
+        temps = [d["temp"] for d in data[-12:]] if len(data) >= 12 else [d["temp"] for d in data]
+        dT = (max(temps) - min(temps)) if temps else 0.0
+        rft_pred = "swing" if dT >= 6 else "stable"
+        live = f"ΔT(12 h) = {dT:.1f} °C"
+        return (rft_pred, live)
+    except Exception:
+        return ("hold", "fetch error")
+
+def seismic_block(region: str):
     try:
-        mag = magnetic_agent()
-    except Exception as e:
-        mag = {"enabled": False, "reason": f"magnetic error: {e}"}
-
-    try:
-        sol = solar_agent()
-    except Exception as e:
-        sol = {"enabled": False, "reason": f"solar error: {e}"}
-
-    def fmt_row(domain: str, out: dict):
-        if not out.get("enabled"):
-            return {"Domain": domain, "RFT Prediction": "DISABLED", "Live Status": out.get("reason", "missing inputs")}
-        idx = out.get("index", None)
-        z = out.get("z", None)
-        tau = out.get("tau_eff", None)
-        idx_s = f"{float(idx):.3e}" if isinstance(idx, (int, float)) else "n/a"
-        z_s = f"{float(z):.2f}" if isinstance(z, (int, float)) else "n/a"
-        t_s = f"{float(tau):.3f}" if isinstance(tau, (int, float)) else "n/a"
-        return {
-            "Domain": domain,
-            "RFT Prediction": f"{out.get('prediction','hold')} | idx={idx_s} | z={z_s} | τ={t_s}",
-            "Live Status": out.get("live_status", ""),
-        }
+        eqs = fetch_usgs_recent(24, 2.5)
+        if not eqs:
+            return ("quiet", "0 events (M≥2.5)")
+        count = len(eqs)
+        mags = [e["mag"] for e in eqs if e.get("mag") is not None]
+        max_mag = max(mags) if mags else 0.0
+        rft_pred = "watch" if max_mag >= 5.0 or count >= 20 else "quiet"
+        live = f"{count} events, max M{max_mag:.1f}"
+        return (rft_pred, live)
+    except Exception:
+        return ("hold", "fetch error")
+
+# ---------- Orchestrator ------------------------------------------------------
+def run_live_dashboard(loc_name: str, region: str):
+    lat, lon, display = geocode_location(loc_name)
+    if lat is None:
+        return (
+            f"❌ Could not find location '{loc_name}'",
+            pd.DataFrame(columns=["Domain","RFT Prediction","Live Status"]),
+            ""
+        )
 
-    df = pd.DataFrame(
-        [
-            fmt_row("Atmospheric", atm),
-            fmt_row("Seismic", sei),
-            fmt_row("Magnetic", mag),
-            fmt_row("Solar", sol),
-        ]
+    mag_pred, mag_live = magnetic_block()
+    sol_pred, sol_live = solar_block()
+    atm_pred, atm_live = atmos_block(lat, lon)
+    sei_pred, sei_live = seismic_block(region)
+
+    rows = [
+        {"Domain": "Magnetic",    "RFT Prediction": mag_pred, "Live Status": mag_live},
+        {"Domain": "Solar",       "RFT Prediction": sol_pred, "Live Status": sol_live},
+        {"Domain": "Atmospheric", "RFT Prediction": atm_pred, "Live Status": atm_live},
+        {"Domain": "Seismic",     "RFT Prediction": sei_pred, "Live Status": sei_live},
+    ]
+    df = pd.DataFrame(rows)
+    ts = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+    header = f"**Location:** {display} | **UTC:** {ts}"
+    links_md = build_verification_links(lat, lon, region)
+    return header, df, links_md
+
+# ---------- Scoreboard helpers -----------------------------------------------
+def run_daily_cycle_ui() -> str:
+    records = run_daily_cycle()
+    if not records:
+        return "No records written (check scoreboard_jobs wiring)."
+    win = records[0]["window"]
+    return (
+        f"Logged {len(records)} scoreboard entries for window "
+        f"{win['start']} → {win['end']} (magnetic, solar, METAR)."
     )
 
-    ts = utc_now_iso()
-    header = f"**Location:** {display} (lat {lat:.3f}, lon {lon:.3f}) | **UTC:** {ts}"
-    return header, df, atm, sei, mag, sol
-
-
-INSTRUCTIONS_MD = """
-## Use and interpretation
-
-**Location input**
-- Used for Atmospheric.
-- Not used for Solar or Magnetic (global signals).
-- Seismic is region-filtered (not city-level) in this build.
-
-**Seismic region**
-- Filters USGS earthquakes by large tectonic region.
-- Counts are not “near your city” unless a radius mode is implemented.
-
-**Run Forecast**
-- Pulls live data and recomputes from scratch.
-- No auto-refresh. No memory. No smoothing.
-
-**Reading the table**
-- RFT Prediction shows model state + index + z + τ_eff.
-- Live Status shows the raw physical measurements used.
-- DISABLED means missing/insufficient live data; no guessing is performed.
-"""
-
-ATM_MD = """
-## Atmospheric
-- This is a short-term stability detector from temperature swing and pressure change.
-- This is not a precipitation forecast and not a full numerical weather model.
-"""
-
-SEIS_MD = """
-## Seismic
-- This is a regional seismic stress monitor from activity density and peak magnitude.
-- This is not a time/epicenter prediction system.
-"""
-
-MAG_MD = """
-## Magnetic
-- This tracks global geomagnetic storm regime shifts using NOAA Kp.
-- This is not a local magnetometer reading or grid-impact forecast.
-"""
-
-SOL_MD = """
-## Solar
-- This tracks global solar radiative regime shifts using GOES X-ray flux.
-- This is not a flare timing predictor or CME arrival model.
-"""
-
-METHOD_MD = f"""
-## Open method equations
-
-Shared core:
-- τ_eff = {K_TAU} · ln(1 + z)
-- Ω_obs = 2π / T_earth = {OMEGA_OBS:.6e}
-- α_R = {ALPHA_R}
-- Index = Ω_obs · τ_eff · α_R
-
-z definitions:
-- Atmospheric: z_atm = clamp( clamp(ΔT/10,0..2) + clamp(|ΔP|/12,0..1.5), 0..3 )
-- Seismic:     z_seis = clamp( clamp(N/60,0..1.5) + clamp(max(0,Mmax-4)/2.5,0..1.5), 0..3 )
-- Magnetic:    z_mag  = clamp( (Kp_last/9) + (drift/2) + 2·|slope|, 0..3 )
-- Solar:       z_solar= clamp( ln(F_mean/1e-8)/10, 0..3 )
-
-Decision thresholds are shown per-domain in the agent output under “rule_fired”.
-"""
-
-
+def build_scoreboard_df() -> pd.DataFrame:
+    entries = load_entries(limit=200)
+    if not entries:
+        return pd.DataFrame(
+            columns=[
+                "timestamp", "domain", "window_start", "window_end",
+                "event", "baseline_p", "rft_p",
+                "brier_baseline", "brier_rft"
+            ]
+        )
+    rows = []
+    for e in entries:
+        ts = datetime.fromtimestamp(e["timestamp"], tz=timezone.utc).isoformat().replace("+00:00", "Z")
+        win = e.get("window", {})
+        rows.append({
+            "timestamp": ts,
+            "domain": e.get("domain", ""),
+            "window_start": win.get("start", ""),
+            "window_end": win.get("end", ""),
+            "event": e.get("event"),
+            "baseline_p": e.get("baseline_p"),
+            "rft_p": e.get("rft_p"),
+            "brier_baseline": e.get("brier_baseline"),
+            "brier_rft": e.get("brier_rft"),
+        })
+    df = pd.DataFrame(rows)
+    df.sort_values("timestamp", ascending=False, inplace=True)
+    return df
+
+# ---------- UI ---------------------------------------------------------------
 with gr.Blocks(title=APP_NAME) as demo:
-    gr.Markdown(f"# {APP_NAME}")
+    gr.Markdown(f"# {APP_NAME}\nLive multi-domain forecast — simple, clear, always live.")
 
     with gr.Tab("Live Forecast"):
         with gr.Row():
-            loc = gr.Textbox(label="Location", value="London")
-        gr.Markdown(
-            "**Location input**\n\n"
-            "- Used for Atmospheric.\n"
-            "- Not used for Solar or Magnetic (global signals).\n"
-            "- Seismic is region-filtered in this build.\n\n"
-            "If a location cannot be resolved, predictions are disabled instead of guessed."
-        )
+            loc_name = gr.Textbox(label="Location (city or region)", value="London")
+            region = gr.Dropdown(
+                ["Global","EMEA","AMER","APAC","RingOfFire"],
+                value="EMEA", label="Seismic Region"
+            )
 
-        with gr.Row():
-            region = gr.Dropdown(["Global", "EMEA", "AMER", "APAC", "RingOfFire"], value="EMEA", label="Seismic Region")
-        gr.Markdown(
-            "**Seismic region selector**\n\n"
-            "- Filters USGS earthquakes by large region.\n"
-            "- Counts are not “near your city” unless radius mode is implemented.\n"
-            "- Not a time/epicenter prediction system."
-        )
+        run_btn = gr.Button("Run Forecast", variant="primary")
+        header_md = gr.Markdown()
+        table = gr.Dataframe(headers=["Domain","RFT Prediction","Live Status"], interactive=False)
+        verify_md = gr.Markdown()
 
-        btn = gr.Button("Run Forecast", variant="primary")
-        gr.Markdown(
-            "**Run Forecast**\n\n"
-            "- Pulls live data and recomputes from scratch.\n"
-            "- No auto-refresh.\n"
-            "- No stored memory.\n"
-            "- No guessing when data is missing."
-        )
+        run_btn.click(run_live_dashboard, [loc_name, region], [header_md, table, verify_md])
 
-        header_md = gr.Markdown()
+    with gr.Tab("Scoreboard"):
         gr.Markdown(
-            "**How to read the table**\n\n"
-            "- RFT Prediction shows model state + index + z + τ_eff.\n"
-            "- Live Status shows the raw physical measurements used.\n"
-            "- DISABLED means missing/insufficient live data; no guessing is performed."
+            "### RFT Falsifiability Scoreboard\n"
+            "This tab logs **synthetic but structured** daily tests for:\n"
+            "- Geomagnetic Kp storms\n"
+            "- GOES X-ray flux pulses\n"
+            "- METAR temperature swings\n\n"
+            "Each row: event flag, baseline probability, RFT probability, and Brier scores."
         )
-        table = gr.Dataframe(headers=["Domain", "RFT Prediction", "Live Status"], interactive=False)
-
-        with gr.Accordion("Atmospheric details", open=False):
-            gr.Markdown(ATM_MD)
-            atm_json = gr.JSON(label="Atmospheric agent output")
-        with gr.Accordion("Seismic details", open=False):
-            gr.Markdown(SEIS_MD)
-            sei_json = gr.JSON(label="Seismic agent output")
-        with gr.Accordion("Magnetic details", open=False):
-            gr.Markdown(MAG_MD)
-            mag_json = gr.JSON(label="Magnetic agent output")
-        with gr.Accordion("Solar details", open=False):
-            gr.Markdown(SOL_MD)
-            sol_json = gr.JSON(label="Solar agent output")
+        cycle_btn = gr.Button("Run daily scoring cycle (yesterday UTC)")
+        cycle_status = gr.Markdown()
+        cycle_btn.click(run_daily_cycle_ui, inputs=None, outputs=cycle_status)
 
-        btn.click(run_forecast, inputs=[loc, region], outputs=[header_md, table, atm_json, sei_json, mag_json, sol_json])
-
-    with gr.Tab("Method (Open)"):
-        gr.Markdown(INSTRUCTIONS_MD)
-        gr.Markdown(METHOD_MD)
+        refresh_btn = gr.Button("Refresh scoreboard view")
+        board_df = gr.Dataframe(interactive=False)
+        refresh_btn.click(build_scoreboard_df, inputs=None, outputs=board_df)
 
+    with gr.Tab("Notes"):
+        gr.Markdown(
+            "## What this Space is doing\n"
+            "- Pulls public live feeds on-demand when you press **Run Forecast**.\n"
+            "- Computes simple, inspectable signals and prints both **RFT Prediction** and **Live Status**.\n"
+            "- Provides direct links for instant falsifiability (shown under the table after each run).\n\n"
+            "## What this Space is NOT doing\n"
+            "- It is not a guaranteed prediction engine.\n"
+            "- It is not hiding logic behind symbols.\n"
+            "- It is not auto-refreshing.\n\n"
+            "## Why some values look the same across locations\n"
+            "- The current seismic summary is global (past 24h). Location-aware seismic requires filtering by radius "
+            "around your typed location.\n"
+        )
 
 if __name__ == "__main__":
     demo.launch()