Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import math
 import json
+import random
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -20,7 +21,9 @@ os.makedirs(OUTDIR, exist_ok=True)
 # Shared utilities
 # -----------------------------
 def set_seed(seed: int):
-    np.random.seed(int(seed) % (2**32 - 1))
+    seed = int(seed) % (2**32 - 1)
+    np.random.seed(seed)
+    random.seed(seed)
 
 def clamp(x, lo, hi):
     return max(lo, min(hi, x))
@@ -49,7 +52,7 @@ def tau_eff_adaptive(
     """
     τ_eff is implemented here as a timing/decision delay modifier.
     - base: baseline τ_eff
-    - slow_by: explicit slow-down term (I wanted this behaviour: slow by 1.0)
+    - slow_by: explicit slow-down term
     - gain: reaction strength to uncertainty
     - cap: prevents absurd values
     """
@@ -103,6 +106,7 @@ def simulate_neo(
         dist = float(np.linalg.norm(meas))
 
         speed = float(np.linalg.norm(vel))
+        # uncertainty proxy: noise relative to alert radius + a mild speed term
         uncertainty = clamp((noise_km / max(alert_km, 1.0)) * 2.0 + (speed / 200.0) * 0.2, 0.0, 1.0)
 
         baseline_alert = dist <= alert_km
@@ -302,11 +306,6 @@ def simulate_jitter(
 
 # -----------------------------
 # 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,
@@ -328,7 +327,7 @@ def simulate_landing(
     x = 60.0
     xv = 0.0
 
-    # A tiny integral term helps remove persistent bias
+    # Integral term helps remove persistent bias
     ix = 0.0
 
     anomalies = 0
@@ -336,39 +335,31 @@ def simulate_landing(
     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
+    LAT_CTRL = 0.95
+    WIND_PUSH = 0.28
+    VERT_CTRL = 0.22
 
-    # Override thresholds (safety style)
     OVERRIDE_X = 18.0
     OVERRIDE_ALT = 260.0
 
     for t in range(int(steps)):
-        # 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_dev = np.random.normal(0.0, thrust_noise)
 
-        # 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.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 (count only meaningful events)
         anomaly_types = []
         if abs(wind) > (0.85 * wind_max):
             anomaly_types.append("High wind")
@@ -380,23 +371,17 @@ def simulate_landing(
         if is_anomaly:
             anomalies += 1
 
-        # Baseline control (continuous)
         u_base_x = -kp_baseline * meas_x - 0.30 * meas_xv
         u_base_v = -kp_baseline * (meas_vv + 5.0)
 
-        # RFT control (gated + override)
-        phase = 1.0 - clamp(meas_alt / 1000.0, 0.0, 1.0)  # 0 high up, 1 near ground
+        phase = 1.0 - clamp(meas_alt / 1000.0, 0.0, 1.0)
         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)
@@ -404,20 +389,16 @@ def simulate_landing(
         u_rft_x = 0.0
         u_rft_v = 0.0
         if do_action:
-            # 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
 
-        # 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)
 
-        # Lateral acceleration from wind and control
         xv = xv + (WIND_PUSH * wind - LAT_CTRL * u_rft_x) * dt
         x = x + xv * dt
 
@@ -501,6 +482,387 @@ 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)
+
+        # "probability field" + initial collapse
+        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)
+
+        # energy + override state
+        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)
+
+        self.psi_override = (0.1 + 0j)
+        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
+
+    def sense_predators(self, predators):
+        perceived = []
+        for p in predators:
+            if random.random() < self.sense_noise_prob:
+                # drop this predator (sensor miss)
+                continue
+            perceived.append((p.x, p.y))
+        return perceived
+
+    def compute_threat(self, perceived):
+        # threat = probability mass near predators (radius window)
+        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):
+        T = self.compute_threat(perceived)
+        E = self.energy / max(self.energy_max, 1e-9)
+        # same structural shape as your PDF: H = alpha*T - beta*E + small recursion term
+        H = self.alpha * T - self.beta * E + 0.01 * (abs(self.psi_override) ** 2)
+        self.psi_override *= np.exp(-1j * H * self.dt_internal)
+
+    def get_override_probability(self):
+        return float(abs(self.psi_override) ** 2)
+
+    def apply_override(self, perceived):
+        # diffuse probability a little (kernel), then suppress regions near predators
+        field = numpy_convolve2d_toroidal(self.pos_prob, self.move_kernel)
+        field = np.maximum(field, 0.0)
+
+        # suppress predator neighborhoods
+        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:
+            # fallback to uniform
+            field[:] = 1.0 / (self.grid_size * self.grid_size)
+        else:
+            field /= s
+
+        self.pos_prob = field
+
+        # collapse away from predator cells explicitly
+        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:
+            # if all got zeroed (rare), just random move
+            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)
+        # occasional full regen (as in your runs)
+        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  # acted?, P_ov, threat
+
+        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.1 + 0j)
+                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))]
+
+    reflex_collisions_cum = []
+    conscious_collisions_cum = []
+    conscious_overrides_avg = []
+    conscious_energy_avg = []
+    conscious_threat_avg = []
+    conscious_pov_avg = []
+    conscious_actions_avg = []
+
+    rows = []
+    ops_proxy = 0
+
+    for t in range(int(steps)):
+        # predators move first
+        for p in predators:
+            p.move()
+
+        # reflex move + collision check
+        for a in reflex_agents:
+            a.move()
+            for p in predators:
+                if a.x == p.x and a.y == p.y:
+                    a.collisions += 1
+
+        # conscious move + collision check
+        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
+
+        reflex_collisions_cum.append(reflex_collisions)
+        conscious_collisions_cum.append(conscious_collisions)
+        conscious_overrides_avg.append(avg_overrides)
+        conscious_energy_avg.append(avg_energy)
+        conscious_threat_avg.append(avg_threat)
+        conscious_pov_avg.append(avg_pov)
+        conscious_actions_avg.append(avg_act)
+
+        # log row (one line per step)
+        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")
+
+    # Plot 1: collisions (cumulative)
+    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")
+
+    # Plot 2: overrides + energy
+    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")
+
+    # Plot 3: threat + P_override + actions
+    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:
+        # show the final probability field of agent 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
 # -----------------------------
@@ -595,35 +957,33 @@ def run_benchmarks(
     return txt, score, score_path, all_imgs, [neo_csv, jit_csv, land_csv]
 
 # -----------------------------
-# UI text blocks (full openness)
+# UI text blocks
 # -----------------------------
 HOME_MD = """
 # Rendered Frame Theory (RFT) — Agent Console
 
-I built this Space to be transparent, reproducible, and benchmarkable.
+This Space is meant 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.
+Run it. Change parameters. Break it. Compare baseline vs RFT.
 
-What I’m demonstrating is a practical idea:
+Core idea:
 
 **Decision timing matters.**
 RFT treats timing (τ_eff), uncertainty, and action “collapse” as first-class controls.
 
-This Space contains three working agent harnesses:
-- **NEO alerting** (reduce early false positives under noisy tracking)
-- **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)
-
-Every tab shows what it’s doing, why, and where it wins or loses.
+This Space contains:
+- **NEO alerting**
+- **Satellite jitter reduction**
+- **Starship-style landing harness**
+- **Predator avoidance** (Reflex vs RFT-style "QuantumConscious" agents)
 
-No SciPy. No hidden dependencies. No model weights. No tricks.
+No SciPy. No hidden dependencies. No model weights.
 """
 
 LIVE_MD = """
 # Live Console
 
-This tab is a single place to run everything quickly and export logs.
+Run everything quickly and export logs.
 
 - deterministic runs (seeded)
 - plots saved
@@ -634,99 +994,78 @@ This tab is a single place to run everything quickly and export logs.
 THEORY_PRACTICE_MD = """
 # Theory → Practice (how I implement RFT here)
 
-This Space uses RFT in a practical way:
-
-## 1) Uncertainty (explicit)
-I compute an uncertainty proxy from noise + disturbance scale.
+## 1) Uncertainty
+Explicit uncertainty proxy from noise + disturbance scale.
 
 ## 2) Confidence
-Confidence is the complement: confidence = 1 − uncertainty (clipped 0..1).
+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 behaviour I wanted to test.
+Higher uncertainty → higher τ_eff.
 
 ## 4) Collapse 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)
+Act only when the gate passes:
+- confidence exceeds a threshold
+- τ_eff increases strictness under uncertainty
 
-## 5) Why this matters
+## 5) Why it 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.
 """
 
 MATH_MD = r"""
 # Mathematics (minimal and implementation-linked)
 
-## 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)
-
-## Definitions
+u ∈ [0,1] : uncertainty proxy  
+C ∈ [0,1] : confidence proxy  
+τ_eff ≥ 1 : effective decision timing factor  
 
-### Confidence
+Confidence:
 \[
 C = \text{clip}(1 - u, 0, 1)
 \]
 
-### Adaptive τ_eff (with “slow by 1.0”)
+Adaptive τ_eff:
 \[
 \tau_{\text{eff}} = \text{clip}(1 + 1.0 + g\cdot u,\; 1,\; \tau_{\max})
 \]
 
-### Collapse gate (concept)
-Higher τ_eff makes decisions stricter:
+Collapse gate (concept):
 \[
 \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 (plain language)
+# Investor / Agency Walkthrough
 
-## What I’m proving inside this Space
-I’m demonstrating a decision-timing framework that can be applied to:
-- alert filtering (NEO / tracking)
+What this Space demonstrates:
+- alert filtering (NEO)
 - stabilisation (jitter reduction)
-- anomaly-aware control loops (landing harness)
-
-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
+- anomaly-aware control (landing harness)
+- threat-aware avoidance (predator demo)
 
-## 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 it is not:
+- not flight-certified
+- not a production pipeline
+- not a claim that anyone is using it
 
-## What would make it production-grade
+What makes it production-grade:
 - real sensor ingestion + timing constraints
 - hardware-in-loop testing
-- systematic dataset validation
-- integration targets (embedded, REST, batch)
+- dataset validation
 """
 
 REPRO_MD = """
 # Reproducibility & Logs
 
-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
+Everything is reproducible:
+- set seed
+- run
+- export CSV
+- verify plots + metrics
+
+CSV schema is explicit in the exports.
 """
 
 # -----------------------------
@@ -776,6 +1115,40 @@ 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)
+    # imgs: 3 or 4
+    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),
@@ -784,7 +1157,6 @@ def ui_run_bench(seed, neo_steps, neo_dt, neo_alert_km, neo_noise_km, jit_steps,
         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: 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],
@@ -794,7 +1166,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)") as demo:
+with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)") as demo:
     gr.Markdown(HOME_MD)
 
     with gr.Tabs():
@@ -862,7 +1234,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
         with gr.Tab("NEO Agent"):
             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"
             )
@@ -898,7 +1269,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
                 "# 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")
@@ -930,7 +1300,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
             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")
@@ -962,13 +1331,68 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
             )
 
         # ----------------------------------------------------------
-        with gr.Tab("Benchmarks"):
+        with gr.Tab("Predator Avoidance"):
             gr.Markdown(
-                "# Benchmarks\n"
-                "Run full packs from the Live Console tab.\n"
-                "Everything is seeded, logged, and exportable.\n"
+                "# 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.01, 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]
+            )
+
+        # ----------------------------------------------------------
         with gr.Tab("Theory → Practice"):
             gr.Markdown(THEORY_PRACTICE_MD)