Update app.py

app.py

@@ -1,8 +1,9 @@
 # app.py
 # ===============================================================
-# Rendered Frame Theory — Live Prediction Console
+# Rendered Frame Theory — Live Prediction Console (Open Method)
 # Domains: Atmospheric / Seismic / Magnetic / Solar
-# No placeholders. Single-file. Live data. RFT agents only.
+# Full transparency: exact inputs + computed z, τ_eff, Ω_obs, α_R, index, and decision rule.
+# Single-file. No placeholders. No external local modules.
 # ===============================================================
 
 import math
@@ -13,16 +14,16 @@ import httpx
 import numpy as np
 import pandas as pd
 
-APP_NAME = "Rendered Frame Theory — Live Prediction Console"
+APP_NAME = "Rendered Frame Theory — Live Prediction Console (Open Method)"
 UA = {"User-Agent": "RFTSystems/LivePredictionConsole"}
 
 # ---------------------------
-# RFT constants (from protocol style)
+# Core constants
 # ---------------------------
-T_EARTH = 365.2422 * 24 * 3600.0  # seconds
-OMEGA_OBS = 2.0 * math.pi / T_EARTH  # rad/s
-K_TAU = 1.38  # δ_r(z)=1.38*ln(1+z)
-ALPHA_R_DEFAULT = 1.02
+T_EARTH = 365.2422 * 24 * 3600.0
+OMEGA_OBS = 2.0 * math.pi / T_EARTH
+K_TAU = 1.38
+ALPHA_R = 1.02
 
 # ---------------------------
 # Regions
@@ -57,30 +58,29 @@ def stable_log_ratio(x: float, x0: float) -> float:
     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)
+
 # ---------------------------
-# Live Data Adapters (no local files)
+# Live adapters
 # ---------------------------
 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"}
-    try:
-        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
-    except Exception as e:
-        return None, None, f"Geocode error: {e}"
+    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"
@@ -105,7 +105,6 @@ def fetch_openmeteo_hourly(lat: float, lon: float, past_days: int = 1):
     }
 
 def fetch_kp_last_24h():
-    # Planetary K index 1-min stream; use last 24h worth of points (we downsample)
     url = "https://services.swpc.noaa.gov/json/planetary_k_index_1m.json"
     r = httpx.get(url, headers=UA, timeout=15)
     r.raise_for_status()
@@ -115,12 +114,13 @@ def fetch_kp_last_24h():
     vals = []
     for row in js:
         kp = row.get("kp_index")
-        if kp is not None:
-            try:
-                vals.append(float(kp))
-            except Exception:
-                pass
-    return vals[-1440:]  # ~24h of 1-min points
+        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"
@@ -161,7 +161,6 @@ def fetch_usgs_quakes(hours: int, minmag: float, bbox=None):
                 "maxlongitude": str(maxlon),
             }
         )
-
     r = httpx.get(url, params=params, headers=UA, timeout=22)
     r.raise_for_status()
     js = r.json()
@@ -171,296 +170,332 @@ def fetch_usgs_quakes(hours: int, minmag: float, bbox=None):
     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"),
-            }
-        )
+        out.append({"id": f.get("id"), "mag": props.get("mag"), "place": props.get("place"), "time": props.get("time")})
     return out
 
 # ---------------------------
-# RFT Agents (equation-driven, no heuristics outside agent)
+# Agents
 # ---------------------------
-def rft_magnetic_agent():
-    """
-    Protocol-style:
-      Ω_obs = 2π/T_Earth
-      define pseudo z_mag from Kp dynamics (render-stress proxy)
-      τ_eff = 1.38 ln(1+z_mag)
-      MagneticIndex = Ω_obs * τ_eff * α_R
-    """
-    try:
-        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  # last ~6h
-        drift = float(np.std(tail)) if len(tail) >= 10 else 0.0
-        slope = float((tail[-1] - tail[0]) / max(1, len(tail) - 1))
-
-        # pseudo z from normalized drift + level (bounded)
-        z_mag = clamp((last / 9.0) + (drift / 2.0) + abs(slope) * 2.0, 0.0, 3.0)
-        tau = tau_eff_from_z(z_mag)
-        alpha_r = ALPHA_R_DEFAULT
-        idx = OMEGA_OBS * tau * alpha_r
-
-        # decision (from index magnitude bands; still inside agent)
-        if last >= 7.0 or z_mag >= 2.0:
-            pred = "warning"
-        elif last >= 5.0 or z_mag >= 1.2:
-            pred = "watch"
-        elif last >= 4.0 or z_mag >= 0.8:
-            pred = "monitor"
-        else:
-            pred = "hold"
-
-        live = f"Global Kp={last:.1f} | drift={drift:.2f} | z_mag={z_mag:.2f} | τ_eff={tau:.3f}"
-        return {
-            "enabled": True,
-            "prediction": pred,
-            "rft_index": float(idx),
-            "live_status": live,
-            "inputs_used": {"kp_last": last, "kp_drift": drift, "kp_slope": slope},
-            "truth_source": "NOAA SWPC planetary_k_index_1m",
-        }
-    except Exception as e:
-        return {"enabled": False, "reason": f"magnetic error: {e}"}
-
-def rft_solar_agent():
-    """
-    Protocol-style:
-      estimate pseudo z_solar from GOES flux relative to baseline
-      τ_eff = 1.38 ln(1+z_solar)
-      Φ_sun = Ω_obs * τ_eff * α_R   (RFT solar flux index)
-    """
-    try:
-        flux = fetch_goes_xray_1day()
-        if len(flux) < 50:
-            return {"enabled": False, "reason": "GOES X-ray feed too short"}
-
-        # Use last 2 hours worth of points if dense, otherwise last 60 points
-        tail = flux[-120:] if len(flux) >= 120 else flux[-60:]
-        f_mean = float(np.mean(tail))
-        f_max = float(np.max(tail))
-
-        # Baseline: A-class floor ~1e-8 to 1e-7; use 1e-8 for ratio stability
-        base = 1e-8
-        lr = stable_log_ratio(f_mean, base)  # ln(f/base)
-        z_solar = clamp(lr / 10.0, 0.0, 3.0)  # bounded mapping to pseudo redshift
-        tau = tau_eff_from_z(z_solar)
-        alpha_r = ALPHA_R_DEFAULT
-        idx = OMEGA_OBS * tau * alpha_r
-
-        # decision bands by GOES class proxy but derived from index/z inside agent
-        if f_max >= 1e-4 or z_solar >= 2.2:
-            pred = "flare likely"
-        elif f_max >= 1e-5 or z_solar >= 1.5:
-            pred = "flare watch"
-        elif f_mean >= 1e-6 or z_solar >= 0.9:
-            pred = "monitor"
-        else:
-            pred = "hold"
-
-        # class label for live status
-        if f_mean >= 1e-4:
-            cls = "X"
-        elif f_mean >= 1e-5:
-            cls = "M"
-        elif f_mean >= 1e-6:
-            cls = "C"
-        elif f_mean >= 1e-7:
-            cls = "B"
-        else:
-            cls = "A"
-
-        live = f"Global GOES mean={f_mean:.2e} ({cls}) | peak={f_max:.2e} | z_solar={z_solar:.2f} | τ_eff={tau:.3f}"
-        return {
-            "enabled": True,
-            "prediction": pred,
-            "rft_index": float(idx),
-            "live_status": live,
-            "inputs_used": {"flux_mean": f_mean, "flux_peak": f_max},
-            "truth_source": "NOAA SWPC GOES primary xrays-1-day",
-        }
-    except Exception as e:
-        return {"enabled": False, "reason": f"solar error: {e}"}
-
-def rft_atmospheric_agent(lat: float, lon: float, display: str):
-    """
-    Location-based:
-      use last 12h ΔT + ΔP as render-stress proxy
-      z_atm from normalized ΔT and |ΔP|
-      τ_eff = 1.38 ln(1+z_atm)
-      Θ_atm = Ω_obs * τ_eff * α_R
-    """
-    try:
-        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 temp too short"}
-
-        t12 = [float(x) for x in temp[-13:]]  # ~12h window
-        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))
-
-        # pseudo z from temp swing + pressure drop magnitude
-        z_from_dt = clamp(dT / 10.0, 0.0, 2.0)     # 10°C swing -> z~1
-        z_from_dp = clamp((abs(dp) / 12.0) if dp is not None else 0.0, 0.0, 1.5)
-        z_atm = clamp(z_from_dt + z_from_dp, 0.0, 3.0)
-
-        tau = tau_eff_from_z(z_atm)
-        idx = OMEGA_OBS * tau * ALPHA_R_DEFAULT
-
-        # decision (inside agent)
-        if dT >= 10 or (dp is not None and dp <= -10):
-            pred = "storm risk"
-        elif dT >= 7 or (dp is not None and dp <= -6):
-            pred = "swing"
-        elif dT >= 4:
-            pred = "mild swing"
-        else:
-            pred = "stable"
-
-        live_parts = [f"{display} ΔT(12h)={dT:.1f}°C", f"z_atm={z_atm:.2f}", f"τ_eff={tau:.3f}"]
-        if dp is not None:
-            live_parts.insert(1, f"ΔP(12h)={dp:.1f} hPa")
-        if w_mean is not None:
-            live_parts.append(f"wind≈{w_mean:.1f} m/s")
-        live = " | ".join(live_parts)
+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)},
+        "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.",
+    }
 
-        return {
-            "enabled": True,
-            "prediction": pred,
-            "rft_index": float(idx),
-            "live_status": live,
-            "inputs_used": {"dT_12h": dT, "dP_12h": dp, "wind_mean": w_mean},
-            "truth_source": "Open-Meteo hourly (temp/rh/pressure/wind)",
-        }
-    except Exception as e:
-        return {"enabled": False, "reason": f"atmos error: {e}"}
-
-def rft_seismic_agent(region: str):
-    """
-    Region-based:
-      use USGS counts/max magnitude as the live measurable driver
-      build Ψ_quake proxy index:
-        Ψ = Ω_obs * τ_eff(z_seis) * α_R
-      where z_seis grows with event density + max magnitude
-    """
-    try:
-        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)
-
-        count = len(eqs)
-        mags = []
-        for e in eqs:
-            m = e.get("mag")
-            if m is not None:
-                try:
-                    mags.append(float(m))
-                except Exception:
-                    pass
-        max_mag = float(max(mags)) if mags else 0.0
-
-        # z_seis from density + magnitude (bounded)
-        z_from_count = clamp(count / 60.0, 0.0, 1.5)   # 60 events -> z~1
-        z_from_mag = clamp(max(0.0, max_mag - 4.0) / 2.5, 0.0, 1.5)  # M6.5 -> +1
-        z_seis = clamp(z_from_count + z_from_mag, 0.0, 3.0)
-
-        tau = tau_eff_from_z(z_seis)
-        idx = OMEGA_OBS * tau * ALPHA_R_DEFAULT
-
-        # decision (inside agent)
-        if max_mag >= 6.5 or z_seis >= 2.2:
-            pred = "alert"
-        elif max_mag >= 5.5 or z_seis >= 1.5:
-            pred = "watch"
-        elif count >= 25 or z_seis >= 1.0:
-            pred = "monitor"
-        else:
-            pred = "quiet"
-
-        scope = "Global" if region == "Global" else region
-        live = f"{scope} quakes(24h,M≥2.5)={count} | max M{max_mag:.1f} | z_seis={z_seis:.2f} | τ_eff={tau:.3f}"
-        return {
-            "enabled": True,
-            "prediction": pred,
-            "rft_index": float(idx),
-            "live_status": live,
-            "inputs_used": {"count": count, "max_mag": max_mag},
-            "truth_source": "USGS FDSN event geojson",
-        }
-    except Exception as e:
-        return {"enabled": False, "reason": f"seismic error: {e}"}
+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)},
+        "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},
+        "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
+        try:
+            mags.append(float(m))
+        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},
+        "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.",
+    }
 
 # ---------------------------
 # Orchestrator
 # ---------------------------
 def run_forecast(location_text: str, seismic_region: str):
-    lat, lon, display = geocode_location(location_text)
+    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}])
-        return f"❌ {display}", df
+        empty = {"enabled": False, "reason": display}
+        return f"❌ {display}", df, empty, empty, empty, empty
 
-    mag = rft_magnetic_agent()
-    sol = rft_solar_agent()
-    atm = rft_atmospheric_agent(lat, lon, display)
-    sei = rft_seismic_agent(seismic_region)
+    try:
+        atm = atmospheric_agent(lat, lon, display)
+    except Exception as e:
+        atm = {"enabled": False, "reason": f"atmos error: {e}"}
 
-    def row(domain: str, out: dict):
+    try:
+        sei = seismic_agent(seismic_region)
+    except Exception as e:
+        sei = {"enabled": False, "reason": f"seismic error: {e}"}
+
+    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("rft_index")
-        idx_s = f"{idx:.3e}" if isinstance(idx, (int, float)) else "n/a"
+            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}",
+            "RFT Prediction": f"{out.get('prediction','hold')} | idx={idx_s} | z={z_s} | τ={t_s}",
             "Live Status": out.get("live_status", ""),
         }
 
     df = pd.DataFrame(
         [
-            row("Atmospheric", atm),
-            row("Seismic", sei),
-            row("Magnetic", mag),
-            row("Solar", sol),
+            fmt_row("Atmospheric", atm),
+            fmt_row("Seismic", sei),
+            fmt_row("Magnetic", mag),
+            fmt_row("Solar", sol),
         ]
     )
 
     ts = utc_now_iso()
     header = f"**Location:** {display} (lat {lat:.3f}, lon {lon:.3f}) | **UTC:** {ts}"
-    return header, df
+    return header, df, atm, sei, mag, sol
+
+# ---------------------------
+# Open Method
+# ---------------------------
+METHOD_MD = f"""
+## Open method
+
+**Shared core:**
+- `τ_eff = {K_TAU} · ln(1 + z)`
+- `Ω_obs = 2π / T_earth = {OMEGA_OBS:.6e}`
+- `α_R = {ALPHA_R}`
+- `Index = Ω_obs · τ_eff · α_R`
+
+### Atmospheric (Open-Meteo, location)
+- Inputs: hourly temp, pressure, wind (last ~12h).
+- `ΔT = max(T) - min(T)`
+- `ΔP = P_end - P_start` (if available)
+- `z_atm = clamp( clamp(ΔT/10,0..2) + clamp(|ΔP|/12,0..1.5), 0..3 )`
+- Label rule in agent output.
+
+### Seismic (USGS, region)
+- Inputs: USGS events in last 24h (M≥2.5), filtered by region.
+- Count `N`, max magnitude `Mmax`
+- `z_seis = clamp( clamp(N/60,0..1.5) + clamp(max(0,Mmax-4)/2.5,0..1.5), 0..3 )`
+- Label rule in agent output.
+
+### Magnetic (NOAA Kp, global)
+- Inputs: planetary Kp 1-min stream.
+- `z_mag = clamp( (Kp_last/9) + (drift/2) + 2·|slope|, 0..3 )`
+- Label rule in agent output.
+
+### Solar (GOES X-ray, global)
+- Inputs: GOES 1–8Å flux (1-day stream).
+- `z_solar = clamp( ln(F_mean/1e-8) / 10, 0..3 )`
+- Label rule in agent output.
+
+Missing/short feeds show **DISABLED**.
+"""
 
 # ---------------------------
 # UI
@@ -468,19 +503,28 @@ def run_forecast(location_text: str, seismic_region: str):
 with gr.Blocks(title=APP_NAME) as demo:
     gr.Markdown(f"# {APP_NAME}")
 
-    with gr.Row():
-        loc = gr.Textbox(label="Location", value="London")
-        region = gr.Dropdown(
-            ["Global", "EMEA", "AMER", "APAC", "RingOfFire"],
-            value="EMEA",
-            label="Seismic Region",
-        )
+    with gr.Tab("Live Forecast"):
+        with gr.Row():
+            loc = gr.Textbox(label="Location", value="London")
+            region = gr.Dropdown(["Global", "EMEA", "AMER", "APAC", "RingOfFire"], value="EMEA", label="Seismic Region")
+
+        btn = gr.Button("Run Forecast", variant="primary")
+        header_md = gr.Markdown()
+        table = gr.Dataframe(headers=["Domain", "RFT Prediction", "Live Status"], interactive=False)
+
+        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")
 
-    btn = gr.Button("Run Forecast", variant="primary")
-    header_md = gr.Markdown()
-    table = gr.Dataframe(headers=["Domain", "RFT Prediction", "Live Status"], interactive=False)
+        btn.click(run_forecast, inputs=[loc, region], outputs=[header_md, table, atm_json, sei_json, mag_json, sol_json])
 
-    btn.click(run_forecast, inputs=[loc, region], outputs=[header_md, table])
+    with gr.Tab("Method (Open)"):
+        gr.Markdown(METHOD_MD)
 
 if __name__ == "__main__":
     demo.launch()