Update app.py

app.py

@@ -1,13 +1,14 @@
 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) — Observer Agent Console (All-in-One Space)
+# Rendered Frame Theory (RFT) — Agent Console (All-in-One Space)
 # Author: Liam Grinstead
 # Purpose: Transparent, reproducible, benchmarkable agent demos
 # Dependencies: numpy, pandas, matplotlib, gradio (NO scipy)
@@ -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))
@@ -37,7 +40,7 @@ def df_to_csv_file(df: pd.DataFrame, name: str):
     return path
 
 # -----------------------------
-# RFT Core: τ_eff + gating (Observer-style decision timing)
+# RFT Core: τ_eff + gating
 # -----------------------------
 def tau_eff_adaptive(
     uncertainty: float,
@@ -46,13 +49,6 @@ def tau_eff_adaptive(
     gain: float = 1.2,
     cap: float = 4.0
 ):
-    """
-    τ_eff is implemented here as a timing/decision delay modifier.
-    - base: baseline τ_eff
-    - slow_by: explicit slow-down term
-    - gain: reaction strength to uncertainty
-    - cap: prevents absurd values
-    """
     u = clamp(float(uncertainty), 0.0, 1.0)
     tau = base + slow_by + gain * u
     return clamp(tau, base, cap)
@@ -61,11 +57,6 @@ def rft_confidence(uncertainty: float):
     return clamp(1.0 - float(uncertainty), 0.0, 1.0)
 
 def rft_gate(conf: float, tau_eff: float, threshold: float):
-    """
-    Decision gate (observer-style “commit” trigger):
-    - higher τ_eff makes the gate stricter
-    - threshold is the minimum confidence needed
-    """
     conf = float(conf)
     tau_eff = float(tau_eff)
     effective = threshold + 0.08 * (tau_eff - 1.0)
@@ -164,7 +155,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 Observer-gated RFT)")
+    ax.set_title("NEO: Alerts (Baseline vs RFT)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("alert (0/1)")
     p_alerts = save_plot(fig3, f"neo_alerts_seed{seed}.png")
@@ -178,7 +169,9 @@ def simulate_neo(
         "baseline_alerts": int(alerts_baseline),
         "rft_candidates": int(alerts_rft_raw),
         "rft_alerts_filtered": int(alerts_rft_filtered),
-        "false_positive_proxy_reduction_%": float(100.0 * (1.0 - (alerts_rft_filtered / max(alerts_rft_raw, 1)))),
+        "false_positive_proxy_reduction_%": float(
+            100.0 * (1.0 - (alerts_rft_filtered / max(alerts_rft_raw, 1)))
+        ),
         "ops_proxy": int(ops_proxy),
     }
 
@@ -260,7 +253,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 observer-gated plant)")
+    ax.set_title("Jitter: residual vs time (running RFT plant)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("jitter (arb)")
     p_jit = save_plot(fig1, f"jitter_residual_seed{seed}.png")
@@ -269,7 +262,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 Observer-gated RFT)")
+    ax.set_title("Jitter: Actuation duty (Baseline vs RFT gating)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("active (0/1)")
     p_duty = save_plot(fig2, f"jitter_duty_seed{seed}.png")
@@ -472,216 +465,366 @@ def simulate_landing(
 
     return summary, [p_alt, p_x, p_w, p_a], csv_path
 
-# -----------------------------
-# Predator Avoidance (2D)
-# -----------------------------
-def simulate_predator_avoidance(
+# ===============================================================
+# Predator Avoidance (Reflex vs QuantumObserver "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 QuantumObserverAgent:
+    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)
+
+        self.psi_override = (0.08 + 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
+        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):
+        T = self.compute_threat(perceived)
+        E = self.energy / max(self.energy_max, 1e-9)
+        drive = (self.alpha * T) - (self.beta * E)
+
+        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)
+
+        H = drive + 0.01 * (abs(self.psi_override) ** 2)
+        self.psi_override *= amp * np.exp(-1j * H * self.dt_internal)
+
+        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_observer(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)
+                acted = 1
+            else:
+                self.move()
+        else:
+            self.move()
+
+        return acted, P_ov, threat
+
+def simulate_predator(
     seed: int,
+    grid_size: int,
     steps: int,
-    dt: float,
-    world_size: float,
-    predator_speed: float,
-    agent_speed: float,
-    catch_radius: float,
-    sense_noise: float,
-    rft_k_attract: float,
-    rft_k_repulse: float,
-    baseline_k_attract: float,
-    baseline_k_repulse: float,
-    gate_threshold: float,
-    tau_gain: float,
-    goal_radius: float,
-    show_baseline: bool
+    num_reflex: int,
+    num_observer: 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
 ):
-    """
-    A simple pursuit/evasion harness:
-    - Predator chases the agent.
-    - Agent tries to reach a goal while avoiding capture.
-    Baseline: always-on potential field (attract goal + repulse predator).
-    Observer-gated RFT: same control, but can "wait" unless risk is high.
-    """
     set_seed(seed)
 
-    # Initial positions
-    agent = np.array([-0.55 * world_size, -0.10 * world_size], dtype=float)
-    predator = np.array([0.35 * world_size, 0.25 * world_size], dtype=float)
-    goal = np.array([0.60 * world_size, -0.45 * world_size], dtype=float)
-
-    # Helper: normalize vector
-    def nrm(v):
-        s = float(np.linalg.norm(v))
-        if s < 1e-12:
-            return v * 0.0
-        return v / s
+    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))]
+    observer_agents = [
+        QuantumObserverAgent(
+            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_observer))
+    ]
+    predators = [Predator(grid_size) for _ in range(int(num_predators))]
 
-    # Logging
     rows = []
     ops_proxy = 0
 
-    caught = False
-    reached_goal = False
-    t_end = int(steps)
-
-    # Simple "energy" proxy
-    energy_baseline = 0.0
-    energy_rft = 0.0
-
     for t in range(int(steps)):
-        # Noisy sensed predator position (agent perception)
-        pred_meas = predator + np.random.normal(0.0, sense_noise, size=2)
-
-        # Distances
-        d_pa = float(np.linalg.norm(pred_meas - agent))   # perceived predator-agent
-        d_true = float(np.linalg.norm(predator - agent))  # true predator-agent
-        d_ag = float(np.linalg.norm(goal - agent))        # agent-goal
-
-        # Uncertainty proxy:
-        # - higher when predator is close (risk)
-        # - higher when sensing is noisy
-        # - mild term for distance-to-goal (to bias to act near the end)
-        risk = clamp((catch_radius / max(d_pa, 1e-6)) * 0.55, 0.0, 1.0)
-        noise_term = clamp((sense_noise / max(world_size, 1e-9)) * 8.0, 0.0, 1.0)
-        goal_term = clamp(1.0 - (d_ag / max(world_size, 1e-9)), 0.0, 1.0) * 0.15
-        uncertainty = clamp(risk + noise_term + goal_term, 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)
-
-        # Predator moves toward agent (pure pursuit)
-        predator_dir = nrm(agent - predator)
-        predator = predator + predator_dir * predator_speed * dt
-
-        # Baseline control (always on)
-        v_goal_b = nrm(goal - agent) * baseline_k_attract
-        v_away_b = nrm(agent - pred_meas) * (baseline_k_repulse / max(d_pa, 0.25))
-        v_base = v_goal_b + v_away_b
-        v_base = nrm(v_base) * agent_speed
-
-        # RFT (observer-gated) control
-        # Gate can be overridden if risk is high / predator is close / goal is near.
-        do_action = rft_gate(conf, tau, gate_threshold)
-        must_act = (d_pa < (3.0 * catch_radius)) or (d_ag < (2.5 * goal_radius))
-        do_action = bool(do_action or must_act)
-
-        v_rft = np.array([0.0, 0.0], dtype=float)
-        if do_action:
-            phase = clamp(1.0 - (d_ag / max(world_size, 1e-9)), 0.0, 1.0)
-            lookahead = 1.0 + 1.2 * phase
-
-            v_goal = nrm(goal - agent) * (rft_k_attract * lookahead)
-            v_away = nrm(agent - pred_meas) * ((rft_k_repulse * lookahead) / max(d_pa, 0.25))
-            v_rft = v_goal + v_away
-            v_rft = nrm(v_rft) * agent_speed
-
-        # Choose which agent motion to apply to the plant
-        if show_baseline:
-            agent_next = agent + v_base * dt
-            energy_baseline += float(np.linalg.norm(v_base)) * dt
-        else:
-            agent_next = agent + v_rft * dt
-            energy_rft += float(np.linalg.norm(v_rft)) * dt
-
-        # Clamp to bounds
-        agent_next[0] = clamp(agent_next[0], -world_size, world_size)
-        agent_next[1] = clamp(agent_next[1], -world_size, world_size)
-        agent = agent_next
-
-        # Termination checks
-        if d_true <= catch_radius:
-            caught = True
-            t_end = t + 1
-        if d_ag <= goal_radius:
-            reached_goal = True
-            t_end = t + 1
-
-        ops_proxy += 14
+        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 observer_agents:
+            acted, P_ov, threat = a.move_observer(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))
+        observer_collisions = int(sum(a.collisions for a in observer_agents))
+        avg_overrides = float(np.mean([a.overrides for a in observer_agents])) if observer_agents else 0.0
+        avg_energy = float(np.mean([a.energy for a in observer_agents])) if observer_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,
-            "agent_x": agent[0],
-            "agent_y": agent[1],
-            "pred_x": predator[0],
-            "pred_y": predator[1],
-            "goal_x": goal[0],
-            "goal_y": goal[1],
-            "d_pred_agent_true": d_true,
-            "d_pred_agent_meas": d_pa,
-            "d_agent_goal": d_ag,
-            "sense_noise": sense_noise,
-            "uncertainty": uncertainty,
-            "tau_eff": tau,
-            "confidence": conf,
-            "action_taken": int(do_action),
-            "mode": "baseline" if show_baseline else "observer_gated_rft",
-            "v_base_x": v_base[0],
-            "v_base_y": v_base[1],
-            "v_rft_x": v_rft[0],
-            "v_rft_y": v_rft[1],
-            "caught": int(caught),
-            "reached_goal": int(reached_goal),
+            "reflex_collisions_cum": reflex_collisions,
+            "observer_collisions_cum": observer_collisions,
+            "avg_observer_overrides": avg_overrides,
+            "avg_observer_energy": avg_energy,
+            "avg_observer_threat": avg_threat,
+            "avg_observer_P_override": avg_pov,
+            "avg_observer_action": avg_act,
+            "predators_positions": "|".join([f"{p.x},{p.y}" for p in predators]),
         })
 
-        if caught or reached_goal:
-            break
-
     df = pd.DataFrame(rows)
+    csv_path = df_to_csv_file(df, f"predator_log_seed{seed}.csv")
 
-    # Plots
-    fig1 = plt.figure(figsize=(7.5, 7.0))
+    fig1 = plt.figure(figsize=(10, 4))
     ax = fig1.add_subplot(111)
-    ax.plot(df["agent_x"], df["agent_y"], label="Agent")
-    ax.plot(df["pred_x"], df["pred_y"], label="Predator")
-    ax.scatter([df["goal_x"].iloc[0]], [df["goal_y"].iloc[0]], marker="x", s=80, label="Goal")
-    ax.set_title("Predator Avoidance: Trajectories")
-    ax.set_xlabel("x")
-    ax.set_ylabel("y")
-    ax.legend(loc="best")
-    p_traj = save_plot(fig1, f"predator_traj_seed{seed}_{'baseline' if show_baseline else 'rft'}.png")
+    ax.plot(df["t"], df["reflex_collisions_cum"], label="Reflex collisions (cum)")
+    ax.plot(df["t"], df["observer_collisions_cum"], label="Observer 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["d_pred_agent_true"], label="True dist (pred→agent)")
-    ax.plot(df["t"], df["d_agent_goal"], label="Dist (agent→goal)")
-    ax.axhline(catch_radius, linestyle="--", label="Catch radius")
-    ax.axhline(goal_radius, linestyle="--", label="Goal radius")
-    ax.set_title("Predator Avoidance: Distances vs time")
+    ax.plot(df["t"], df["avg_observer_overrides"], label="Avg overrides (observer)")
+    ax.plot(df["t"], df["avg_observer_energy"], label="Avg energy (observer)")
+    ax.set_title("Predator Avoidance: Overrides + Energy (Observer)")
     ax.set_xlabel("t (step)")
-    ax.set_ylabel("distance")
-    ax.legend(loc="best")
-    p_dist = save_plot(fig2, f"predator_dist_seed{seed}_{'baseline' if show_baseline else 'rft'}.png")
+    ax.set_ylabel("value")
+    ax.legend()
+    p_ov = save_plot(fig2, f"predator_overrides_energy_seed{seed}.png")
 
-    fig3 = plt.figure(figsize=(10, 3))
+    fig3 = plt.figure(figsize=(10, 4))
     ax = fig3.add_subplot(111)
-    ax.step(df["t"], df["action_taken"], where="post")
-    ax.set_title("Predator Avoidance: Action timeline (observer-gated)")
+    ax.plot(df["t"], df["avg_observer_threat"], label="Avg threat")
+    ax.plot(df["t"], df["avg_observer_P_override"], label="Avg P_override")
+    ax.plot(df["t"], df["avg_observer_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("action (0/1)")
-    p_act = save_plot(fig3, f"predator_action_seed{seed}_{'baseline' if show_baseline else 'rft'}.png")
-
-    csv_path = df_to_csv_file(df, f"predator_log_seed{seed}_{'baseline' if show_baseline else 'rft'}.csv")
-
-    min_sep = float(df["d_pred_agent_true"].min()) if len(df) else 0.0
-    steps_ran = int(len(df))
-    success = bool(reached_goal and not caught)
+    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(observer_agents) > 0:
+        field = observer_agents[0].pos_prob
+        fig4 = plt.figure(figsize=(6, 5))
+        ax = fig4.add_subplot(111)
+        im = ax.imshow(field, aspect="auto")
+        ax.set_title("Observer 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),
-        "mode": "baseline" if show_baseline else "observer_gated_rft",
-        "steps_ran": steps_ran,
-        "caught": bool(caught),
-        "reached_goal": bool(reached_goal),
-        "success": bool(success),
-        "min_separation_true": float(min_sep),
-        "final_dist_to_goal": float(df["d_agent_goal"].iloc[-1]) if len(df) else None,
-        "energy_proxy_baseline": float(energy_baseline),
-        "energy_proxy_rft": float(energy_rft),
+        "grid_size": int(grid_size),
+        "steps": int(steps),
+        "num_reflex": int(num_reflex),
+        "num_observer": int(num_observer),
+        "num_predators": int(num_predators),
+        "final_reflex_collisions": int(df["reflex_collisions_cum"].iloc[-1]) if len(df) else 0,
+        "final_observer_collisions": int(df["observer_collisions_cum"].iloc[-1]) if len(df) else 0,
+        "final_avg_observer_overrides": float(df["avg_observer_overrides"].iloc[-1]) if len(df) else 0.0,
+        "final_avg_observer_energy": float(df["avg_observer_energy"].iloc[-1]) if len(df) else 0.0,
         "ops_proxy": int(ops_proxy),
     }
 
-    return summary, [p_traj, p_dist, p_act], csv_path
+    imgs = [p_col, p_ov, p_thr]
+    if heatmap_path is not None:
+        imgs.append(heatmap_path)
+
+    return summary, imgs, csv_path
 
 # -----------------------------
-# Benchmarks (NEO/Jitter/Landing only to keep UI stable)
+# Benchmarks (NEO/Jitter/Landing)
 # -----------------------------
 def run_benchmarks(
     seed: int,
@@ -767,42 +910,37 @@ 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  # 3 + 3 + 4 = 10
+    all_imgs = neo_imgs + jit_imgs + land_imgs
     return txt, score, score_path, all_imgs, [neo_csv, jit_csv, land_csv]
 
 # -----------------------------
 # UI text blocks
 # -----------------------------
 HOME_MD = """
-# RFT — Observer Agent Console
-
-I built this Space to be transparent, reproducible, and benchmarkable.
+# Rendered Frame Theory (RFT) — Agent Console
 
-This is **not** a consciousness claim.  
-When I say “observer” here, I mean a practical decision-timing mechanism: uncertainty → τ_eff → gate → commit or wait.
+This Space is meant to be transparent, reproducible, and benchmarkable.
 
 Run it. Change parameters. Break it. Compare baseline vs RFT.
 
-What I’m demonstrating is a simple idea:
+Core idea:
 
 **Decision timing matters.**
-RFT treats timing (τ_eff), uncertainty, and action “commit” as first-class controls.
+RFT treats timing (τ_eff), uncertainty, and action “collapse” as first-class controls.
 
-This Space contains 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 timing-control harness)
-- **Predator avoidance** (agent reaches goal while avoiding a pursuing predator)
+This Space contains:
+- **NEO alerting**
+- **Satellite jitter reduction**
+- **Starship-style landing harness**
+- **Predator avoidance** (Reflex vs RFT-style "QuantumObserver" agents)
 
-Every tab shows what it’s doing, why, and where it wins or loses.
-
-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
@@ -811,102 +949,80 @@ This tab is a single place to run everything quickly and export logs.
 """
 
 THEORY_PRACTICE_MD = """
-# Theory → Practice (how I implement the RFT Observer Agent idea here)
-
-This Space uses RFT in a practical way:
+# Theory → Practice (how I implement RFT here)
 
-## 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) 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)
+## 4) Collapse gate
+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.
-This observer-gated approach 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 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})
 \]
 
-### Decision 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)
-- pursuit/evasion behaviour (predator avoidance)
-
-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 certification
-- I’m not claiming any company is using this
-- I’m not claiming this replaces 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.
 """
 
 # -----------------------------
@@ -956,28 +1072,38 @@ 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, steps, dt, world_size, predator_speed, agent_speed, catch_radius, sense_noise,
-                    rft_k_attract, rft_k_repulse, base_k_attract, base_k_repulse, gate_th, tau_gain, goal_radius, show_baseline):
-    summary, imgs, csv_path = simulate_predator_avoidance(
+def ui_run_predator(seed, grid_size, steps, num_reflex, num_observer, 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),
-        dt=float(dt),
-        world_size=float(world_size),
-        predator_speed=float(predator_speed),
-        agent_speed=float(agent_speed),
-        catch_radius=float(catch_radius),
-        sense_noise=float(sense_noise),
-        rft_k_attract=float(rft_k_attract),
-        rft_k_repulse=float(rft_k_repulse),
-        baseline_k_attract=float(base_k_attract),
-        baseline_k_repulse=float(base_k_repulse),
-        gate_threshold=float(gate_th),
-        tau_gain=float(tau_gain),
-        goal_radius=float(goal_radius),
-        show_baseline=bool(show_baseline),
+        num_reflex=int(num_reflex),
+        num_observer=int(num_observer),
+        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)
-    return summary_txt, imgs[0], imgs[1], imgs[2], csv_path
+    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(
@@ -996,7 +1122,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 — Observer Agent Console (NEO / Jitter / Landing / Predator)") as demo:
+with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)") as demo:
     gr.Markdown(HOME_MD)
 
     with gr.Tabs():
@@ -1025,7 +1151,7 @@ with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing / P
                     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 Observer-gated RFT)")
+            run_b = gr.Button("Run Full Benchmarks (Baseline vs RFT)")
 
             bench_txt = gr.Textbox(label="Benchmark summary", lines=6)
             bench_table = gr.Dataframe(label="Scorecard (CSV also exported)")
@@ -1052,14 +1178,18 @@ with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing / P
             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 Observer Agent"):
+        with gr.Tab("NEO Agent"):
             gr.Markdown(
-                "# Near-Earth Object (NEO) Observer Agent\n"
+                "# Near-Earth Object (NEO) Alerting Agent\n"
                 "Baseline: distance threshold only.\n"
-                "Observer-gated RFT: distance threshold + confidence + τ_eff decision gate.\n"
+                "RFT: distance threshold + confidence + τ_eff collapse gate.\n"
             )
             with gr.Row():
                 seed_neo = gr.Number(value=42, precision=0, label="Seed")
@@ -1068,7 +1198,7 @@ with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing / P
             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="Confidence threshold")
+                rft_conf_th = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="RFT 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")
@@ -1087,11 +1217,11 @@ with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing / P
                 outputs=[out_neo_summary, out_neo_debug, out_neo_img1, out_neo_img2, out_neo_img3, out_neo_csv]
             )
 
-        with gr.Tab("Satellite Jitter Observer Agent"):
+        with gr.Tab("Satellite Jitter Agent"):
             gr.Markdown(
-                "# Satellite Jitter Reduction (Observer-gated)\n"
+                "# Satellite Jitter Reduction\n"
                 "Baseline: continuous correction.\n"
-                "Observer-gated RFT: gated correction using confidence + τ_eff.\n"
+                "RFT: gated correction using confidence + τ_eff.\n"
             )
             with gr.Row():
                 seed_j = gr.Number(value=42, precision=0, label="Seed")
@@ -1120,7 +1250,7 @@ with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing / P
 
         with gr.Tab("Starship Landing Harness"):
             gr.Markdown(
-                "# Starship-style Landing Harness (Observer-gated decision timing)\n"
+                "# Starship-style Landing Harness (Simplified)\n"
                 "This is not a flight model. It’s a timing-control harness.\n"
             )
             with gr.Row():
@@ -1154,52 +1284,65 @@ with gr.Blocks(title="RFT — Observer Agent Console (NEO / Jitter / Landing / P
 
         with gr.Tab("Predator Avoidance"):
             gr.Markdown(
-                "# Predator Avoidance (Observer Agent)\n"
-                "Agent tries to reach a goal while avoiding a pursuing predator.\n"
-                "This is a simple pursuit/evasion harness designed to be inspectable and reproducible.\n"
-                "Toggle **Baseline** (always-on control) vs **Observer-gated RFT** (can wait unless risk is high).\n"
+                "# Predator Avoidance (Reflex vs RFT)\n"
+                "Grid world with roaming predators.\n"
+                "Reflex agents: random walk.\n"
+                "Observer agents: probability field + threat-weighted override.\n"
             )
+
             with gr.Row():
-                seed_p = gr.Number(value=7, precision=0, label="Seed")
-                steps_p = gr.Slider(50, 1500, value=450, step=1, label="Steps")
-                dt_p = gr.Slider(0.05, 1.0, value=0.20, step=0.01, label="dt")
-            with gr.Row():
-                world_size = gr.Slider(20.0, 300.0, value=120.0, step=5.0, label="World size (bounds)")
-                predator_speed = gr.Slider(0.1, 40.0, value=10.0, step=0.1, label="Predator speed")
-                agent_speed = gr.Slider(0.1, 40.0, value=12.0, step=0.1, label="Agent speed")
-            with gr.Row():
-                catch_radius = gr.Slider(0.5, 30.0, value=6.0, step=0.5, label="Catch radius")
-                goal_radius = gr.Slider(0.5, 30.0, value=6.0, step=0.5, label="Goal radius")
-                sense_noise = gr.Slider(0.0, 10.0, value=1.2, step=0.1, label="Sensor noise (predator)")
-            with gr.Row():
-                base_k_att = gr.Slider(0.1, 10.0, value=1.2, step=0.05, label="Baseline attract gain")
-                base_k_rep = gr.Slider(0.1, 30.0, value=10.0, step=0.1, label="Baseline repulse gain")
-            with gr.Row():
-                rft_k_att = gr.Slider(0.1, 10.0, value=1.2, step=0.05, label="RFT attract gain")
-                rft_k_rep = gr.Slider(0.1, 30.0, value=10.0, step=0.1, label="RFT repulse gain")
+                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():
-                gate_p = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="Gate threshold")
-                tau_p = gr.Slider(0.0, 3.0, value=1.2, step=0.05, label="τ_eff gain")
-                mode_baseline = gr.Checkbox(value=False, label="Run Baseline mode (unchecked = Observer-gated RFT)")
-            run_p = gr.Button("Run Predator Avoidance")
+                num_reflex = gr.Slider(0, 50, value=10, step=1, label="Reflex agents")
+                num_observer = gr.Slider(0, 20, value=3, step=1, label="Observer 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="Trajectories")
-                out_p_img2 = gr.Image(label="Distances vs time")
-                out_p_img3 = gr.Image(label="Action timeline")
+                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, steps_p, dt_p, world_size, predator_speed, agent_speed, catch_radius, sense_noise,
-                        rft_k_att, rft_k_rep, base_k_att, base_k_rep, gate_p, tau_p, goal_radius, mode_baseline],
-                outputs=[out_p_summary, out_p_img1, out_p_img2, out_p_img3, out_p_csv]
+                inputs=[seed_p, grid_size, steps_p, num_reflex, num_observer, 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("Benchmarks"):
-            gr.Markdown("# Benchmarks\nRun full packs from the Live Console tab.\nEverything is seeded, logged, and exportable.\n")
-
         with gr.Tab("Theory → Practice"):
             gr.Markdown(THEORY_PRACTICE_MD)