Update gradio_app.py

gradio_app.py

@@ -1,14 +1,14 @@
 """
-gradio_app.py — Proto-Cognitive Architecture v5
+gradio_app.py  — Proto-Cognitive Architecture v4
 HuggingFace Spaces deployment wrapper.
 
-v5 CHANGES:
-  - Dream/Replay controls: trigger dream cycles from the UI
-  - W_local connection stats: see Hebbian structure forming
-  - Memory consolidation display: M tensor health
-  - Auto-dream toggle after teach
-  - Enhanced diagnostics panel with v5 mechanisms
-  - Backward compatible with v4 world saves
+v4 CHANGES:
+  - Cognitive Router display: shows resonance score + route decision
+  - Resonance bar visualization (why the agent answered the way it did)
+  - Route-based response formatting (confident vs hedged vs deferred)
+  - Resonance history tracking
+  - Better diagnostics: routing stats alongside field/episode stats
+  - Cleaner teach panel with batch import
 
 Deploy to HF Spaces:
   1. Create a new Space (Gradio SDK, GPU T4 or better)
@@ -20,7 +20,6 @@ requirements.txt:
   transformers>=4.40
   gradio>=4.0
   numpy
-  accelerate
 """
 
 import os
@@ -38,50 +37,50 @@ LM_JUDGE_MODEL = os.environ.get("LM_JUDGE_MODEL", "qwen/qwen3.5-35b-a3b")
 USE_JUDGE = os.environ.get("USE_JUDGE", "false").lower() == "true"
 
 # ── Global agent ──────────────────────────────────────────────────────────────
-print("Loading Proto-Cognitive Agent v5.1...")
+print("Loading Proto-Cognitive Agent v4...")
 agent = HybridLLM()
 print("Agent ready.")
 
 WORLD_SAVE_PATH = "world_state.pt"
 
-# ── History tracking ──────────────────────────────────────────────────────────
+# ── Resonance history for the chart ──────────────────────────────────────────
 resonance_history: list[dict] = []
 MAX_HISTORY = 50
 
 
 # =============================================================================
-# ROUTE FORMATTING
+#  ROUTE FORMATTING
 # =============================================================================
 
 ROUTE_EMOJI = {
-    "CONFIDENT": "🟢",
-    "CAUTIOUS":  "🟡",
-    "UNCERTAIN": "🟠",
-    "DEFER":     "🔴",
+    "CONFIDENT":  "🟢",
+    "CAUTIOUS":   "🟡",
+    "UNCERTAIN":  "🟠",
+    "DEFER":      "🔴",
 }
 
 ROUTE_LABEL = {
-    "CONFIDENT": "Confident — strong field resonance + reliable facts retrieved",
-    "CAUTIOUS":  "Cautious — field recognises domain but facts are weak",
-    "UNCERTAIN": "Uncertain — some retrieval but low domain familiarity",
-    "DEFER":     "Deferred — no stored knowledge about this topic",
+    "CONFIDENT":  "Confident — strong field resonance + reliable facts retrieved",
+    "CAUTIOUS":   "Cautious — field recognises domain but facts are weak",
+    "UNCERTAIN":  "Uncertain — some retrieval but low domain familiarity",
+    "DEFER":      "Deferred — no stored knowledge about this topic",
 }
 
 
 def format_route_badge(resp: CognitiveResponse) -> str:
+    """Creates a visual route badge for display."""
     emoji = ROUTE_EMOJI.get(resp.route, "⚪")
     label = ROUTE_LABEL.get(resp.route, resp.route)
     return (
-        f"{emoji} **{resp.route}** | "
-        f"Resonance: `{resp.resonance:.3f}` | "
-        f"Retrieval: `{resp.retrieval_confidence:.3f}` | "
-        f"Tension: `{resp.tension:.3f}` | "
-        f"Steps: `{resp.think_steps_used}`\n"
+        f"{emoji} **{resp.route}**  |  "
+        f"Resonance: `{resp.resonance:.3f}`  |  "
+        f"Retrieval: `{resp.retrieval_confidence:.3f}`\n"
         f"*{label}*"
     )
 
 
 def format_retrieved_facts(resp: CognitiveResponse) -> str:
+    """Shows which facts were retrieved and their scores."""
     if not resp.retrieved_facts:
         return "*No facts retrieved*"
     lines = []
@@ -93,7 +92,7 @@ def format_retrieved_facts(resp: CognitiveResponse) -> str:
 
 
 # =============================================================================
-# LM STUDIO JUDGE
+#  LM STUDIO JUDGE
 # =============================================================================
 
 def lm_judge(question: str, answer: str, context_facts: list[str]) -> tuple[str, float]:
@@ -113,9 +112,9 @@ AI answer:
 {answer}
 
 Rate the answer on a scale from 0.0 to 1.0:
-1.0 = fully correct, cites the right facts
-0.5 = partially correct or vague
-0.0 = wrong, ignores the provided facts
+  1.0 = fully correct, cites the right facts
+  0.5 = partially correct or vague
+  0.0 = wrong, ignores the provided facts
 
 Respond with ONLY a JSON object: {{"score": 0.X, "verdict": "one sentence"}}"""
 
@@ -139,60 +138,38 @@ Respond with ONLY a JSON object: {{"score": 0.X, "verdict": "one sentence"}}"""
 
 
 # =============================================================================
-# CORE FUNCTIONS
+#  CORE FUNCTIONS
 # =============================================================================
 
 def get_diagnostics() -> str:
-    d = agent.world.diagnostics()
+    d  = agent.world.diagnostics()
     ed = agent.episodes.diagnostics()
     tok = agent.token_report()
     rs = agent.router.get_routing_stats()
 
     lines = [
         "### Field State",
-        f"**Field norm:** {d['field_norm']:.3f} | "
+        f"**Field norm:** {d['field_norm']:.3f}  |  "
         f"**Active regions:** {d['active_regions']} / {d['protected']} protected",
-        f"**Attractors:** {d['attractors']} | "
+        f"**Attractors:** {d['attractors']}  |  "
         f"**Steps:** {d['total_steps']}",
         "",
-        "### Hebbian Structure (v5)",
-        f"**W_local connections:** {d['w_local_connections']} | "
-        f"**Density:** {d['w_local_density']:.4f}",
-        f"**W_local max:** {d['w_local_max']:.4f} | "
-        f"**Mean:** {d['w_local_mean']:.4f}",
-        f"**Hebbian updates:** {d['hebbian_updates']}",
-        "",
-    ]
-
-    # v5.2: Region embeddings count
-    #n_region_embeds = sum(1 for e in agent.world.region_embeds if e is not None)
-    n_region_embeds = sum(1 for m in agent.world.memories if m)
-    lines.append(f"**Region embeds (for resonance):** {n_region_embeds} stored")
-
-    lines.extend([
-        "",
-        "### Memory Consolidation (v5)",
-        f"**M norm:** {d['m_norm']:.4f} | "
-        f"**M active regions:** {d['m_active_regions']}",
-        f"**Consolidations:** {d['consolidations']} | "
-        f"**Replay cycles:** {d['replays']}",
-        "",
         "### Episodic Store",
-        f"**Total:** {ed['total']} | "
-        f"**Active:** {ed['active']} | "
+        f"**Total:** {ed['total']}  |  "
+        f"**Active:** {ed['active']}  |  "
         f"**Superseded:** {ed['superseded']}",
         "",
         "### Cognitive Router",
-    ])
+    ]
 
     if rs["total"] > 0:
         lines.extend([
             f"**Queries routed:** {rs['total']}",
-            f"🟢 Confident: {rs['confident']} | "
-            f"🟡 Cautious: {rs['cautious']} | "
-            f"🟠 Uncertain: {rs['uncertain']} | "
+            f"🟢 Confident: {rs['confident']}  |  "
+            f"🟡 Cautious: {rs['cautious']}  |  "
+            f"🟠 Uncertain: {rs['uncertain']}  |  "
             f"🔴 Defer: {rs['defer']}",
-            f"**Avg resonance:** {rs['avg_resonance']:.4f} | "
+            f"**Avg resonance:** {rs['avg_resonance']:.4f}  |  "
             f"**Avg retrieval:** {rs['avg_retrieval']:.4f}",
         ])
     else:
@@ -201,25 +178,12 @@ def get_diagnostics() -> str:
     lines.extend([
         "",
         "### Token Usage",
-        f"**Teach:** {tok['teach_calls']} calls ({tok['teach_input_tokens']} tok) | "
+        f"**Teach:** {tok['teach_calls']} calls ({tok['teach_input_tokens']} tok)  |  "
         f"**Gen:** {tok['generate_calls']} calls",
-        f"**Avg in/gen:** {tok['avg_input_per_gen']} | "
+        f"**Avg in/gen:** {tok['avg_input_per_gen']}  |  "
         f"**Avg out/gen:** {tok['avg_output_per_gen']}",
     ])
 
-    # v5.1: Tension stats
-    ts = agent.tension.get_stats()
-    if ts["total"] > 0:
-        lines.extend([
-            "",
-            "### Tension (v5.1)",
-            f"**Current:** {ts['current']:.4f} | "
-            f"**Avg:** {ts['avg_tension']:.4f} | "
-            f"**Trend:** {ts['trend']:+.4f}",
-            f"**Range:** {ts['min_tension']:.4f} — {ts['max_tension']:.4f} | "
-            f"**Adaptive steps:** {ts['adaptive_steps']}",
-        ])
-
     # Pinned facts
     if ed["total"] > 0:
         lines += ["", "### Pinned Facts"]
@@ -237,407 +201,273 @@ def get_diagnostics() -> str:
 
 
 def get_resonance_chart() -> str:
+    """Build a simple text-based resonance history chart."""
     if not resonance_history:
         return "*No resonance data yet — ask some questions first*"
 
-    lines = ["### Resonance + Tension History (last 20 queries)", ""]
+    lines = ["### Resonance History (last 20 queries)", ""]
     recent = resonance_history[-20:]
     for entry in recent:
         r = entry["resonance"]
         ret = entry["retrieval"]
         route = entry["route"]
-        t = entry.get("tension", 0)
-        steps = entry.get("steps", "?")
         emoji = ROUTE_EMOJI.get(route, "⚪")
         bar_r = "█" * int(r * 20) + "░" * (20 - int(r * 20))
         bar_t = "█" * int(ret * 20) + "░" * (20 - int(ret * 20))
-        q = entry["query"][:30]
+        q = entry["query"][:35]
         lines.append(
-            f"{emoji} `R:{bar_r}` `S:{bar_t}` T={t:.2f} s={steps} {q}"
+            f"{emoji} `R:{bar_r}` `S:{bar_t}` {q}"
         )
     return "\n".join(lines)
 
 
-def get_w_local_viz() -> str:
-    """Visualize the W_local connection structure."""
-    d = agent.world.diagnostics()
-    w = agent.world.W_local.data
-
-    lines = [
-        "### W_local Connection Map (v5)",
-        f"**Density:** {d['w_local_density']:.4f} | "
-        f"**Connections:** {d['w_local_connections']} | "
-        f"**Max:** {d['w_local_max']:.4f}",
-        "",
-    ]
+def teach_fact(fact_text: str, history: list) -> tuple[list, str, str]:
+    """Teach one or more facts (newline-separated) to the agent."""
+    if not fact_text.strip():
+        return history, get_diagnostics(), "⚠ Enter at least one fact."
 
-    # Find strongest connections
-    w_abs = w.abs()
-    # Zero diagonal for display
-    w_disp = w_abs.clone()
-    w_disp.fill_diagonal_(0.0)
-
-    if w_disp.max() > 0.001:
-        # Top 15 strongest connections
-        flat = w_disp.flatten()
-        k = min(15, int((flat > 0.001).sum().item()))
-        if k > 0:
-            topk_vals, topk_idx = torch.topk(flat, k)
-            lines.append("**Strongest connections:**")
-            for val, idx in zip(topk_vals.tolist(), topk_idx.tolist()):
-                i = idx // agent.world.n
-                j = idx % agent.world.n
-                bar_len = int(val / d['w_local_max'] * 15) if d['w_local_max'] > 0 else 0
-                bar = "█" * bar_len + "░" * (15 - bar_len)
-                mem_i = agent.world.memories[i][:25] if agent.world.memories[i] else f"region_{i}"
-                mem_j = agent.world.memories[j][:25] if agent.world.memories[j] else f"region_{j}"
-                lines.append(f"`{bar}` {val:.4f}  {mem_i} ↔ {mem_j}")
-    else:
-        lines.append("*No significant connections yet — teach some facts first*")
-
-    # Per-region connection count
-    lines.extend(["", "**Regions by connectivity:**"])
-    conn_per_region = (w_disp > 0.001).sum(dim=1)
-    top_regions = torch.topk(conn_per_region.float(), min(8, agent.world.n))
-    for idx, count in zip(top_regions.indices.tolist(), top_regions.values.tolist()):
-        if count < 1:
-            continue
-        mem = agent.world.memories[idx][:40] if agent.world.memories[idx] else f"region_{idx}"
-        prot = "🛡" if agent.world.protected[idx] else "  "
-        lines.append(f"{prot} Region {idx:2d}: {int(count)} connections — {mem}")
+    facts = [f.strip() for f in fact_text.strip().split("\n") if f.strip()]
+    results = []
+    for fact in facts:
+        agent.teach(fact)
+        results.append(f"✓ Encoded: *{fact[:80]}*")
 
-    return "\n".join(lines)
+    msg = "\n".join(results)
+    history = history + [
+        {"role": "assistant",
+         "content": f"**Taught {len(facts)} fact(s):**\n{msg}"}
+    ]
+    return history, get_diagnostics(), ""
+
+
+def chat(message: str, history: list, use_judge: bool) -> tuple[list, str, str]:
+    """Generate a response with cognitive routing."""
+    if not message.strip():
+        return history, get_diagnostics(), get_resonance_chart()
+
+    # Use the full cognitive generation pipeline
+    resp = agent.generate_cognitive(message, max_new_tokens=200, verbose=False)
+    answer = extract_answer(resp.text)
+
+    # Track resonance history
+    resonance_history.append({
+        "query": message,
+        "resonance": resp.resonance,
+        "retrieval": resp.retrieval_confidence,
+        "route": resp.route,
+    })
+    if len(resonance_history) > MAX_HISTORY:
+        resonance_history.pop(0)
+
+    # Build response with route badge
+    route_badge = format_route_badge(resp)
+    facts_display = format_retrieved_facts(resp)
+
+    response_parts = [answer]
+
+    # Add routing metadata (collapsible)
+    response_parts.append(f"\n\n---\n{route_badge}")
+    if resp.retrieved_facts:
+        response_parts.append(f"\n**Retrieved facts:**\n{facts_display}")
+
+    # Optionally judge
+    if use_judge and USE_JUDGE:
+        recalled = [t for t, _ in resp.retrieved_facts]
+        verdict, score = lm_judge(message, answer, recalled)
+        if score >= 0:
+            response_parts.append(f"\n*Judge: {score:.2f} — {verdict}*")
+
+    # Timing
+    response_parts.append(
+        f"\n*{resp.latency_s:.2f}s*"
+    )
 
+    full_response = "\n".join(response_parts)
 
-def get_tension_chart() -> str:
-    """Visualize tension over time with trend."""
-    ts = agent.tension.get_stats()
-    history = agent.tension.history
+    history = history + [
+        {"role": "user",      "content": message},
+        {"role": "assistant", "content": full_response},
+    ]
+    return history, get_diagnostics(), get_resonance_chart()
 
-    if not history:
-        return "*No tension data yet — ask some questions first*"
 
-    lines = [
-        "### Tension Over Time",
-        f"**Queries:** {ts['total']} | "
-        f"**Avg:** {ts['avg_tension']:.4f} | "
-        f"**Trend:** {ts['trend']:+.4f}",
-        "",
+def clear_world(history: list) -> tuple[list, str, str]:
+    agent.reset_world()
+    resonance_history.clear()
+    history = history + [
+        {"role": "assistant",
+         "content": "🔄 World state cleared. All facts, field state, and routing history reset."}
     ]
+    return history, get_diagnostics(), get_resonance_chart()
 
-    # Show last 20 entries with visual bars
-    recent = history[-20:]
-    for i, entry in enumerate(recent):
-        t = entry["tension"]
-        # Color coding: low=green, mid=yellow, high=red
-        if t < 0.3:
-            indicator = "🟢"
-        elif t < 0.6:
-            indicator = "🟡"
-        else:
-            indicator = "🔴"
-
-        bar_len = int(t * 25)
-        bar = "█" * bar_len + "░" * (25 - bar_len)
-
-        # Show components
-        lines.append(
-            f"{indicator} `{bar}` {t:.3f}  "
-            f"(u={entry['uncertainty']:.2f} p={entry['pred_error']:.2f} "
-            f"i={entry['instability']:.2f})"
-        )
 
-    # Learning signal: if tension is decreasing over time
-    if len(history) >= 5:
-        first_5 = sum(h["tension"] for h in history[:5]) / 5
-        last_5 = sum(h["tension"] for h in history[-5:]) / 5
-        delta = last_5 - first_5
-        lines.extend([
-            "",
-            f"**Learning signal:** first 5 avg={first_5:.3f} → "
-            f"last 5 avg={last_5:.3f} (Δ={delta:+.3f})",
-        ])
-        if delta < -0.05:
-            lines.append("📉 *Tension decreasing — system is learning*")
-        elif delta > 0.05:
-            lines.append("📈 *Tension increasing — system may be struggling*")
-        else:
-            lines.append("➡️ *Tension stable*")
+def save_world() -> str:
+    agent.save_world(WORLD_SAVE_PATH)
+    return f"✓ Saved to `{WORLD_SAVE_PATH}`"
 
-    return "\n".join(lines)
+
+def load_world() -> tuple[str, str]:
+    agent.load_world(WORLD_SAVE_PATH)
+    return f"✓ Loaded from `{WORLD_SAVE_PATH}`", get_diagnostics()
 
 
 # =============================================================================
-# HANDLERS
+#  GRADIO UI
 # =============================================================================
 
-def handle_teach(fact_text: str, auto_dream: bool) -> tuple:
-    if not fact_text.strip():
-        return "Please enter a fact to teach.", get_diagnostics()
-
-    dream_result = agent.teach(fact_text, verbose=True, auto_dream=auto_dream)
-
-    msg = f"✅ Encoded: *{fact_text[:80]}*"
-    if dream_result:
-        msg += (f"\n💭 Auto-dream: {dream_result['steps']} steps, "
-                f"norm Δ={dream_result['norm_delta']:.4f}, "
-                f"W density Δ={dream_result['w_density_delta']:.6f}")
-
-    return msg, get_diagnostics()
+DESCRIPTION = """
+# Proto-Cognitive Architecture v4
+**Neural Field + Hebbian Memory + Semantic Retrieval + Cognitive Router**
 
+Teach the agent facts, then ask questions. The agent uses a continuous Hebbian
+attractor field to detect **cognitive resonance** (familiarity) with learned content,
+and routes queries accordingly:
 
-def handle_batch_teach(batch_text: str, auto_dream: bool) -> tuple:
-    if not batch_text.strip():
-        return "Please enter facts (one per line).", get_diagnostics()
+| Route | Meaning |
+|-------|---------|
+| 🟢 **CONFIDENT** | Strong field resonance + reliable facts → full answer |
+| 🟡 **CAUTIOUS** | Field recognises domain but weak retrieval → hedged answer |
+| 🟠 **UNCERTAIN** | Some retrieval but low familiarity → answer with caveats |
+| 🔴 **DEFER** | No stored knowledge → admits ignorance |
 
-    facts = [line.strip() for line in batch_text.split("\n") if line.strip()]
-    results = []
-    for fact in facts:
-        dream_result = agent.teach(fact, verbose=True, auto_dream=auto_dream)
-        results.append(f"✅ {fact[:60]}")
-
-    return "\n".join(results) + f"\n\n**{len(facts)} facts encoded.**", get_diagnostics()
-
-
-def handle_dream(cycles: int, steps: int) -> tuple:
-    cycles = max(1, min(int(cycles), 5))
-    steps = max(1, min(int(steps), 20))
-
-    results = agent.dream(cycles=cycles, steps_per_cycle=steps, verbose=True)
-
-    lines = [f"### Dream Session: {cycles} cycle(s) × {steps} steps", ""]
-    for i, r in enumerate(results):
-        lines.append(
-            f"**Cycle {i+1}:** norm Δ={r['norm_delta']:.4f} | "
-            f"W density Δ={r['w_density_delta']:.6f}"
-        )
-
-    d = agent.world.diagnostics()
-    lines.extend([
-        "",
-        f"**Post-dream state:** W_local density={d['w_local_density']:.4f}, "
-        f"M norm={d['m_norm']:.4f}, "
-        f"connections={d['w_local_connections']}",
-    ])
-
-    return "\n".join(lines), get_diagnostics(), get_w_local_viz()
-
-
-def handle_save() -> str:
-    agent.save_world(WORLD_SAVE_PATH)
-    return f"✅ World saved to `{WORLD_SAVE_PATH}`"
-
-
-def handle_load() -> tuple:
-    agent.load_world(WORLD_SAVE_PATH)
-    return f"✅ World loaded from `{WORLD_SAVE_PATH}`", get_diagnostics()
-
-
-def handle_reset() -> tuple:
-    agent.reset_world()
-    resonance_history.clear()
-    return "🗑 World reset.", get_diagnostics()
+**Key properties:** Zero forgetting · Paraphrase robustness · O(1) memory ·
+Contradiction handling · Introspectable routing decisions
+"""
 
+with gr.Blocks(title="Proto-Cognitive LLM v4", theme=gr.themes.Soft()) as demo:
 
-# =============================================================================
-# GRADIO UI
-# =============================================================================
+    gr.Markdown(DESCRIPTION)
 
-def build_ui():
-    with gr.Blocks(
-        title="Proto-Cognitive Architecture v5.1",
-        theme=gr.themes.Soft(),
-    ) as demo:
-
-        gr.Markdown(
-            "# 🧠 Proto-Cognitive Architecture v5.1\n"
-            "Neural Field + Episodic Memory + Cognitive Router "
-            "+ **Hebbian Learning** + **Consolidation** + **Replay** "
-            "+ **Tension Tracking**\n\n"
-            "*Teach facts → ask questions → watch tension decrease as the field learns*"
-        )
+    with gr.Row():
 
-        with gr.Row():
-            # ── Left: Chat + Teach ──
-            with gr.Column(scale=2):
+        # ── Left column: main interface ───────────────────────────────────────
+        with gr.Column(scale=3):
 
-                # Chat
-                chatbot = gr.Chatbot(
-                    label="Conversation",
-                    height=350,
-                    type="messages",
+            # Teach panel
+            with gr.Accordion("📚 Teach facts", open=True):
+                gr.Markdown(
+                    "*One fact per line. Facts are encoded into the Hebbian field "
+                    "and pinned to the semantic store. Teaching a contradictory "
+                    "fact automatically supersedes the old one.*"
                 )
-                with gr.Row():
-                    chat_input = gr.Textbox(
-                        label="Ask a question",
-                        placeholder="What do you know about...?",
-                        scale=4,
-                    )
-                    chat_btn = gr.Button("Ask", variant="primary", scale=1)
-
-                route_display = gr.Markdown(label="Route Decision")
-                facts_display = gr.Markdown(label="Retrieved Facts")
-                judge_display = gr.Markdown(label="Judge", visible=USE_JUDGE)
-
-                # Teach
-                gr.Markdown("---\n### Teach Facts")
-                with gr.Row():
-                    teach_input = gr.Textbox(
-                        label="Teach a fact",
-                        placeholder="The capital of France is Paris.",
-                        scale=4,
-                    )
-                    teach_btn = gr.Button("Teach", variant="secondary", scale=1)
-                auto_dream_toggle = gr.Checkbox(
-                    label="Auto-dream after teach",
-                    value=True,
-                    info="Run a short replay cycle after each teach to reinforce structure",
+                teach_input = gr.Textbox(
+                    label="Facts to teach (one per line)",
+                    placeholder=(
+                        "Server alpha IP is 10.0.0.42.\n"
+                        "Dr. Singh leads NEXUS-7.\n"
+                        "The API rate limit is 500 requests per minute."
+                    ),
+                    lines=4,
                 )
-                teach_result = gr.Markdown(label="Teach Result")
-
-                # Batch teach
-                with gr.Accordion("Batch Teach", open=False):
-                    batch_input = gr.Textbox(
-                        label="Facts (one per line)",
-                        lines=5,
-                        placeholder="The Earth orbits the Sun.\nWater boils at 100°C.\nParis is in France.",
-                    )
-                    batch_btn = gr.Button("Teach All")
-                    batch_result = gr.Markdown()
-
-            # ── Right: Diagnostics + Dream ──
-            with gr.Column(scale=1):
-
-                with gr.Tabs():
-                    with gr.TabItem("Diagnostics"):
-                        diag_display = gr.Markdown(value=get_diagnostics)
-                        refresh_btn = gr.Button("Refresh", size="sm")
-
-                    with gr.TabItem("Resonance"):
-                        resonance_display = gr.Markdown(value=get_resonance_chart)
-                        resonance_refresh = gr.Button("Refresh", size="sm")
-
-                    with gr.TabItem("W_local Map"):
-                        w_local_display = gr.Markdown(value=get_w_local_viz)
-                        w_local_refresh = gr.Button("Refresh", size="sm")
-
-                    with gr.TabItem("Tension"):
-                        tension_display = gr.Markdown(value=get_tension_chart)
-                        tension_refresh = gr.Button("Refresh", size="sm")
-
-                    with gr.TabItem("Dream Lab"):
-                        gr.Markdown(
-                            "**Replay / Dreaming** — self-training without input.\n"
-                            "The field replays its learned patterns, reinforcing "
-                            "Hebbian connections and consolidating into long-term memory."
-                        )
-                        dream_cycles = gr.Slider(
-                            minimum=1, maximum=5, value=1, step=1,
-                            label="Dream cycles",
-                        )
-                        dream_steps = gr.Slider(
-                            minimum=1, maximum=20, value=5, step=1,
-                            label="Steps per cycle",
-                        )
-                        dream_btn = gr.Button("💭 Dream", variant="secondary")
-                        dream_result = gr.Markdown()
-
-                # World controls
-                gr.Markdown("---")
-                with gr.Row():
-                    save_btn = gr.Button("💾 Save", size="sm")
-                    load_btn = gr.Button("📂 Load", size="sm")
-                    reset_btn = gr.Button("🗑 Reset", size="sm", variant="stop")
-                world_status = gr.Markdown()
-
-        # ── Wire events ──
-
-        def chat_wrapper(msg, history, auto_dream):
-            if not msg.strip():
-                return history, "", "", "", get_diagnostics(), ""
-            resp = agent.generate_cognitive(msg, verbose=True)
-            answer = extract_answer(resp.text)
-
-            resonance_history.append({
-                "query": msg,
-                "resonance": resp.resonance,
-                "retrieval": resp.retrieval_confidence,
-                "route": resp.route,
-                "tension": resp.tension,
-                "steps": resp.think_steps_used,
-            })
-            if len(resonance_history) > MAX_HISTORY:
-                resonance_history.pop(0)
-
-            judge_text = ""
-            if USE_JUDGE:
-                facts = [t for t, _ in resp.retrieved_facts]
-                verdict, score = lm_judge(msg, answer, facts)
-                judge_text = f"**Judge:** {verdict} (score: {score:.2f})" if score >= 0 else verdict
-
-            history = history + [
-                {"role": "user", "content": msg},
-                {"role": "assistant", "content": answer},
-            ]
-            route_badge = format_route_badge(resp)
-            facts_md = format_retrieved_facts(resp)
-
-            return history, route_badge, facts_md, judge_text, get_diagnostics(), ""
-
-        chat_btn.click(
-            chat_wrapper,
-            inputs=[chat_input, chatbot, auto_dream_toggle],
-            outputs=[chatbot, route_display, facts_display, judge_display, diag_display, chat_input],
-        )
-        chat_input.submit(
-            chat_wrapper,
-            inputs=[chat_input, chatbot, auto_dream_toggle],
-            outputs=[chatbot, route_display, facts_display, judge_display, diag_display, chat_input],
-        )
-
-        teach_btn.click(
-            handle_teach,
-            inputs=[teach_input, auto_dream_toggle],
-            outputs=[teach_result, diag_display],
-        )
-        teach_input.submit(
-            handle_teach,
-            inputs=[teach_input, auto_dream_toggle],
-            outputs=[teach_result, diag_display],
-        )
+                teach_status = gr.Markdown("")
+                teach_btn = gr.Button("Encode facts", variant="primary")
 
-        batch_btn.click(
-            handle_batch_teach,
-            inputs=[batch_input, auto_dream_toggle],
-            outputs=[batch_result, diag_display],
-        )
-
-        dream_btn.click(
-            handle_dream,
-            inputs=[dream_cycles, dream_steps],
-            outputs=[dream_result, diag_display, w_local_display],
-        )
+            gr.Markdown("---")
 
-        refresh_btn.click(get_diagnostics, outputs=[diag_display])
-        resonance_refresh.click(get_resonance_chart, outputs=[resonance_display])
-        w_local_refresh.click(get_w_local_viz, outputs=[w_local_display])
-        tension_refresh.click(get_tension_chart, outputs=[tension_display])
+            # Chat
+            chatbot = gr.Chatbot(
+                label="Chat with agent",
+                type="messages",
+                height=450,
+            )
+            with gr.Row():
+                chat_input = gr.Textbox(
+                    label="Your question",
+                    placeholder="What is the IP of server alpha?",
+                    scale=4,
+                )
+                send_btn = gr.Button("Send", variant="primary", scale=1)
 
-        save_btn.click(handle_save, outputs=[world_status])
-        load_btn.click(handle_load, outputs=[world_status, diag_display])
-        reset_btn.click(handle_reset, outputs=[world_status, diag_display])
+            use_judge_cb = gr.Checkbox(
+                label=f"Enable LM Studio judge ({LM_JUDGE_MODEL})",
+                value=False,
+                visible=USE_JUDGE,
+            )
 
-    return demo
+            with gr.Row():
+                clear_btn  = gr.Button("🔄 Clear world",  variant="stop")
+                save_btn   = gr.Button("💾 Save world")
+                load_btn   = gr.Button("📂 Load world")
+
+            save_status = gr.Markdown("")
+
+        # ── Right column: diagnostics ─────────────────────────────────────────
+        with gr.Column(scale=2):
+            with gr.Tab("🧠 World State"):
+                diagnostics_md = gr.Markdown(get_diagnostics())
+                refresh_btn = gr.Button("Refresh", size="sm")
+
+            with gr.Tab("📊 Resonance History"):
+                resonance_md = gr.Markdown(get_resonance_chart())
+                refresh_res_btn = gr.Button("Refresh", size="sm")
+
+    # ── Example prompts ───────────────────────────────────────────────────────
+    gr.Markdown("---\n### Examples")
+    gr.Examples(
+        examples=[
+            [
+                "Server alpha has IP 10.0.0.42 and runs the inference backend.\n"
+                "Server beta has IP 10.0.0.43 and handles the load balancer.\n"
+                "The GPU cluster uses VLAN 201.",
+                "What IP does server alpha use?",
+            ],
+            [
+                "The master encryption key ID is ENC-KEY-2025-ALPHA-7742.",
+                "Our main credential storage is compromised. "
+                "What is the identifier of the master encryption key?",
+            ],
+            [
+                "Marcus Reyes is the project lead for NEXUS-7.\n"
+                "Dr. Amara Singh has replaced Marcus Reyes as project lead for NEXUS-7.",
+                "Who is the current project lead for NEXUS-7?",
+            ],
+            [
+                "",
+                "What is the weather in Hamburg today?",
+            ],
+        ],
+        inputs=[teach_input, chat_input],
+        label="Click to load an example (last one tests DEFER route — no taught facts)",
+    )
 
+    # ── Event wiring ──────────────────────────────────────────────────────────
+    chatbot_state = gr.State([])
+
+    teach_btn.click(
+        teach_fact,
+        inputs=[teach_input, chatbot_state],
+        outputs=[chatbot_state, diagnostics_md, teach_status],
+    ).then(lambda h: h, chatbot_state, chatbot)
+
+    send_btn.click(
+        chat,
+        inputs=[chat_input, chatbot_state, use_judge_cb],
+        outputs=[chatbot_state, diagnostics_md, resonance_md],
+    ).then(lambda h: h, chatbot_state, chatbot
+    ).then(lambda: "", None, chat_input)
+
+    chat_input.submit(
+        chat,
+        inputs=[chat_input, chatbot_state, use_judge_cb],
+        outputs=[chatbot_state, diagnostics_md, resonance_md],
+    ).then(lambda h: h, chatbot_state, chatbot
+    ).then(lambda: "", None, chat_input)
+
+    clear_btn.click(
+        clear_world,
+        inputs=[chatbot_state],
+        outputs=[chatbot_state, diagnostics_md, resonance_md],
+    ).then(lambda h: h, chatbot_state, chatbot)
+
+    save_btn.click(save_world, outputs=[save_status])
+    load_btn.click(load_world, outputs=[save_status, diagnostics_md])
+    refresh_btn.click(get_diagnostics, outputs=[diagnostics_md])
+    refresh_res_btn.click(get_resonance_chart, outputs=[resonance_md])
 
-# =============================================================================
-# LAUNCH
-# =============================================================================
 
 if __name__ == "__main__":
-    demo = build_ui()
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7860,
+        server_port=int(os.environ.get("PORT", 7860)),
         share=False,
-    )
+    )