Update app.py

app.py

@@ -1,5 +1,4 @@
 import os
-import time
 import math
 import json
 import numpy as np
@@ -40,16 +39,18 @@ def df_to_csv_file(df: pd.DataFrame, name: str):
 # -----------------------------
 # RFT Core: τ_eff + gating
 # -----------------------------
-def tau_eff_adaptive(uncertainty: float,
-                     base: float = 1.0,
-                     slow_by: float = 1.0,
-                     gain: float = 1.2,
-                     cap: float = 4.0):
+def tau_eff_adaptive(
+    uncertainty: float,
+    base: float = 1.0,
+    slow_by: float = 1.0,
+    gain: float = 1.2,
+    cap: float = 4.0
+):
     """
-    τ_eff here is implemented as a timing/decision delay modifier.
+    τ_eff is implemented here as a timing/decision delay modifier.
     - base: baseline τ_eff
-    - slow_by: explicit "slow by 1.0" style term (user requested this behaviour)
-    - gain: how strongly τ_eff reacts to uncertainty
+    - slow_by: explicit slow-down term (I wanted this behaviour: slow by 1.0)
+    - gain: reaction strength to uncertainty
     - cap: prevents absurd values
     """
     u = clamp(float(uncertainty), 0.0, 1.0)
@@ -57,35 +58,34 @@ def tau_eff_adaptive(uncertainty: float,
     return clamp(tau, base, cap)
 
 def rft_confidence(uncertainty: float):
-    # Confidence is the complement of uncertainty, clipped.
     return clamp(1.0 - float(uncertainty), 0.0, 1.0)
 
 def rft_gate(conf: float, tau_eff: float, threshold: float):
     """
     Collapse gate:
-    - higher τ_eff makes gate stricter (forces more decisive conditions)
+    - higher τ_eff makes the gate stricter
     - threshold is the minimum confidence needed
     """
     conf = float(conf)
     tau_eff = float(tau_eff)
-    # stricter with larger tau: raise the effective threshold
     effective = threshold + 0.08 * (tau_eff - 1.0)
     return conf >= clamp(effective, 0.0, 0.999)
 
 # -----------------------------
 # NEO Simulation
 # -----------------------------
-def simulate_neo(seed: int,
-                 steps: int,
-                 dt: float,
-                 alert_km: float,
-                 noise_km: float,
-                 rft_conf_threshold: float,
-                 tau_gain: float,
-                 show_debug: bool):
+def simulate_neo(
+    seed: int,
+    steps: int,
+    dt: float,
+    alert_km: float,
+    noise_km: float,
+    rft_conf_threshold: float,
+    tau_gain: float,
+    show_debug: bool
+):
     set_seed(seed)
 
-    # Start far-ish but inside a range that can produce alerts
     pos = np.array([9000.0, 2500.0, 1000.0], dtype=float)  # km
     vel = np.array([-55.0, -8.0, -3.0], dtype=float)       # km/step (scaled)
 
@@ -96,29 +96,22 @@ def simulate_neo(seed: int,
     ops_proxy = 0
 
     for t in range(int(steps)):
-        # Truth propagation (simple linear + drift)
         drift = 0.05 * np.array([math.sin(0.03*t), math.cos(0.02*t), math.sin(0.015*t)])
         pos_true = pos + vel * dt + drift
 
-        # Measurement noise
         meas = pos_true + np.random.normal(0.0, noise_km, size=3)
-
-        # Distance to origin (proxy for Earth)
         dist = float(np.linalg.norm(meas))
 
-        # Uncertainty proxy: higher noise and higher speed increase uncertainty
         speed = float(np.linalg.norm(vel))
         uncertainty = clamp((noise_km / max(alert_km, 1.0)) * 2.0 + (speed / 200.0) * 0.2, 0.0, 1.0)
 
-        # Baseline alert: if within radius
         baseline_alert = dist <= alert_km
         if baseline_alert:
             alerts_baseline += 1
 
-        # RFT: τ_eff + confidence + gate (collapse earlier / smarter)
         tau = tau_eff_adaptive(uncertainty=uncertainty, base=1.0, slow_by=1.0, gain=tau_gain, cap=4.0)
         conf = rft_confidence(uncertainty)
-        # "RFT alert candidate" uses same geometric condition but *requires* collapse gate
+
         rft_candidate = dist <= alert_km
         rft_alert = bool(rft_candidate and rft_gate(conf, tau, rft_conf_threshold))
 
@@ -127,7 +120,7 @@ def simulate_neo(seed: int,
         if rft_alert:
             alerts_rft_filtered += 1
 
-        ops_proxy += 12  # a stable "compute proxy" per step
+        ops_proxy += 12
 
         rows.append({
             "t": t,
@@ -149,7 +142,6 @@ def simulate_neo(seed: int,
 
     df = pd.DataFrame(rows)
 
-    # Plots
     fig1 = plt.figure(figsize=(10, 4))
     ax = fig1.add_subplot(111)
     ax.plot(df["t"], df["dist_km"])
@@ -194,30 +186,27 @@ def simulate_neo(seed: int,
 
     debug_lines = ""
     if show_debug:
-        debug_lines = (
-            "Debug view (first 12 rows):\n"
-            + df.head(12).to_string(index=False)
-        )
+        debug_lines = "Debug view (first 12 rows):\n" + df.head(12).to_string(index=False)
 
     return summary, debug_lines, [p_dist, p_conf, p_alerts], csv_path
 
 # -----------------------------
 # Satellite Jitter Simulation
 # -----------------------------
-def simulate_jitter(seed: int,
-                    steps: int,
-                    dt: float,
-                    noise: float,
-                    baseline_kp: float,
-                    rft_kp: float,
-                    gate_threshold: float,
-                    tau_gain: float):
+def simulate_jitter(
+    seed: int,
+    steps: int,
+    dt: float,
+    noise: float,
+    baseline_kp: float,
+    rft_kp: float,
+    gate_threshold: float,
+    tau_gain: float
+):
     set_seed(seed)
 
     jitter = 0.0
     jitter_rate = 0.0
-    act_baseline = 0.0
-    act_rft = 0.0
 
     rows = []
     duty_baseline = 0
@@ -225,17 +214,14 @@ def simulate_jitter(seed: int,
     ops_proxy = 0
 
     for t in range(int(steps)):
-        # Jitter dynamics (random walk + periodic micro-vibe)
         micro = 0.25 * math.sin(0.05 * t) + 0.12 * math.sin(0.13 * t)
         jitter_rate += np.random.normal(0.0, noise) * 0.08
         jitter += jitter_rate * dt + micro + np.random.normal(0.0, noise)
 
-        # Baseline: continuous correction
         u_base = -baseline_kp * jitter
         jitter_base_next = jitter + u_base * 0.35
         duty_baseline += int(abs(u_base) > 0.01)
 
-        # RFT: correct only when it’s worth collapsing an action
         uncertainty = clamp(noise * 3.0, 0.0, 1.0)
         tau = tau_eff_adaptive(uncertainty, base=1.0, slow_by=1.0, gain=tau_gain, cap=4.0)
         conf = rft_confidence(uncertainty)
@@ -245,18 +231,15 @@ def simulate_jitter(seed: int,
         jitter_rft_next = jitter + u_rft * 0.35
         duty_rft += int(abs(u_rft) > 0.01)
 
-        act_baseline = u_base
-        act_rft = u_rft
-
         ops_proxy += 10
 
         rows.append({
             "t": t,
             "jitter": jitter,
-            "u_baseline": act_baseline,
-            "u_rft": act_rft,
-            "baseline_active": int(abs(act_baseline) > 0.01),
-            "rft_active": int(abs(act_rft) > 0.01),
+            "u_baseline": u_base,
+            "u_rft": u_rft,
+            "baseline_active": int(abs(u_base) > 0.01),
+            "rft_active": int(abs(u_rft) > 0.01),
             "tau_eff": tau,
             "confidence": conf,
             "noise": noise,
@@ -264,13 +247,15 @@ def simulate_jitter(seed: int,
             "jitter_rft_next": jitter_rft_next,
         })
 
-        # Update jitter state (common plant)
-        jitter = jitter_rft_next  # choose RFT plant evolution to reflect "running RFT"
+        # Run the plant under RFT to reflect "using the RFT agent"
+        jitter = jitter_rft_next
         jitter_rate *= 0.92
 
     df = pd.DataFrame(rows)
 
-    rms = lambda x: float(np.sqrt(np.mean(np.square(x))))
+    def rms(x):
+        return float(np.sqrt(np.mean(np.square(np.asarray(x)))))
+
     jitter_rms = rms(df["jitter"].values)
     duty_b = duty_baseline / max(steps, 1)
     duty_r = duty_rft / max(steps, 1)
@@ -317,87 +302,123 @@ def simulate_jitter(seed: int,
 
 # -----------------------------
 # Starship-style Landing Harness (2D)
+# FIXES:
+# - wind is SIGNED (gusts left/right), not always positive drift
+# - control authority increased so the goal is actually reachable
+# - gate cannot veto "must-correct" moments (override when error is big / low altitude)
+# - includes simple wind feed-forward cancellation term
 # -----------------------------
-def simulate_landing(seed: int,
-                     steps: int,
-                     dt: float,
-                     wind_max: float,
-                     thrust_noise: float,
-                     kp_baseline: float,
-                     kp_rft: float,
-                     gate_threshold: float,
-                     tau_gain: float,
-                     goal_m: float):
+def simulate_landing(
+    seed: int,
+    steps: int,
+    dt: float,
+    wind_max: float,
+    thrust_noise: float,
+    kp_baseline: float,
+    kp_rft: float,
+    gate_threshold: float,
+    tau_gain: float,
+    goal_m: float
+):
     set_seed(seed)
 
-    # state: altitude, vertical velocity, lateral x offset, lateral velocity
+    # State
     alt = 1000.0
     vv = -45.0
     x = 60.0
     xv = 0.0
 
+    # A tiny integral term helps remove persistent bias
+    ix = 0.0
+
     anomalies = 0
     actions = 0
     ops_proxy = 0
-
     rows = []
 
+    # Tuned plant constants (simple, but consistent)
+    g = -9.81
+
+    # Control authority (this is what makes 10m achievable)
+    LAT_CTRL = 0.95      # lateral accel per control unit
+    WIND_PUSH = 0.28     # lateral accel per m/s wind
+    VERT_CTRL = 0.22     # vertical accel per control unit
+
+    # Override thresholds (safety style)
+    OVERRIDE_X = 18.0
+    OVERRIDE_ALT = 260.0
+
     for t in range(int(steps)):
-        # wind profile
-        wind = wind_max * (0.55 + 0.45 * math.sin(0.08 * t)) + np.random.normal(0, 0.4)
-        wind = clamp(wind, 0.0, wind_max)
+        # Signed wind with gusty behaviour (not always pushing one way)
+        gust = math.sin(0.08 * t) + 0.55 * math.sin(0.21 * t + 0.7)
+        wind = (wind_max * 0.75) * gust + np.random.normal(0.0, 0.65)
+        wind = clamp(wind, -wind_max, wind_max)
 
-        # thrust disturbance
+        # Thrust disturbance
         thrust_dev = np.random.normal(0.0, thrust_noise)
 
-        # measurement noise (simple)
+        # Measurement noise
         meas_alt = alt + np.random.normal(0, 0.6)
         meas_vv = vv + np.random.normal(0, 0.35)
         meas_x = x + np.random.normal(0, 0.8)
         meas_xv = xv + np.random.normal(0, 0.25)
 
-        # uncertainty proxy
-        uncertainty = clamp((abs(thrust_dev) / 5.0) * 0.15 + (wind / max(wind_max, 1e-9)) * 0.25, 0.0, 1.0)
+        # Uncertainty proxy
+        uncertainty = clamp((abs(thrust_dev) / 5.0) * 0.18 + (abs(wind) / max(wind_max, 1e-9)) * 0.30, 0.0, 1.0)
         tau = tau_eff_adaptive(uncertainty, base=1.0, slow_by=1.0, gain=tau_gain, cap=4.0)
         conf = rft_confidence(uncertainty)
 
-        # anomaly definition (reduced spam): only count if materially bad
+        # Anomaly definition (count only meaningful events)
         anomaly_types = []
-        if wind > (0.85 * wind_max):
+        if abs(wind) > (0.85 * wind_max):
             anomaly_types.append("High wind")
         if meas_alt < 200 and abs(meas_x) > 20:
             anomaly_types.append("High lateral error near ground")
         if meas_alt < 150 and abs(meas_vv) > 15:
             anomaly_types.append("High descent rate near ground")
-
         is_anomaly = len(anomaly_types) > 0
         if is_anomaly:
             anomalies += 1
 
-        # Baseline control: continuous proportional (computed for reference / logging)
-        u_base_x = -kp_baseline * meas_x - 0.25 * meas_xv
-        u_base_v = -kp_baseline * (meas_vv + 5.0)  # target ~ -5 m/s
-
-        # RFT control: gated “collapse” actions
-        do_action = rft_gate(conf, tau, gate_threshold)
+        # Baseline control (continuous)
+        u_base_x = -kp_baseline * meas_x - 0.30 * meas_xv
+        u_base_v = -kp_baseline * (meas_vv + 5.0)
 
-        # lookahead scaling makes RFT more decisive as altitude drops
+        # RFT control (gated + override)
         phase = 1.0 - clamp(meas_alt / 1000.0, 0.0, 1.0)  # 0 high up, 1 near ground
-        lookahead = 1.0 + 1.2 * phase
+        lookahead = 1.0 + 1.6 * phase
+
+        # Wind feed-forward: cancel expected push
+        # If wind is pushing +, we apply opposite control; vice versa.
+        wind_ff = (WIND_PUSH * wind) / max(LAT_CTRL, 1e-9)
+
+        # Integral accumulates only when closer (so it doesn't explode up high)
+        if meas_alt < 600:
+            ix = clamp(ix + (meas_x * dt) * 0.0025, -40.0, 40.0)
+
+        # Gate + override logic
+        do_action = rft_gate(conf, tau, gate_threshold)
+        must_act = (abs(meas_x) > OVERRIDE_X) or (meas_alt < OVERRIDE_ALT)
+        do_action = bool(do_action or must_act)
 
         u_rft_x = 0.0
         u_rft_v = 0.0
         if do_action:
-            u_rft_x = (-kp_rft * lookahead * meas_x) - (0.30 * meas_xv)
+            # PD + small I + wind FF
+            u_rft_x = (-kp_rft * lookahead * meas_x) - (0.42 * meas_xv) - (0.20 * ix) - wind_ff
             u_rft_v = (-kp_rft * lookahead * (meas_vv + 5.0))
             actions += 1
 
-        # apply dynamics
-        g = -9.81
-        vv = vv + (g + 0.18 * u_rft_v + 0.08 * thrust_dev) * dt
+        # Saturate control (realistic bounded actuation)
+        u_rft_x = clamp(u_rft_x, -20.0, 20.0)
+        u_rft_v = clamp(u_rft_v, -18.0, 18.0)
+
+        # Apply dynamics
+        vv = vv + (g + VERT_CTRL * u_rft_v + 0.09 * thrust_dev) * dt
         alt = max(0.0, alt + vv * dt)
 
-        xv = xv + (0.35 * wind - 0.30 * u_rft_x) * dt
+        # Lateral acceleration from wind and control
+        xv = xv + (WIND_PUSH * wind - LAT_CTRL * u_rft_x) * dt
         x = x + xv * dt
 
         ops_proxy += 16
@@ -420,13 +441,14 @@ def simulate_landing(seed: int,
             "u_baseline_v": u_base_v,
             "u_rft_x": u_rft_x,
             "u_rft_v": u_rft_v,
+            "ix": ix,
+            "wind_ff": wind_ff,
         })
 
         if alt <= 0.0:
             break
 
     df = pd.DataFrame(rows)
-
     landing_offset = float(abs(df["x_m"].iloc[-1])) if len(df) else 9999.0
 
     fig1 = plt.figure(figsize=(10, 4))
@@ -450,7 +472,7 @@ def simulate_landing(seed: int,
     fig3 = plt.figure(figsize=(10, 4))
     ax = fig3.add_subplot(111)
     ax.plot(df["t"], df["wind_m_s"])
-    ax.set_title("Landing: wind profile")
+    ax.set_title("Landing: wind profile (signed gusts)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("wind (m/s)")
     p_w = save_plot(fig3, f"landing_wind_seed{seed}.png")
@@ -482,22 +504,16 @@ def simulate_landing(seed: int,
 # -----------------------------
 # Benchmarks
 # -----------------------------
-def run_benchmarks(seed: int,
-                   neo_steps: int, neo_dt: float, neo_alert_km: float, neo_noise_km: float,
-                   jit_steps: int, jit_dt: float, jit_noise: float,
-                   land_steps: int, land_dt: float, land_wind: float, land_thrust_noise: float,
-                   tau_gain: float):
-    """
-    Benchmarks are baseline vs RFT under the SAME seed.
-    Baseline here means:
-    - NEO: geometric threshold only
-    - Jitter: continuous correction (no gating)
-    - Landing: continuous proportional (no gating)
-    RFT means τ_eff + confidence + gate.
-    """
+def run_benchmarks(
+    seed: int,
+    neo_steps: int, neo_dt: float, neo_alert_km: float, neo_noise_km: float,
+    jit_steps: int, jit_dt: float, jit_noise: float,
+    land_steps: int, land_dt: float, land_wind: float, land_thrust_noise: float,
+    tau_gain: float
+):
     seed = int(seed)
 
-    # NEO benchmark
+    # NEO
     s_rft, _, neo_imgs, neo_csv = simulate_neo(
         seed=seed,
         steps=neo_steps,
@@ -513,7 +529,7 @@ def run_benchmarks(seed: int,
     neo_rft = int(neo_df["rft_alert"].sum())
     neo_candidates = int(neo_df["rft_candidate"].sum())
 
-    # Jitter benchmark
+    # Jitter
     j_sum, jit_imgs, jit_csv = simulate_jitter(
         seed=seed,
         steps=jit_steps,
@@ -525,7 +541,7 @@ def run_benchmarks(seed: int,
         tau_gain=tau_gain
     )
 
-    # Landing benchmark
+    # Landing
     l_sum, land_imgs, land_csv = simulate_landing(
         seed=seed,
         steps=land_steps,
@@ -575,23 +591,23 @@ def run_benchmarks(seed: int,
         f"- Landing: final offset={l_sum['final_landing_offset_m']:.2f} m (goal 10 m), anomalies={l_sum['total_anomalies_detected']}, actions={l_sum['total_control_actions']}\n"
     )
 
-    all_imgs = neo_imgs + jit_imgs + land_imgs  # 3 + 3 + 4 = 10 images
+    all_imgs = neo_imgs + jit_imgs + land_imgs  # 3 + 3 + 4 = 10
     return txt, score, score_path, all_imgs, [neo_csv, jit_csv, land_csv]
 
 # -----------------------------
-# UI text blocks (full openness)
+# UI text blocks (my voice, full openness)
 # -----------------------------
 HOME_MD = """
 # Rendered Frame Theory (RFT) — Agent Console
 
 I built this Space to be transparent, reproducible, and benchmarkable.
 
-I’m not asking anyone to “believe” in anything here.  
-Run it. Change the parameters. Break it. Compare baseline vs RFT.  
+I’m not asking anyone to “believe” in anything here.
+Run it. Change the parameters. Break it. Compare baseline vs RFT.
 
 What I’m demonstrating is a practical idea:
 
-**Decision timing matters.**  
+**Decision timing matters.**
 RFT treats timing (τ_eff), uncertainty, and action “collapse” as first-class controls.
 
 This Space contains three working agent harnesses:
@@ -621,16 +637,15 @@ THEORY_PRACTICE_MD = """
 This Space uses RFT in a practical way:
 
 ## 1) Uncertainty (explicit)
-I compute an uncertainty proxy from noise + disturbance scale.  
-This is not magic. It’s just honest modelling.
+I compute an uncertainty proxy from noise + disturbance scale.
 
 ## 2) Confidence
-Confidence is the complement: **confidence = 1 − uncertainty** (clipped 0..1).
+Confidence is the complement: confidence = 1 − uncertainty (clipped 0..1).
 
 ## 3) Adaptive τ_eff
 τ_eff is implemented as a timing/decision strictness modifier:
 - higher uncertainty → higher τ_eff
-- **and yes, I explicitly slow τ_eff by 1.0**, because this was the target behaviour I wanted to test.
+- and yes, I explicitly slow τ_eff by 1.0, because this was the behaviour I wanted to test.
 
 ## 4) Collapse gate
 I only apply “decisive actions” when the gate condition passes:
@@ -639,21 +654,19 @@ I only apply “decisive actions” when the gate condition passes:
 
 ## 5) Why this matters
 Baseline controllers often act constantly.
-RFT tries to act **less often**, but **more decisively**, so you waste less energy and trigger fewer junk corrections/alerts.
+RFT tries to act less often, but more decisively, so you waste less energy and trigger fewer junk corrections/alerts.
 """
 
 MATH_MD = r"""
 # Mathematics (minimal and implementation-linked)
 
-I’m keeping this readable and tied to actual behaviour in code.
-
 ## Variables (used in this Space)
-- **u ∈ [0,1]** : uncertainty proxy (dimensionless)
-- **C ∈ [0,1]** : confidence proxy (dimensionless)
-- **τ_eff ≥ 1** : effective render/decision timing factor (dimensionless)
-- **Gate(C, τ_eff)** : action/alert collapse condition
+- u ∈ [0,1] : uncertainty proxy (dimensionless)
+- C ∈ [0,1] : confidence proxy (dimensionless)
+- τ_eff ≥ 1 : effective render/decision timing factor (dimensionless)
 
 ## Definitions
+
 ### Confidence
 \[
 C = \text{clip}(1 - u, 0, 1)
@@ -663,16 +676,14 @@ C = \text{clip}(1 - u, 0, 1)
 \[
 \tau_{\text{eff}} = \text{clip}(1 + 1.0 + g\cdot u,\; 1,\; \tau_{\max})
 \]
-where \( g \) is a gain.
 
 ### Collapse gate (concept)
-A higher τ_eff makes the decision stricter:
+Higher τ_eff makes decisions stricter:
 \[
 \text{Gate} = \left[C \ge \theta + k(\tau_{\text{eff}}-1)\right]
 \]
-where \( \theta \) is the base confidence threshold and \( k \) increases strictness with τ_eff.
 
-That’s exactly what I implement here: more uncertainty → higher τ_eff → harder gate → fewer low-confidence actions.
+That is exactly what I implement here: more uncertainty → higher τ_eff → harder gate → fewer low-confidence actions.
 """
 
 INVESTOR_MD = """
@@ -684,27 +695,22 @@ I’m demonstrating a decision-timing framework that can be applied to:
 - stabilisation (jitter reduction)
 - anomaly-aware control loops (landing harness)
 
-This is not a “pitch deck”. It’s a runnable harness:
-- you can reproduce the results with seeds
+This is a runnable harness:
+- you can reproduce results with seeds
 - you can export logs
 - you can compare baseline vs RFT
 - you can change thresholds and see behaviour shift
 
-## What I’m NOT claiming
+## What I’m not claiming
 - I’m not claiming flight certification
-- I’m not claiming SpaceX is using this
+- I’m not claiming any company is using this
 - I’m not claiming this replaces aerospace validation pipelines
 
-## What would make this production-grade
+## What would make it production-grade
 - real sensor ingestion + timing constraints
 - hardware-in-loop testing
 - systematic dataset validation
 - integration targets (embedded, REST, batch)
-
-If you want the “serious build”, I can package these modules as:
-- Python module
-- REST endpoint
-- edge builds (ARM)
 """
 
 REPRO_MD = """
@@ -724,7 +730,7 @@ CSV schema is explicit in the exports:
 """
 
 # -----------------------------
-# Gradio UI
+# Gradio UI helpers
 # -----------------------------
 def ui_run_neo(seed, steps, dt, alert_km, noise_km, rft_conf_th, tau_gain, show_debug):
     summary, debug_lines, imgs, csv_path = simulate_neo(
@@ -770,10 +776,7 @@ def ui_run_landing(seed, steps, dt, wind_max, thrust_noise, kp_base, kp_rft, gat
     summary_txt = json.dumps(summary, indent=2)
     return summary_txt, imgs[0], imgs[1], imgs[2], imgs[3], csv_path
 
-def ui_run_bench(seed, neo_steps, neo_dt, neo_alert_km, neo_noise_km,
-                 jit_steps, jit_dt, jit_noise,
-                 land_steps, land_dt, land_wind, land_thrust_noise,
-                 tau_gain):
+def ui_run_bench(seed, neo_steps, neo_dt, neo_alert_km, neo_noise_km, jit_steps, jit_dt, jit_noise, land_steps, land_dt, land_wind, land_thrust_noise, tau_gain):
     txt, score_df, score_csv, imgs, logs = run_benchmarks(
         seed=int(seed),
         neo_steps=int(neo_steps), neo_dt=float(neo_dt), neo_alert_km=float(neo_alert_km), neo_noise_km=float(neo_noise_km),
@@ -781,24 +784,16 @@ def ui_run_bench(seed, neo_steps, neo_dt, neo_alert_km, neo_noise_km,
         land_steps=int(land_steps), land_dt=float(land_dt), land_wind=float(land_wind), land_thrust_noise=float(land_thrust_noise),
         tau_gain=float(tau_gain)
     )
-
-    # IMPORTANT:
-    # The Live Console Benchmarks tab has 16 outputs:
-    #  - 1 textbox, 1 dataframe, 1 file
-    #  - 10 images
-    #  - 3 log files
-    # run_benchmarks returns 10 images (3 NEO + 3 jitter + 4 landing)
-    # so we MUST return imgs[0]..imgs[9] here.
-    while len(imgs) < 10:
-        imgs.append(None)
-
+    # IMPORTANT: 16 outputs expected. We return 10 images + 3 files + 3 objects = 16.
     return (
         txt, score_df, score_csv,
-        imgs[0], imgs[1], imgs[2], imgs[3], imgs[4],
-        imgs[5], imgs[6], imgs[7], imgs[8], imgs[9],
+        imgs[0], imgs[1], imgs[2], imgs[3], imgs[4], imgs[5], imgs[6], imgs[7], imgs[8], imgs[9],
         logs[0], logs[1], logs[2]
     )
 
+# -----------------------------
+# Gradio UI
+# -----------------------------
 with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
     gr.Markdown(HOME_MD)
 
@@ -856,14 +851,21 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
             run_b.click(
                 ui_run_bench,
                 inputs=[seed_live, neo_steps, neo_dt, neo_alert, neo_noise, jit_steps, jit_dt, jit_noise, land_steps, land_dt, land_wind, land_thrust_noise, tau_gain_live],
-                outputs=[bench_txt, bench_table, bench_score_csv,
-                         img1, img2, img3, img4, img5, img6, img7, img8, img9, img10,
-                         neo_log, jit_log, land_log]
+                outputs=[
+                    bench_txt, bench_table, bench_score_csv,
+                    img1, img2, img3, img4, img5, img6, img7, img8, img9, img10,
+                    neo_log, jit_log, land_log
+                ]
             )
 
         # ----------------------------------------------------------
         with gr.Tab("NEO Agent"):
-            gr.Markdown("# Near-Earth Object (NEO) Alerting Agent\nThis is a test harness for filtering close-approach alerts under noise.\nBaseline: distance threshold only.\nRFT: distance threshold + confidence + τ_eff collapse gate.\n")
+            gr.Markdown(
+                "# Near-Earth Object (NEO) Alerting Agent\n"
+                "This is a test harness for filtering close-approach alerts under noise.\n"
+                "Baseline: distance threshold only.\n"
+                "RFT: distance threshold + confidence + τ_eff collapse gate.\n"
+            )
             with gr.Row():
                 seed_neo = gr.Number(value=42, precision=0, label="Seed")
                 steps_neo = gr.Slider(50, 400, value=120, step=1, label="Steps")
@@ -892,7 +894,12 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
 
         # ----------------------------------------------------------
         with gr.Tab("Satellite Jitter Agent"):
-            gr.Markdown("# Satellite Jitter Reduction\nBaseline: continuous correction.\nRFT: gated correction using confidence + τ_eff.\nThis is a simple but honest test of duty-cycle reduction.\n")
+            gr.Markdown(
+                "# Satellite Jitter Reduction\n"
+                "Baseline: continuous correction.\n"
+                "RFT: gated correction using confidence + τ_eff.\n"
+                "This is a simple but honest test of duty-cycle reduction.\n"
+            )
             with gr.Row():
                 seed_j = gr.Number(value=42, precision=0, label="Seed")
                 steps_j = gr.Slider(100, 1200, value=500, step=1, label="Steps")
@@ -920,7 +927,11 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
 
         # ----------------------------------------------------------
         with gr.Tab("Starship Landing Harness"):
-            gr.Markdown("# Starship-style Landing Harness (Simplified)\nThis is not a SpaceX flight model. It’s a timing-control harness.\nBaseline vs RFT shows whether gated decision timing can reduce waste and still hit the landing goal.\n")
+            gr.Markdown(
+                "# Starship-style Landing Harness (Simplified)\n"
+                "This is not a flight model. It’s a timing-control harness.\n"
+                "Baseline vs RFT shows whether gated decision timing can reduce waste and still hit the landing goal.\n"
+            )
             with gr.Row():
                 seed_l = gr.Number(value=42, precision=0, label="Seed")
                 steps_l = gr.Slider(40, 400, value=120, step=1, label="Steps")
@@ -952,9 +963,12 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
 
         # ----------------------------------------------------------
         with gr.Tab("Benchmarks"):
-            gr.Markdown("# Benchmarks\nBaseline vs RFT runs, same seed, exported logs.\nUse Live Console to run full benchmark packs.\n")
+            gr.Markdown(
+                "# Benchmarks\n"
+                "Run full packs from the Live Console tab.\n"
+                "Everything is seeded, logged, and exportable.\n"
+            )
 
-        # ----------------------------------------------------------
         with gr.Tab("Theory → Practice"):
             gr.Markdown(THEORY_PRACTICE_MD)