Update app.py

app.py

@@ -16,7 +16,6 @@ import gradio as gr
 
 @dataclass
 class RFTBrainParams:
-    """Tunable parameters for the self-deciding brain."""
     base_energy: float = 0.85
     base_kappa: float = 0.65
     learning_rate: float = 0.08
@@ -38,12 +37,6 @@ class RFTBrainState:
 
 
 class RFTSelfDecidingBrain:
-    """
-    Simple but non-trivial self-deciding loop:
-    - Tracks κ (coherence), energy, identity stability, drift.
-    - Evolves in response to external context.
-    """
-
     def __init__(self, params: RFTBrainParams):
         self.params = params
         self.state = RFTBrainState(
@@ -63,11 +56,6 @@ class RFTSelfDecidingBrain:
             self.state.recent_errors.pop(0)
 
     def step(self, context: Dict[str, float]) -> Dict[str, Any]:
-        """
-        One update step. Context can include:
-        - external_risk_factor
-        - cooperative_signal
-        """
         now = time.time()
         dt = max(1e-3, now - self.state.last_update)
         self.state.last_update = now
@@ -75,20 +63,17 @@ class RFTSelfDecidingBrain:
         risk = float(context.get("external_risk_factor", 0.3))
         coop = float(context.get("cooperative_signal", 0.5))
 
-        # Energy dynamics
         target_energy = self.params.base_energy + 0.2 * (coop - risk)
         target_energy = max(0.0, min(1.0, target_energy))
         self.state.energy_reserves += self.params.learning_rate * (target_energy - self.state.energy_reserves)
         self.state.energy_reserves -= self.params.decay * dt
         self.state.energy_reserves = max(0.0, min(1.0, self.state.energy_reserves))
 
-        # Coherence κ dynamics
         target_kappa = self.params.base_kappa + 0.3 * (coop - 0.5) - 0.2 * (risk - 0.3)
         target_kappa = max(0.0, min(1.0, target_kappa))
         self.state.kappa += self.params.learning_rate * (target_kappa - self.state.kappa)
         self.state.kappa = max(0.0, min(1.0, self.state.kappa))
 
-        # Identity drift and stability
         drift_noise = (random.random() - 0.5) * 2.0 * self.params.drift_scale * dt
         self.state.identity_drift += drift_noise + 0.1 * (risk - 0.3) - 0.05 * (coop - 0.5)
         self.state.identity_drift = max(-1.0, min(1.0, self.state.identity_drift))
@@ -102,13 +87,11 @@ class RFTSelfDecidingBrain:
             ),
         )
 
-        # Awakening phase logic
         if self.state.energy_reserves > 0.75 and self.state.kappa > 0.7 and self.state.identity_stability > 0.7:
             self.state.awakening_phase = min(self.state.awakening_phase + 1, 4)
         elif self.state.energy_reserves < 0.35 or self.state.kappa < 0.3:
             self.state.awakening_phase = max(self.state.awakening_phase - 1, 0)
 
-        # Mode selection
         if self.state.awakening_phase >= 3:
             self.state.mode = "awake"
         elif self.state.awakening_phase == 2:
@@ -118,7 +101,6 @@ class RFTSelfDecidingBrain:
         else:
             self.state.mode = "idle"
 
-        # Update "error" for prediction metric
         target_predict = 0.5 + 0.3 * coop
         actual_predict = (self.state.kappa + self.state.energy_reserves) / 2.0
         self._update_error_series(target_predict, actual_predict)
@@ -138,11 +120,6 @@ class RFTSelfDecidingBrain:
 # ============================================================
 
 class NexFrameOrchestrator:
-    """
-    Symbolic orchestrator: takes text, runs a small internal vector cycle,
-    returns a symbolic 'voice' plus entropy/coherence numbers.
-    """
-
     def __init__(self, num_fields: int = 8, vector_dim: int = 128):
         self.num_fields = num_fields
         self.vector_dim = vector_dim
@@ -157,7 +134,6 @@ class NexFrameOrchestrator:
         return float(-np.sum(p * np.log(p)))
 
     def _coherence(self) -> float:
-        # Pairwise cosine similarity mean
         norms = np.linalg.norm(self.state, axis=1, keepdims=True) + 1e-12
         unit = self.state / norms
         sim = unit @ unit.T
@@ -169,7 +145,6 @@ class NexFrameOrchestrator:
         self.step_count += 1
         length_norm = min(len(nl_input) / 200.0, 1.0)
 
-        # Simple recurrent update
         noise = np.random.randn(*self.state.shape) * (0.02 + 0.03 * length_norm)
         feedback = np.tanh(self.state @ self.state.T) @ self.state
         self.state = 0.90 * self.state + 0.09 * feedback + 0.01 * noise
@@ -178,7 +153,6 @@ class NexFrameOrchestrator:
         coher = self._coherence()
         collapse_triggered = bool(coher > 0.6 and entropy < 5.0)
 
-        # Symbolic "voice"
         mode = "reflective"
         if coher > 0.7:
             mode = "resonant"
@@ -238,12 +212,6 @@ def meets_minimum_conscious_threshold(
     error_variance: float,
     drift: float,
 ) -> bool:
-    """
-    Very explicit 3×3 style gate:
-    - Energy, κ, stability high
-    - Prediction accuracy reasonable
-    - Drift and variance not exploding
-    """
     core_ok = energy > 0.55 and kappa > 0.55 and identity_stability > 0.55
     predict_ok = prediction_accuracy > 0.6 and error_variance < 0.15
     drift_ok = abs(drift) < 0.6
@@ -256,7 +224,7 @@ def meets_minimum_conscious_threshold(
 
 def build_default_civilization(n_agents: int = 32) -> List[Dict[str, float]]:
     civ = []
-    for i in range(n_agents):
+    for _ in range(n_agents):
         tier = 1 + int(3 * random.random())
         awareness = max(0.1, min(1.0, random.gauss(0.5, 0.15)))
         torque = max(0.0, min(1.0, random.gauss(0.4, 0.2)))
@@ -319,7 +287,6 @@ class RFTSargAgent:
         return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:24]
 
     def compute_ops(self, size: int = 200_000, speed_mode: bool = True) -> Dict[str, float]:
-        # Simple synthetic workload
         start = time.time()
         arr = np.linspace(0.0, 10.0, size, dtype=float)
         _ = np.sin(arr) * np.cos(arr * 0.5)
@@ -348,23 +315,17 @@ def _derive_prediction_metrics(error_series: List[float]) -> (float, float):
 # 7. GLOBAL NEXFRAME STATE
 # ============================================================
 
-# Core symbolic orchestrator
 ORCHESTRATOR = NexFrameOrchestrator(num_fields=8, vector_dim=128)
-
-# Self-deciding brain
 BRAIN_PARAMS = RFTBrainParams()
 BRAIN = RFTSelfDecidingBrain(params=BRAIN_PARAMS)
 
-# Agent13-style triad
 agent11 = RFTAgent(name="Agent_11", tau_eff=0.6, omega=0.9, LN2=1.1, mode="conscious")
 agent12 = RFTAgent(name="Agent_12", tau_eff=0.7, omega=1.1, LN2=1.1, mode="conscious")
 agent13 = RFTAgent(name="Agent_13", tau_eff=0.8, omega=1.3, LN2=1.2, mode="conscious")
 AGENT13_ENSEMBLE = Agent13Ensemble(agents=[agent11, agent12, agent13])
 
-# Symbolic civilization
 CIVILIZATION = build_default_civilization()
 
-# Sarg probe
 SARG = RFTSargAgent(
     name="SARG_01",
     LMP=1.0,
@@ -373,24 +334,22 @@ SARG = RFTSargAgent(
     entropy_delta=1e-21,
 )
 
-# Histories
 KAPPA_HISTORY: List[float] = []
 ENERGY_HISTORY: List[float] = []
 CONSCIOUS_FLAG_HISTORY: List[float] = []
 
 
 # ============================================================
-# 8. SINGLE NEXFRAME CYCLE (WITH DEBUG WRAP)
+# 8. SINGLE NEXFRAME CYCLE (CHATBOT MESSAGES FORMAT)
 # ============================================================
 
-def nexframe_cycle(user_input: str, chat_history: List[List[str]]):
+def nexframe_cycle(user_input: str, chat_history: List[Dict[str, str]]):
     try:
         if chat_history is None:
             chat_history = []
         if not user_input:
             user_input = "<empty>"
 
-        # 1) Brain step
         text_len = len(user_input)
         context = {
             "external_risk_factor": 0.2 + 0.4 * math.tanh(text_len / 80.0),
@@ -405,12 +364,10 @@ def nexframe_cycle(user_input: str, chat_history: List[List[str]]):
         error_series = BRAIN.state.recent_errors
         prediction_accuracy, error_variance = _derive_prediction_metrics(error_series)
 
-        # 2) Agent13 triad
         observer_frames = [kappa, energy, identity_stability]
         triad_res = AGENT13_ENSEMBLE.collective_action(observer_frames)
         tri_coh = triad_res["triadic_coherence"]
 
-        # 3) Minimum consciousness gate
         is_conscious = meets_minimum_conscious_threshold(
             energy=energy,
             coherence=tri_coh,
@@ -421,24 +378,19 @@ def nexframe_cycle(user_input: str, chat_history: List[List[str]]):
             drift=drift,
         )
 
-        # 4) Orchestrator
         orc_res = ORCHESTRATOR.run_cycle(nl_input=user_input)
         dialogue = orc_res["orchestrator_dialogue"]
 
-        # 5) Sarg probe
         sarg_snapshot = SARG.generate_conscious_field()
         sarg_hash = SARG.commit_hash_oath()
         sarg_perf = SARG.compute_ops(size=200_000, speed_mode=True)
 
-        # 6) Civilization
         civ_stats = civilization_summary(CIVILIZATION)
 
-        # 7) Histories
         KAPPA_HISTORY.append(kappa)
         ENERGY_HISTORY.append(energy)
         CONSCIOUS_FLAG_HISTORY.append(1.0 if is_conscious else 0.0)
 
-        # 8) Build reply + metrics
         reply_text = dialogue
 
         metrics_md = (
@@ -472,7 +424,11 @@ def nexframe_cycle(user_input: str, chat_history: List[List[str]]):
             f"- Mean fitness: `{civ_stats['mean_fitness']:.3f}`\n"
         )
 
-        chat_history = chat_history + [[user_input, reply_text]]
+        # NEW: messages format for Chatbot (Gradio 6)
+        chat_history = chat_history + [
+            {"role": "user", "content": user_input},
+            {"role": "assistant", "content": reply_text},
+        ]
         return chat_history, metrics_md
 
     except Exception as e:
@@ -485,7 +441,8 @@ def nexframe_cycle(user_input: str, chat_history: List[List[str]]):
         if chat_history is None:
             chat_history = []
         chat_history = chat_history + [
-            [user_input or "<empty>", "⚠ NexFrame hit an internal error. See status panel."]
+            {"role": "user", "content": user_input or "<empty>"},
+            {"role": "assistant", "content": "⚠ NexFrame hit an internal error. See status panel."},
         ]
         return chat_history, error_md
 
@@ -510,6 +467,7 @@ On the right you see its **internal state**: κ, energy, consciousness gate, tri
             chatbot = gr.Chatbot(
                 label="NexFrame Dialogue",
                 height=500,
+                type="messages",  # <= important for dict-based messages
             )
             user_box = gr.Textbox(
                 label="Your message",