Update app.py

app.py

@@ -63,17 +63,20 @@ 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))
@@ -87,11 +90,13 @@ class RFTSelfDecidingBrain:
             ),
         )
 
+        # Awakening ladder
         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
         if self.state.awakening_phase >= 3:
             self.state.mode = "awake"
         elif self.state.awakening_phase == 2:
@@ -101,6 +106,7 @@ class RFTSelfDecidingBrain:
         else:
             self.state.mode = "idle"
 
+        # Internal prediction signal vs actual
         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)
@@ -346,6 +352,7 @@ CONSCIOUS_FLAG_HISTORY: List[float] = []
 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>"
@@ -393,6 +400,15 @@ def nexframe_cycle(user_input: str, chat_history: List[Dict[str, str]]):
 
         reply_text = dialogue
 
+        # Short status strip
+        gate_str = "✅ Gate: PASSED" if is_conscious else "⭕ Gate: NOT PASSED"
+        status_md = (
+            f"**State:** `{brain_obs['mode']}` (phase {brain_obs['awakening_phase']})  \n"
+            f"**κ:** `{kappa:.3f}` • **Energy:** `{energy:.3f}`  \n"
+            f"**{gate_str}**"
+        )
+
+        # Full metrics
         metrics_md = (
             "### NexFrame Status\n\n"
             "**Brain**\n"
@@ -424,11 +440,12 @@ def nexframe_cycle(user_input: str, chat_history: List[Dict[str, str]]):
             f"- Mean fitness: `{civ_stats['mean_fitness']:.3f}`\n"
         )
 
+        # Chatbot messages (dict format)
         chat_history = chat_history + [
             {"role": "user", "content": user_input},
             {"role": "assistant", "content": reply_text},
         ]
-        return chat_history, metrics_md
+        return chat_history, status_md, metrics_md
 
     except Exception as e:
         tb = traceback.format_exc()
@@ -443,29 +460,93 @@ def nexframe_cycle(user_input: str, chat_history: List[Dict[str, str]]):
             {"role": "user", "content": user_input or "<empty>"},
             {"role": "assistant", "content": "⚠ NexFrame hit an internal error. See status panel."},
         ]
-        return chat_history, error_md
+        status_md = "**State:** error  \n**Details:** see status panel below."
+        return chat_history, status_md, error_md
 
 
 # ============================================================
 # 9. GRADIO UI
 # ============================================================
 
+# Initial message so visitors see something immediately
+INITIAL_MESSAGES = [
+    {
+        "role": "assistant",
+        "content": (
+            "I am NexFrame, a symbolic RFT engine. "
+            "Type a message and I will respond while my internal state updates on the right."
+        ),
+    }
+]
+
 with gr.Blocks() as demo:
     gr.Markdown(
         """
 # NexFrame — RFT Symbolic Intelligence
 
-Type to interact with NexFrame.
-
-On the right you see its **internal state**: κ, energy, consciousness gate, triadic coherence, Sarg field, and civilization stats.
+This is **not** a standard chatbot.  
+Your messages drive a small symbolic brain. The chat on the left is its voice.  
+The panel on the right shows what its internal field is doing while it talks to you.
         """
     )
 
+    with gr.Accordion("What am I looking at?", open=False):
+        gr.Markdown(
+            """
+### How this works (non-technical)
+
+NexFrame converts your text into numbers, pushes them through a symbolic brain, and updates a set of dials that describe how stable or chaotic that brain is.
+
+**Left** = what NexFrame says.  
+**Right** = what NexFrame *is* while it says it.
+
+---
+
+#### Brain
+- **κ (kappa)** – how internally coherent NexFrame is (0 = scrambled, 1 = highly aligned).  
+- **Energy** – how much \"fuel\" the brain has to keep running its internal loops.  
+- **Mode** – rough state: `idle`, `searching`, `dreaming`, `awake`.  
+- **Awakening phase** – 0–4 ladder; higher means a more stable, self-consistent state.  
+- **Identity stability / drift** – how steady NexFrame’s internal identity is vs how much it is drifting.
+
+#### Consciousness Gate (3×3)
+A simple, explicit test – not magic.  
+It checks three things:
+
+1. Internal health (κ, energy, stability)  
+2. Prediction quality (how well its own internal signals line up)  
+3. Drift/instability  
+
+Only if all three look good do you see: **\"Minimum conscious threshold passed: True\"**.
+
+#### Symbolic Orchestrator
+- **Entropy** – how spread out the internal patterns are (higher = more chaotic).  
+- **Coherence** – how much the internal fields agree with each other.  
+- **Collapse triggered** – flips when coherence is high *and* entropy is low.
+
+#### Sarg Agent
+A tiny performance + field probe:
+- Generates a small field (Ψₐ and Λ) every time you send a message.  
+- Measures how many operations per second it can push through.  
+- Signs each step with a short hash (**hash oath**) so runs can be tracked externally.
+
+#### Civilization
+A toy population of symbolic agents.  
+You see the averages:
+
+- **Tier** – rough level in the hierarchy.  
+- **Awareness kernel** – how \"aware\" the average agent is.  
+- **Collapse torque** – how strongly they push the field toward decisions.  
+- **Fitness** – one score summarising how viable this symbolic civilization is.
+            """
+        )
+
     with gr.Row():
         with gr.Column(scale=3):
             chatbot = gr.Chatbot(
                 label="NexFrame Dialogue",
                 height=500,
+                value=INITIAL_MESSAGES,
             )
             user_box = gr.Textbox(
                 label="Your message",
@@ -475,18 +556,21 @@ On the right you see its **internal state**: κ, energy, consciousness gate, tri
             send_btn = gr.Button("Send")
 
         with gr.Column(scale=2):
+            status_strip = gr.Markdown(
+                "**State:** waiting for first message…"
+            )
             metrics_panel = gr.Markdown("Metrics will appear here after your first message.")
 
     send_btn.click(
         fn=nexframe_cycle,
         inputs=[user_box, chatbot],
-        outputs=[chatbot, metrics_panel],
+        outputs=[chatbot, status_strip, metrics_panel],
     )
 
     user_box.submit(
         fn=nexframe_cycle,
         inputs=[user_box, chatbot],
-        outputs=[chatbot, metrics_panel],
+        outputs=[chatbot, status_strip, metrics_panel],
     )