Update app.py

app.py

@@ -1,272 +1,662 @@
+# app.py
 # ===============================================================
-# Rendered Frame Theory — Forecast Lab Console (Instant Falsifiability Links)
+# Rendered Frame Theory — Live Prediction Console (Open Method)
+# Domains: Atmospheric / Seismic / Magnetic / Solar
+# Adds: Seismic LOCAL radius mode (so location changes seismic)
+# Single-file. No placeholders.
 # ===============================================================
 
+import math
+from datetime import datetime, timezone, timedelta
+
 import gradio as gr
-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)
+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:]
+
+
+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
+        try:
+            out.append(float(f))
+        except Exception:
+            pass
+    return out
+
+
+def fetch_usgs_quakes(hours: int, minmag: float, bbox=None, center=None, radius_km=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),
+            }
+        )
+
+    if center is not None and radius_km is not None:
+        lat, lon = center
+        params.update(
+            {
+                "latitude": str(float(lat)),
+                "longitude": str(float(lon)),
+                "maxradiuskm": str(float(radius_km)),
+            }
+        )
+
+    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 build_verification_links(lat: float, lon: float, seismic_mode: str, seismic_region: str, radius_km: float) -> str:
     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"
+    swpc_kp_json = "https://services.swpc.noaa.gov/json/planetary_k_index_1m.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"
+    goes_xray_json = "https://services.swpc.noaa.gov/json/goes/primary/xrays-1-day.json"
 
-    # 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"
+        "&hourly=temperature_2m,pressure_msl,wind_speed_10m&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"
+    if seismic_mode == "Local radius":
+        usgs_query = (
+            "https://earthquake.usgs.gov/fdsnws/event/1/query"
+            f"?format=geojson&starttime=&endtime=&minmagnitude=2.5"
+            f"&latitude={lat:.5f}&longitude={lon:.5f}&maxradiuskm={float(radius_km):.0f}"
+        )
+        scope = f"Local radius query ({int(radius_km)} km around your location)"
+    else:
+        scope = f"Region mode ({seismic_region})"
+        usgs_query = "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&starttime=&endtime=&minmagnitude=2.5"
 
     return (
-        "### Verify these results instantly (official sources)\n"
+        "### Verify instantly (official sources)\n"
         f"- **Magnetic (Kp):** {swpc_kp_page}  \n"
-        f"  Live feed JSON: {swpc_kp_json}\n"
+        f"  Live 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"  Live JSON: {goes_xray_json}\n"
+        f"- **Atmospheric (Open-Meteo API for this 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."
+        f"  **USGS query used:** {usgs_query}  \n"
+        f"  Scope: {scope}\n"
     )
 
-# ---------- Live domain logic -------------------------------------------------
-def magnetic_block():
-    """
-    Primary: SWPC JSON feed; fallback: Kyoto WDC mirror (open endpoint).
-    """
-    try:
+
+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 does not change Magnetic. Kp is global.",
+        "do": "Use to track global geomagnetic regime shifts.",
+        "dont": "Do not treat as a city magnetometer.",
+    }
+
+
+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 xrays-1-day (global)",
+        "inputs_used": {"flux_mean": f_mean, "flux_peak": f_peak, "tail_len": len(tail)},
+        "location_effect": "Location does not change Solar. GOES flux is global.",
+        "do": "Use to track global solar radiative regime shifts.",
+        "dont": "Do not treat as flare timing or CME arrival prediction.",
+    }
+
+
+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 changes Atmospheric.",
+        "do": "Use as a short-term stability detector from ΔT and ΔP.",
+        "dont": "Do not treat as precipitation probability or full NWP forecast.",
+    }
+
+
+def seismic_agent_region(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)
+    return eqs, f"Region={region}"
+
+
+def seismic_agent_local(lat: float, lon: float, radius_km: float):
+    eqs = fetch_usgs_quakes(hours=24, minmag=2.5, center=(lat, lon), radius_km=radius_km)
+    return eqs, f"Local radius={int(radius_km)}km"
+
+
+def seismic_score(eqs):
+    N = int(len(eqs))
+    mags = []
+    for e in eqs:
+        m = e.get("mag")
+        if m is None:
+            continue
         try:
-            data = fetch_k_index(24)
+            mags.append(float(m))
         except Exception:
-            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.
-    """
+            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"
+
+    return pred, rule, z, tau, idx, N, Mmax
+
+
+def seismic_agent(mode: str, region: str, lat: float, lon: float, radius_km: float):
+    if mode == "Local radius":
+        eqs, scope = seismic_agent_local(lat, lon, radius_km)
+        location_effect = "Location changes Seismic in Local radius mode."
+        do = "Use to monitor seismic activity within the selected radius around your typed location."
+        dont = "Do not treat as time/epicenter prediction."
+        truth_scope = f"USGS events within {int(radius_km)} km"
+    else:
+        eqs, scope = seismic_agent_region(region)
+        location_effect = "Location does not change Seismic in Region mode. Region selector does."
+        do = "Use as a regional seismic stress monitor."
+        dont = "Do not treat as time/epicenter prediction."
+        truth_scope = f"USGS events filtered by region={region}"
+
+    pred, rule, z, tau, idx, N, Mmax = seismic_score(eqs)
+    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": f"USGS FDSN event feed ({truth_scope})",
+        "inputs_used": {"count_24h": N, "max_mag_24h": Mmax, "mode": mode, "region": region, "radius_km": float(radius_km), "lat": float(lat), "lon": float(lon)},
+        "location_effect": location_effect,
+        "do": do,
+        "dont": dont,
+        "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 → count + max magnitude → z_seis → τ_eff → Index → label via fixed thresholds.",
+    }
+
+
+def run_forecast(location_text: str, seismic_mode: str, seismic_region: str, radius_km: float):
     try:
-        try:
-            data = fetch_goes_flux(24)
-        except Exception:
-            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):
+        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
+
     try:
-        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):
+        atm = atmospheric_agent(lat, lon, display)
+    except Exception as e:
+        atm = {"enabled": False, "reason": f"atmos error: {e}"}
+
     try:
-        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"]),
-            ""
-        )
+        sei = seismic_agent(seismic_mode, seismic_region, lat, lon, radius_km)
+    except Exception as e:
+        sei = {"enabled": False, "reason": f"seismic error: {e}"}
 
-    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)."
+    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", ""),
+        }
+
+    df = pd.DataFrame(
+        [
+            fmt_row("Atmospheric", atm),
+            fmt_row("Seismic", sei),
+            fmt_row("Magnetic", mag),
+            fmt_row("Solar", sol),
+        ]
     )
 
-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 ---------------------------------------------------------------
+    ts = utc_now_iso()
+    header = f"**Location:** {display} (lat {lat:.3f}, lon {lon:.3f}) | **UTC:** {ts}"
+
+    verify_md = build_verification_links(lat, lon, seismic_mode, seismic_region, radius_km)
+    return header, df, verify_md, atm, sei, mag, sol
+
+
+INSTRUCTIONS_MD = """
+## Use and interpretation
+
+**Location input**
+- Used for Atmospheric.
+- Used for Seismic only if Seismic Mode is set to Local radius.
+- Not used for Solar or Magnetic (global signals).
+
+**Seismic Mode**
+- Region mode: counts quakes in large region (EMEA/AMER/APAC/RingOfFire/Global).
+- Local radius mode: counts quakes within a radius (km) around your typed location.
+
+**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.
+"""
+
+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 as `rule_fired`.
+"""
+
+
 with gr.Blocks(title=APP_NAME) as demo:
-    gr.Markdown(f"# {APP_NAME}\nLive multi-domain forecast — simple, clear, always live.")
+    gr.Markdown(f"# {APP_NAME}")
 
     with gr.Tab("Live Forecast"):
+        loc = gr.Textbox(label="Location", value="London, UK")
+        gr.Markdown(
+            "**Location input**\n\n"
+            "- Used for Atmospheric.\n"
+            "- Used for Seismic only in **Local radius** mode.\n"
+            "- Not used for Solar or Magnetic (global signals).\n\n"
+            "If a location cannot be resolved, predictions are disabled instead of guessed."
+        )
+
+        seismic_mode = gr.Radio(
+            choices=["Region", "Local radius"],
+            value="Local radius",
+            label="Seismic Mode"
+        )
+        gr.Markdown(
+            "**Seismic Mode**\n\n"
+            "- **Region:** counts earthquakes in a large region.\n"
+            "- **Local radius:** counts earthquakes within a radius (km) around your typed location.\n\n"
+            "This is a stress monitor, not a time/epicenter prediction system."
+        )
+
         with gr.Row():
-            loc_name = gr.Textbox(label="Location (city or region)", value="London")
-            region = gr.Dropdown(
-                ["Global","EMEA","AMER","APAC","RingOfFire"],
-                value="EMEA", label="Seismic Region"
-            )
+            region = gr.Dropdown(["Global", "EMEA", "AMER", "APAC", "RingOfFire"], value="EMEA", label="Seismic Region (used in Region mode)")
+            radius = gr.Slider(50, 2000, value=500, step=50, label="Seismic Radius km (used in Local radius mode)")
+
+        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 = gr.Button("Run Forecast", variant="primary")
         header_md = gr.Markdown()
-        table = gr.Dataframe(headers=["Domain","RFT Prediction","Live Status"], interactive=False)
+        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."
+        )
+        table = gr.Dataframe(headers=["Domain", "RFT Prediction", "Live Status"], interactive=False)
+
         verify_md = gr.Markdown()
 
-        run_btn.click(run_live_dashboard, [loc_name, region], [header_md, table, verify_md])
+        with gr.Accordion("Atmospheric details", open=False):
+            atm_json = gr.JSON(label="Atmospheric agent output")
+        with gr.Accordion("Seismic details", open=False):
+            sei_json = gr.JSON(label="Seismic agent output")
+        with gr.Accordion("Magnetic details", open=False):
+            mag_json = gr.JSON(label="Magnetic agent output")
+        with gr.Accordion("Solar details", open=False):
+            sol_json = gr.JSON(label="Solar agent output")
 
-    with gr.Tab("Scoreboard"):
-        gr.Markdown(
-            "### 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."
+        btn.click(
+            run_forecast,
+            inputs=[loc, seismic_mode, region, radius],
+            outputs=[header_md, table, verify_md, atm_json, sei_json, mag_json, sol_json],
         )
-        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)
 
-        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("Method (Open)"):
+        gr.Markdown(INSTRUCTIONS_MD)
+        gr.Markdown(METHOD_MD)
 
-    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()