Update app.py

app.py

@@ -1,14 +1,13 @@
 import os
 import math
 import json
-import random
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 import gradio as gr
 
 # ===============================================================
-# Rendered Frame Theory (RFT) — Agent Console (All-in-One Space)
+# Rendered Frame Theory (RFT) — Observer Agent Console (All-in-One Space)
 # Author: Liam Grinstead
 # Purpose: Transparent, reproducible, benchmarkable agent demos
 # Dependencies: numpy, pandas, matplotlib, gradio (NO scipy)
@@ -21,9 +20,7 @@ os.makedirs(OUTDIR, exist_ok=True)
 # Shared utilities
 # -----------------------------
 def set_seed(seed: int):
-    seed = int(seed) % (2**32 - 1)
-    np.random.seed(seed)
-    random.seed(seed)
+    np.random.seed(int(seed) % (2**32 - 1))
 
 def clamp(x, lo, hi):
     return max(lo, min(hi, x))
@@ -40,7 +37,7 @@ def df_to_csv_file(df: pd.DataFrame, name: str):
     return path
 
 # -----------------------------
-# RFT Core: τ_eff + gating
+# RFT Core: τ_eff + gating (Observer-style decision timing)
 # -----------------------------
 def tau_eff_adaptive(
     uncertainty: float,
@@ -52,7 +49,7 @@ def tau_eff_adaptive(
     """
     τ_eff is implemented here as a timing/decision delay modifier.
     - base: baseline τ_eff
-    - slow_by: explicit slow-down term
+    - slow_by: explicit slow-down term (I wanted this behaviour: slow by 1.0)
     - gain: reaction strength to uncertainty
     - cap: prevents absurd values
     """
@@ -65,7 +62,7 @@ def rft_confidence(uncertainty: float):
 
 def rft_gate(conf: float, tau_eff: float, threshold: float):
     """
-    Collapse gate:
+    Decision gate (observer-style “commit” trigger):
     - higher τ_eff makes the gate stricter
     - threshold is the minimum confidence needed
     """
@@ -167,7 +164,7 @@ def simulate_neo(
     ax = fig3.add_subplot(111)
     ax.step(df["t"], df["baseline_alert"], where="post")
     ax.step(df["t"], df["rft_alert"], where="post")
-    ax.set_title("NEO: Alerts (Baseline vs RFT)")
+    ax.set_title("NEO: Alerts (Baseline vs Observer-gated RFT)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("alert (0/1)")
     p_alerts = save_plot(fig3, f"neo_alerts_seed{seed}.png")
@@ -265,7 +262,7 @@ def simulate_jitter(
     fig1 = plt.figure(figsize=(10, 4))
     ax = fig1.add_subplot(111)
     ax.plot(df["t"], df["jitter"])
-    ax.set_title("Jitter: residual vs time (running RFT plant)")
+    ax.set_title("Jitter: residual vs time (running observer-gated plant)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("jitter (arb)")
     p_jit = save_plot(fig1, f"jitter_residual_seed{seed}.png")
@@ -274,7 +271,7 @@ def simulate_jitter(
     ax = fig2.add_subplot(111)
     ax.step(df["t"], df["baseline_active"], where="post")
     ax.step(df["t"], df["rft_active"], where="post")
-    ax.set_title("Jitter: Actuation duty (Baseline vs RFT gating)")
+    ax.set_title("Jitter: Actuation duty (Baseline vs Observer-gated RFT)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("active (0/1)")
     p_duty = save_plot(fig2, f"jitter_duty_seed{seed}.png")
@@ -323,7 +320,6 @@ def simulate_landing(
     vv = -45.0
     x = 60.0
     xv = 0.0
-
     ix = 0.0
 
     anomalies = 0
@@ -332,11 +328,13 @@ def simulate_landing(
     rows = []
 
     g = -9.81
-
     LAT_CTRL = 0.95
     WIND_PUSH = 0.28
     VERT_CTRL = 0.22
 
+    OVERRIDE_X = 18.0
+    OVERRIDE_ALT = 260.0
+
     for t in range(int(steps)):
         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)
@@ -360,6 +358,7 @@ def simulate_landing(
             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
@@ -375,7 +374,9 @@ def simulate_landing(
         if meas_alt < 600:
             ix = clamp(ix + (meas_x * dt) * 0.0025, -40.0, 40.0)
 
-        do_action = bool(rft_gate(conf, tau, gate_threshold))
+        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
@@ -473,375 +474,6 @@ def simulate_landing(
 
     return summary, [p_alt, p_x, p_w, p_a], csv_path
 
-# ===============================================================
-# Predator Avoidance (Reflex vs QuantumConscious "RFT-style")
-# ===============================================================
-def numpy_convolve2d_toroidal(array: np.ndarray, kernel: np.ndarray) -> np.ndarray:
-    out = np.zeros_like(array, dtype=float)
-    kcx = kernel.shape[0] // 2
-    kcy = kernel.shape[1] // 2
-    rows, cols = array.shape
-    for i in range(rows):
-        for j in range(cols):
-            val = 0.0
-            for m in range(kernel.shape[0]):
-                for n in range(kernel.shape[1]):
-                    x = (i + m - kcx) % rows
-                    y = (j + n - kcy) % cols
-                    val += array[x, y] * kernel[m, n]
-            out[i, j] = val
-    return out
-
-class Predator:
-    def __init__(self, grid_size: int):
-        self.grid_size = grid_size
-        self.x = random.randint(0, grid_size - 1)
-        self.y = random.randint(0, grid_size - 1)
-
-    def move(self):
-        dx, dy = random.choice([(0,1), (0,-1), (1,0), (-1,0)])
-        self.x = (self.x + dx) % self.grid_size
-        self.y = (self.y + dy) % self.grid_size
-
-class ReflexAgent:
-    def __init__(self, grid_size: int):
-        self.grid_size = grid_size
-        self.x = random.randint(0, grid_size - 1)
-        self.y = random.randint(0, grid_size - 1)
-        self.collisions = 0
-
-    def move(self):
-        dx, dy = random.choice([(0,1), (0,-1), (1,0), (-1,0)])
-        self.x = (self.x + dx) % self.grid_size
-        self.y = (self.y + dy) % self.grid_size
-
-class QuantumConsciousAgent:
-    def __init__(
-        self,
-        grid_size: int,
-        move_kernel: np.ndarray,
-        energy_max: float,
-        energy_regen: float,
-        base_override_cost: float,
-        quantum_boost_prob: float,
-        quantum_boost_amount: float,
-        sense_noise_prob: float,
-        alpha: float,
-        beta: float,
-        dt_internal: float,
-        override_threshold: float
-    ):
-        self.grid_size = grid_size
-        self.move_kernel = move_kernel.astype(float)
-
-        self.pos_prob = np.zeros((grid_size, grid_size), dtype=float)
-        x, y = np.random.randint(grid_size), np.random.randint(grid_size)
-        self.pos_prob[x, y] = 1.0
-        self.x, self.y = int(x), int(y)
-
-        self.energy_max = float(energy_max)
-        self.energy = float(energy_max)
-        self.energy_regen = float(energy_regen)
-        self.base_override_cost = float(base_override_cost)
-        self.quantum_boost_prob = float(quantum_boost_prob)
-        self.quantum_boost_amount = float(quantum_boost_amount)
-        self.sense_noise_prob = float(sense_noise_prob)
-
-        self.alpha = float(alpha)
-        self.beta = float(beta)
-        self.dt_internal = float(dt_internal)
-        self.override_threshold = float(override_threshold)
-
-        # Start low so P_override is not pinned at the threshold.
-        self.psi_override = (0.08 + 0j)  # |psi|^2 = 0.0064
-        self.overrides = 0
-        self.collisions = 0
-
-    def move(self):
-        dx, dy = random.choice([(0,1), (0,-1), (1,0), (-1,0)])
-        self.x = (self.x + dx) % self.grid_size
-        self.y = (self.y + dy) % self.grid_size
-
-        # Keep pos_prob consistent with actual state (otherwise threat stays meaningless)
-        self.pos_prob.fill(0.0)
-        self.pos_prob[self.x, self.y] = 1.0
-
-    def sense_predators(self, predators):
-        perceived = []
-        for p in predators:
-            if random.random() < self.sense_noise_prob:
-                continue
-            perceived.append((p.x, p.y))
-        return perceived
-
-    def compute_threat(self, perceived):
-        threat = 0.0
-        radius = 2
-        for (px, py) in perceived:
-            xs = [(px + dx) % self.grid_size for dx in range(-radius, radius + 1)]
-            ys = [(py + dy) % self.grid_size for dy in range(-radius, radius + 1)]
-            sub = self.pos_prob[np.ix_(xs, ys)]
-            threat += float(sub.sum())
-        return threat
-
-    def update_override_state(self, perceived):
-        """
-        Make P_override responsive (amplitude changes), not phase-only.
-        Threat pushes amplitude up; energy pushes it down.
-        """
-        T = self.compute_threat(perceived)
-        E = self.energy / max(self.energy_max, 1e-9)
-
-        drive = (self.alpha * T) - (self.beta * E)
-
-        # amplitude pump/decay (bounded)
-        exp_term = clamp(drive, -6.0, 6.0) * 0.22 * self.dt_internal
-        amp = math.exp(exp_term)
-        amp = clamp(amp, 0.75, 1.35)
-
-        # keep a "quantum-style" phase evolution too
-        H = drive + 0.01 * (abs(self.psi_override) ** 2)
-        self.psi_override *= amp * np.exp(-1j * H * self.dt_internal)
-
-        # cap magnitude so probability stays within [0,1]
-        mag = abs(self.psi_override)
-        if mag > 1.0:
-            self.psi_override /= mag
-
-    def get_override_probability(self):
-        return float(min(abs(self.psi_override) ** 2, 1.0))
-
-    def apply_override(self, perceived):
-        field = numpy_convolve2d_toroidal(self.pos_prob, self.move_kernel)
-        field = np.maximum(field, 0.0)
-
-        for (px, py) in perceived:
-            for dx in range(-2, 3):
-                for dy in range(-2, 3):
-                    nx = (px + dx) % self.grid_size
-                    ny = (py + dy) % self.grid_size
-                    dist = abs(dx) + abs(dy)
-                    field[nx, ny] *= (1.0 - 0.30 / (dist + 1.0))
-
-        s = float(field.sum())
-        if s <= 0:
-            field[:] = 1.0 / (self.grid_size * self.grid_size)
-        else:
-            field /= s
-
-        self.pos_prob = field
-
-        flat = self.pos_prob.flatten().copy()
-        for (px, py) in perceived:
-            flat[px * self.grid_size + py] = 0.0
-
-        tot = float(flat.sum())
-        if tot <= 0:
-            self.move()
-            return
-
-        flat /= tot
-        idx = np.random.choice(self.grid_size * self.grid_size, p=flat)
-        self.x, self.y = divmod(int(idx), self.grid_size)
-
-    def quantum_energy_boost(self):
-        if random.random() < self.quantum_boost_prob:
-            return float(self.quantum_boost_amount)
-        return 0.0
-
-    def regen_energy(self):
-        boost = self.quantum_energy_boost()
-        self.energy = clamp(self.energy + self.energy_regen + boost, 0.0, self.energy_max)
-        if self.energy < self.energy_max and random.random() < 0.05:
-            self.energy = self.energy_max
-
-    def move_consciously(self, predators, group_coherence: float):
-        if self.energy <= 0:
-            self.move()
-            return 0, 0.0, 0.0
-
-        perceived = self.sense_predators(predators)
-        self.update_override_state(perceived)
-
-        P_ov = self.get_override_probability()
-        threat = self.compute_threat(perceived)
-
-        acted = 0
-        if (P_ov >= self.override_threshold) and (self.energy > 0):
-            effective_cost = self.base_override_cost * (1.0 - float(group_coherence))
-            if self.energy >= effective_cost:
-                self.overrides += 1
-                self.energy -= effective_cost
-                self.apply_override(perceived)
-                self.psi_override = (0.08 + 0j)  # reset after a collapse action
-                acted = 1
-            else:
-                self.move()
-        else:
-            self.move()
-
-        return acted, P_ov, threat
-
-def simulate_predator(
-    seed: int,
-    grid_size: int,
-    steps: int,
-    num_reflex: int,
-    num_conscious: int,
-    num_predators: int,
-    group_coherence: float,
-    sense_noise_prob: float,
-    override_threshold: float,
-    alpha: float,
-    beta: float,
-    dt_internal: float,
-    energy_max: float,
-    base_override_cost: float,
-    energy_regen: float,
-    quantum_boost_prob: float,
-    quantum_boost_amount: float,
-    show_heatmap: bool
-):
-    set_seed(seed)
-
-    move_kernel = np.array([[0, 0.2, 0],
-                            [0.2, 0.2, 0.2],
-                            [0, 0.2, 0]], dtype=float)
-
-    reflex_agents = [ReflexAgent(grid_size) for _ in range(int(num_reflex))]
-    conscious_agents = [
-        QuantumConsciousAgent(
-            grid_size=grid_size,
-            move_kernel=move_kernel,
-            energy_max=energy_max,
-            energy_regen=energy_regen,
-            base_override_cost=base_override_cost,
-            quantum_boost_prob=quantum_boost_prob,
-            quantum_boost_amount=quantum_boost_amount,
-            sense_noise_prob=sense_noise_prob,
-            alpha=alpha,
-            beta=beta,
-            dt_internal=dt_internal,
-            override_threshold=override_threshold
-        )
-        for _ in range(int(num_conscious))
-    ]
-    predators = [Predator(grid_size) for _ in range(int(num_predators))]
-
-    rows = []
-    ops_proxy = 0
-
-    for t in range(int(steps)):
-        for p in predators:
-            p.move()
-
-        for a in reflex_agents:
-            a.move()
-            for p in predators:
-                if a.x == p.x and a.y == p.y:
-                    a.collisions += 1
-
-        actions = []
-        povs = []
-        threats = []
-        for a in conscious_agents:
-            acted, P_ov, threat = a.move_consciously(predators, group_coherence)
-            a.regen_energy()
-            actions.append(acted)
-            povs.append(P_ov)
-            threats.append(threat)
-            for p in predators:
-                if a.x == p.x and a.y == p.y:
-                    a.collisions += 1
-
-        ops_proxy += 18
-
-        reflex_collisions = int(sum(a.collisions for a in reflex_agents))
-        conscious_collisions = int(sum(a.collisions for a in conscious_agents))
-        avg_overrides = float(np.mean([a.overrides for a in conscious_agents])) if conscious_agents else 0.0
-        avg_energy = float(np.mean([a.energy for a in conscious_agents])) if conscious_agents else 0.0
-        avg_threat = float(np.mean(threats)) if threats else 0.0
-        avg_pov = float(np.mean(povs)) if povs else 0.0
-        avg_act = float(np.mean(actions)) if actions else 0.0
-
-        rows.append({
-            "t": t,
-            "reflex_collisions_cum": reflex_collisions,
-            "conscious_collisions_cum": conscious_collisions,
-            "avg_conscious_overrides": avg_overrides,
-            "avg_conscious_energy": avg_energy,
-            "avg_conscious_threat": avg_threat,
-            "avg_conscious_P_override": avg_pov,
-            "avg_conscious_action": avg_act,
-            "predators_positions": "|".join([f"{p.x},{p.y}" for p in predators]),
-        })
-
-    df = pd.DataFrame(rows)
-    csv_path = df_to_csv_file(df, f"predator_log_seed{seed}.csv")
-
-    fig1 = plt.figure(figsize=(10, 4))
-    ax = fig1.add_subplot(111)
-    ax.plot(df["t"], df["reflex_collisions_cum"], label="Reflex collisions (cum)")
-    ax.plot(df["t"], df["conscious_collisions_cum"], label="Conscious collisions (cum)")
-    ax.set_title("Predator Avoidance: Collisions (Reflex vs RFT)")
-    ax.set_xlabel("t (step)")
-    ax.set_ylabel("collisions (cum)")
-    ax.legend()
-    p_col = save_plot(fig1, f"predator_collisions_seed{seed}.png")
-
-    fig2 = plt.figure(figsize=(10, 4))
-    ax = fig2.add_subplot(111)
-    ax.plot(df["t"], df["avg_conscious_overrides"], label="Avg overrides (conscious)")
-    ax.plot(df["t"], df["avg_conscious_energy"], label="Avg energy (conscious)")
-    ax.set_title("Predator Avoidance: Overrides + Energy (Conscious)")
-    ax.set_xlabel("t (step)")
-    ax.set_ylabel("value")
-    ax.legend()
-    p_ov = save_plot(fig2, f"predator_overrides_energy_seed{seed}.png")
-
-    fig3 = plt.figure(figsize=(10, 4))
-    ax = fig3.add_subplot(111)
-    ax.plot(df["t"], df["avg_conscious_threat"], label="Avg threat")
-    ax.plot(df["t"], df["avg_conscious_P_override"], label="Avg P_override")
-    ax.plot(df["t"], df["avg_conscious_action"], label="Avg action rate")
-    ax.set_title("Predator Avoidance: Threat vs Override Probability vs Action Rate")
-    ax.set_xlabel("t (step)")
-    ax.set_ylabel("value")
-    ax.legend()
-    p_thr = save_plot(fig3, f"predator_threat_seed{seed}.png")
-
-    heatmap_path = None
-    if show_heatmap and len(conscious_agents) > 0:
-        field = conscious_agents[0].pos_prob
-        fig4 = plt.figure(figsize=(6, 5))
-        ax = fig4.add_subplot(111)
-        im = ax.imshow(field, aspect="auto")
-        ax.set_title("Conscious Agent[0]: Final probability field (pos_prob)")
-        ax.set_xlabel("y")
-        ax.set_ylabel("x")
-        fig4.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
-        heatmap_path = save_plot(fig4, f"predator_probfield_seed{seed}.png")
-
-    summary = {
-        "seed": int(seed),
-        "grid_size": int(grid_size),
-        "steps": int(steps),
-        "num_reflex": int(num_reflex),
-        "num_conscious": int(num_conscious),
-        "num_predators": int(num_predators),
-        "final_reflex_collisions": int(df["reflex_collisions_cum"].iloc[-1]) if len(df) else 0,
-        "final_conscious_collisions": int(df["conscious_collisions_cum"].iloc[-1]) if len(df) else 0,
-        "final_avg_conscious_overrides": float(df["avg_conscious_overrides"].iloc[-1]) if len(df) else 0.0,
-        "final_avg_conscious_energy": float(df["avg_conscious_energy"].iloc[-1]) if len(df) else 0.0,
-        "ops_proxy": int(ops_proxy),
-    }
-
-    imgs = [p_col, p_ov, p_thr]
-    if heatmap_path is not None:
-        imgs.append(heatmap_path)
-
-    return summary, imgs, csv_path
-
 # -----------------------------
 # Benchmarks
 # -----------------------------
@@ -929,37 +561,41 @@ def run_benchmarks(
         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
+    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
 # -----------------------------
 HOME_MD = """
-# Rendered Frame Theory (RFT) — Agent Console
+# RFT — Observer Agent Console
 
-This Space is meant to be transparent, reproducible, and benchmarkable.
+I built this Space to be transparent, reproducible, and benchmarkable.
+
+This is **not** a consciousness claim.  
+When I say “observer” here, I mean a practical decision-timing mechanism: uncertainty → τ_eff → gate → commit or wait.
 
 Run it. Change parameters. Break it. Compare baseline vs RFT.
 
-Core idea:
+What I’m demonstrating is a simple idea:
 
 **Decision timing matters.**
-RFT treats timing (τ_eff), uncertainty, and action “collapse” as first-class controls.
+RFT treats timing (τ_eff), uncertainty, and action “commit” as first-class controls.
+
+This Space contains three working agent harnesses:
+- **NEO alerting** (filter noisy close-approach alerts)
+- **Satellite jitter reduction** (reduce actuator duty / chatter while keeping residual low)
+- **Starship-style landing harness** (simplified, but structured to test decision timing under wind/thrust disturbances)
 
-This Space contains:
-- **NEO alerting**
-- **Satellite jitter reduction**
-- **Starship-style landing harness**
-- **Predator avoidance** (Reflex vs RFT-style "QuantumConscious" agents)
+Every tab shows what it’s doing, why, and where it wins or loses.
 
-No SciPy. No hidden dependencies. No model weights.
+No SciPy. No hidden dependencies. No model weights. No tricks.
 """
 
 LIVE_MD = """
 # Live Console
 
-Run everything quickly and export logs.
+This tab is a single place to run everything quickly and export logs.
 
 - deterministic runs (seeded)
 - plots saved
@@ -968,80 +604,101 @@ Run everything quickly and export logs.
 """
 
 THEORY_PRACTICE_MD = """
-# Theory → Practice (how I implement RFT here)
+# Theory → Practice (how I implement the RFT Observer Agent idea here)
 
-## 1) Uncertainty
-Explicit uncertainty proxy from noise + disturbance scale.
+This Space uses RFT in a practical way:
+
+## 1) Uncertainty (explicit)
+I compute an uncertainty proxy from noise + disturbance scale.
 
 ## 2) Confidence
-confidence = 1 − uncertainty (clipped 0..1).
+Confidence is the complement: confidence = 1 − uncertainty (clipped 0..1).
 
 ## 3) Adaptive τ_eff
-Higher uncertainty → higher τ_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 behaviour I wanted to test.
 
-## 4) Collapse gate
-Act only when the gate passes:
-- confidence exceeds a threshold
-- τ_eff increases strictness under uncertainty
+## 4) Decision gate
+I only apply “decisive actions” when the gate condition passes:
+- confidence must exceed a threshold
+- τ_eff increases strictness (makes the gate harder under uncertainty)
 
-## 5) Why it matters
+## 5) Why this matters
 Baseline controllers often act constantly.
-RFT tries to act less often, but more decisively.
+This observer-gated approach 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)
 
-u ∈ [0,1] : uncertainty proxy  
-C ∈ [0,1] : confidence proxy  
-τ_eff ≥ 1 : effective decision timing factor  
+## Variables (used in this Space)
+- u ∈ [0,1] : uncertainty proxy (dimensionless)
+- C ∈ [0,1] : confidence proxy (dimensionless)
+- τ_eff ≥ 1 : effective decision-timing factor (dimensionless)
+
+## Definitions
 
-Confidence:
+### Confidence
 \[
 C = \text{clip}(1 - u, 0, 1)
 \]
 
-Adaptive τ_eff:
+### Adaptive τ_eff (with “slow by 1.0”)
 \[
 \tau_{\text{eff}} = \text{clip}(1 + 1.0 + g\cdot u,\; 1,\; \tau_{\max})
 \]
 
-Collapse gate (concept):
+### Decision gate (concept)
+Higher τ_eff makes decisions stricter:
 \[
 \text{Gate} = \left[C \ge \theta + k(\tau_{\text{eff}}-1)\right]
 \]
+
+That is exactly what I implement here: more uncertainty → higher τ_eff → harder gate → fewer low-confidence actions.
 """
 
 INVESTOR_MD = """
-# Investor / Agency Walkthrough
+# Investor / Agency Walkthrough (plain language)
 
-What this Space demonstrates:
-- alert filtering (NEO)
+## What I’m proving inside this Space
+I’m demonstrating a decision-timing framework that can be applied to:
+- alert filtering (NEO / tracking)
 - stabilisation (jitter reduction)
-- anomaly-aware control (landing harness)
-- threat-aware avoidance (predator demo)
+- anomaly-aware control loops (landing harness)
 
-What it is not:
-- not flight-certified
-- not a production pipeline
-- not a claim that anyone is using it
+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 makes it production-grade:
+## What I’m not claiming
+- I’m not claiming flight certification
+- I’m not claiming any company is using this
+- I’m not claiming this replaces aerospace validation pipelines
+
+## What would make it production-grade
 - real sensor ingestion + timing constraints
 - hardware-in-loop testing
-- dataset validation
+- systematic dataset validation
+- integration targets (embedded, REST, batch)
 """
 
 REPRO_MD = """
 # Reproducibility & Logs
 
-Everything is reproducible:
-- set seed
-- run
-- export CSV
-- verify plots + metrics
-
-CSV schema is explicit in the exports.
+Everything here is reproducible:
+- set the seed
+- run baseline vs RFT with the same seed
+- export the CSV
+- verify plots and metrics
+
+CSV schema is explicit in the exports:
+- time index
+- state values
+- uncertainty, confidence, τ_eff
+- alerts/actions flags
 """
 
 # -----------------------------
@@ -1091,39 +748,6 @@ 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_predator(seed, grid_size, steps, num_reflex, num_conscious, num_predators,
-                    group_coherence, sense_noise_prob, override_threshold,
-                    alpha, beta, dt_internal,
-                    energy_max, base_override_cost, energy_regen,
-                    quantum_boost_prob, quantum_boost_amount,
-                    show_heatmap):
-    summary, imgs, csv_path = simulate_predator(
-        seed=int(seed),
-        grid_size=int(grid_size),
-        steps=int(steps),
-        num_reflex=int(num_reflex),
-        num_conscious=int(num_conscious),
-        num_predators=int(num_predators),
-        group_coherence=float(group_coherence),
-        sense_noise_prob=float(sense_noise_prob),
-        override_threshold=float(override_threshold),
-        alpha=float(alpha),
-        beta=float(beta),
-        dt_internal=float(dt_internal),
-        energy_max=float(energy_max),
-        base_override_cost=float(base_override_cost),
-        energy_regen=float(energy_regen),
-        quantum_boost_prob=float(quantum_boost_prob),
-        quantum_boost_amount=float(quantum_boost_amount),
-        show_heatmap=bool(show_heatmap)
-    )
-    summary_txt = json.dumps(summary, indent=2)
-    img1 = imgs[0] if len(imgs) > 0 else None
-    img2 = imgs[1] if len(imgs) > 1 else None
-    img3 = imgs[2] if len(imgs) > 2 else None
-    img4 = imgs[3] if len(imgs) > 3 else None
-    return summary_txt, img1, img2, img3, img4, 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):
     txt, score_df, score_csv, imgs, logs = run_benchmarks(
         seed=int(seed),
@@ -1141,7 +765,7 @@ def ui_run_bench(seed, neo_steps, neo_dt, neo_alert_km, neo_noise_km, jit_steps,
 # -----------------------------
 # Gradio UI
 # -----------------------------
-with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)") as demo:
+with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing)") as demo:
     gr.Markdown(HOME_MD)
 
     with gr.Tabs():
@@ -1170,7 +794,7 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                     land_wind = gr.Slider(0.0, 25.0, value=15.0, step=0.5, label="Landing wind max (m/s)")
                     land_thrust_noise = gr.Slider(0.0, 10.0, value=3.0, step=0.1, label="Landing thrust noise")
 
-            run_b = gr.Button("Run Full Benchmarks (Baseline vs RFT)")
+            run_b = gr.Button("Run Full Benchmarks (Baseline vs Observer-gated RFT)")
 
             bench_txt = gr.Textbox(label="Benchmark summary", lines=6)
             bench_table = gr.Dataframe(label="Scorecard (CSV also exported)")
@@ -1204,11 +828,12 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 ]
             )
 
-        with gr.Tab("NEO Agent"):
+        with gr.Tab("NEO Observer Agent"):
             gr.Markdown(
-                "# Near-Earth Object (NEO) Alerting Agent\n"
+                "# Near-Earth Object (NEO) Observer 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"
+                "Observer-gated RFT: distance threshold + confidence + τ_eff decision gate.\n"
             )
             with gr.Row():
                 seed_neo = gr.Number(value=42, precision=0, label="Seed")
@@ -1217,7 +842,7 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
             with gr.Row():
                 alert_km = gr.Slider(1000, 20000, value=5000, step=50, label="Alert threshold (km)")
                 noise_km = gr.Slider(0.0, 200.0, value=35.0, step=1.0, label="Measurement noise (km)")
-                rft_conf_th = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="RFT confidence threshold")
+                rft_conf_th = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="Confidence threshold")
                 tau_gain = gr.Slider(0.0, 3.0, value=1.2, step=0.05, label="τ_eff gain")
             show_debug = gr.Checkbox(value=False, label="Show debug table (first rows)")
             run_neo = gr.Button("Run NEO Simulation")
@@ -1236,11 +861,11 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 outputs=[out_neo_summary, out_neo_debug, out_neo_img1, out_neo_img2, out_neo_img3, out_neo_csv]
             )
 
-        with gr.Tab("Satellite Jitter Agent"):
+        with gr.Tab("Satellite Jitter Observer Agent"):
             gr.Markdown(
-                "# Satellite Jitter Reduction\n"
+                "# Satellite Jitter Reduction (Observer-gated)\n"
                 "Baseline: continuous correction.\n"
-                "RFT: gated correction using confidence + τ_eff.\n"
+                "Observer-gated RFT: gated correction using confidence + τ_eff.\n"
             )
             with gr.Row():
                 seed_j = gr.Number(value=42, precision=0, label="Seed")
@@ -1269,7 +894,7 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
 
         with gr.Tab("Starship Landing Harness"):
             gr.Markdown(
-                "# Starship-style Landing Harness (Simplified)\n"
+                "# Starship-style Landing Harness (Observer-gated decision timing)\n"
                 "This is not a flight model. It’s a timing-control harness.\n"
             )
             with gr.Row():
@@ -1301,65 +926,11 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 outputs=[out_l_summary, out_l_img1, out_l_img2, out_l_img3, out_l_img4, out_l_csv]
             )
 
-        with gr.Tab("Predator Avoidance"):
+        with gr.Tab("Benchmarks"):
             gr.Markdown(
-                "# Predator Avoidance (Reflex vs RFT)\n"
-                "Grid world with roaming predators.\n"
-                "Reflex agents: random walk.\n"
-                "Conscious agents: probability field + threat-weighted override.\n"
-            )
-
-            with gr.Row():
-                seed_p = gr.Number(value=42, precision=0, label="Seed")
-                grid_size = gr.Slider(10, 60, value=20, step=1, label="Grid size")
-                steps_p = gr.Slider(50, 1500, value=200, step=1, label="Steps")
-
-            with gr.Row():
-                num_reflex = gr.Slider(0, 50, value=10, step=1, label="Reflex agents")
-                num_conscious = gr.Slider(0, 20, value=3, step=1, label="Conscious agents")
-                num_predators = gr.Slider(1, 20, value=3, step=1, label="Predators")
-
-            with gr.Accordion("RFT / Agent parameters", open=True):
-                with gr.Row():
-                    group_coherence = gr.Slider(0.0, 0.95, value=0.30, step=0.01, label="Group coherence")
-                    sense_noise_prob = gr.Slider(0.0, 0.9, value=0.10, step=0.01, label="Sense noise probability")
-                    override_threshold = gr.Slider(0.0, 1.0, value=0.02, step=0.005, label="Override threshold (P_ov)")
-
-                with gr.Row():
-                    alpha = gr.Slider(0.0, 50.0, value=15.0, step=0.5, label="alpha (threat gain)")
-                    beta = gr.Slider(0.0, 10.0, value=0.5, step=0.05, label="beta (energy term)")
-                    dt_internal = gr.Slider(0.01, 1.0, value=0.2, step=0.01, label="override dt")
-
-                with gr.Row():
-                    energy_max = gr.Slider(1.0, 300.0, value=100.0, step=1.0, label="Energy max")
-                    base_override_cost = gr.Slider(0.0, 10.0, value=1.0, step=0.1, label="Base override cost")
-                    energy_regen = gr.Slider(0.0, 1.0, value=0.05, step=0.01, label="Energy regen")
-
-                with gr.Row():
-                    quantum_boost_prob = gr.Slider(0.0, 1.0, value=0.10, step=0.01, label="Quantum boost probability")
-                    quantum_boost_amount = gr.Slider(0.0, 50.0, value=5.0, step=0.5, label="Quantum boost amount")
-                    show_heatmap = gr.Checkbox(value=True, label="Show probability field heatmap (agent[0])")
-
-            run_p = gr.Button("Run Predator Simulation")
-
-            out_p_summary = gr.Textbox(label="Summary JSON", lines=12)
-            with gr.Row():
-                out_p_img1 = gr.Image(label="Collisions (cumulative)")
-                out_p_img2 = gr.Image(label="Overrides + Energy")
-            with gr.Row():
-                out_p_img3 = gr.Image(label="Threat / P_override / Action rate")
-                out_p_img4 = gr.Image(label="Final probability field (optional)")
-            out_p_csv = gr.File(label="Download Predator CSV log")
-
-            run_p.click(
-                ui_run_predator,
-                inputs=[seed_p, grid_size, steps_p, num_reflex, num_conscious, num_predators,
-                        group_coherence, sense_noise_prob, override_threshold,
-                        alpha, beta, dt_internal,
-                        energy_max, base_override_cost, energy_regen,
-                        quantum_boost_prob, quantum_boost_amount,
-                        show_heatmap],
-                outputs=[out_p_summary, out_p_img1, out_p_img2, out_p_img3, out_p_img4, out_p_csv]
+                "# Benchmarks\n"
+                "Run full packs from the Live Console tab.\n"
+                "Everything is seeded, logged, and exportable.\n"
             )
 
         with gr.Tab("Theory → Practice"):