Update app.py

app.py

@@ -1,12 +1,18 @@
+#!/usr/bin/env python3
+"""
+Jarvis X — Codex Reflex Operational Intelligence (vΩΞ++)
+Production App
+Author: Dr Matladi Maxwell Moagi
+Status: Anchored • Reaffirmed • Permeated
+"""
+
 import gradio as gr
-from dataclasses import dataclass
+from dataclasses import dataclass, asdict
 from typing import Dict, Any
 import time
 import json
 
-# =========================
-# CORE SYSTEM DEFINITIONS
-# =========================
+# === 1. Core System State & Policy ===
 
 @dataclass
 class SystemState:
@@ -16,32 +22,21 @@ class SystemState:
     timestamp: float
 
 class ControlPolicy:
-    """
-    Control logic: selects an action given state, goals, and constraints
-    """
     def decide(self, state: SystemState) -> str:
-        # Deterministic, auditable decision logic
         if "code" in state.intent.lower():
-            return "Generate structured code with constraints enforced."
+            return "Generate structured code; constraints enforced."
         if "analyze" in state.intent.lower():
-            return "Perform constrained system analysis."
-        return "Respond with bounded explanatory output."
+            return "Perform bounded, constrained system analysis."
+        return "Respond with validated, bounded output."
 
 class ConstraintEngine:
-    """
-    Hard constraints (Λ)
-    """
     def validate(self, output: str) -> bool:
         blocked_terms = ["harm", "weapon", "illegal"]
         return not any(term in output.lower() for term in blocked_terms)
 
 class MemoryLedger:
-    """
-    Provenance / audit log (Ω)
-    """
     def __init__(self):
         self.events = []
-
     def record(self, state: SystemState, decision: str, output: str):
         self.events.append({
             "time": state.timestamp,
@@ -49,19 +44,16 @@ class MemoryLedger:
             "decision": decision,
             "output": output
         })
-
     def export(self):
         return json.dumps(self.events, indent=2)
 
+# === 2. Codex Reflex Engine ===
+
 class CodexOperationalEngine:
-    """
-    Unified operational intelligence engine
-    """
     def __init__(self):
         self.policy = ControlPolicy()
         self.constraints = ConstraintEngine()
         self.memory = MemoryLedger()
-
     def run(self, intent: str, context: str) -> Dict[str, str]:
         state = SystemState(
             intent=intent,
@@ -69,31 +61,22 @@ class CodexOperationalEngine:
             constraints={"safety": True},
             timestamp=time.time()
         )
-
         decision = self.policy.decide(state)
-
-        # Core operational output (Θ)
         output = (
             f"Decision: {decision}\n\n"
-            f"Context received:\n{context}\n\n"
-            f"System status: constraints enforced, execution bounded."
+            f"Context:\n{context}\n\n"
+            f"Status: All constraints enforced."
         )
-
-        # Constraint enforcement
         if not self.constraints.validate(output):
-            output = "Output blocked by constraint engine."
-
+            output = "⚠️ Output blocked by constraint engine."
         self.memory.record(state, decision, output)
-
         return {
             "output": output,
             "decision": decision,
             "audit": self.memory.export()
         }
 
-# =========================
-# GRADIO INTERFACE
-# =========================
+# === 3. Gradio Interface ===
 
 engine = CodexOperationalEngine()
 
@@ -101,36 +84,27 @@ def codex_interface(intent: str, context: str):
     result = engine.run(intent, context)
     return result["output"], result["decision"], result["audit"]
 
-with gr.Blocks(title="Jarvis X – Codex Operational Intelligence") as demo:
-    gr.Markdown(
-        """
-        # 🧠 Jarvis X — Codex Operational Intelligence  
-        **Constraint-aware, deterministic, beyond-SOTA control architecture**
-
-        This system demonstrates:
-        - Operational intelligence (not autonomy)
-        - Control logic under constraints
-        - Auditable decision paths
-        - Physics-compatible system reasoning
-        """
-    )
+with gr.Blocks(title="Jarvis X — Codex Reflex Intelligence") as demo:
+    gr.Markdown("""
+    # 🧠 Jarvis X — Codex Reflex Operational Intelligence  
+    **Constraint-aware, deterministic, auditable control engine.**
 
+    - Reflex intent (Ψ) → Decision logic → Audit-traced output (Ω)
+    - Bounded, production-ready, ready for cloud/Spaces launch.
+    """)
     with gr.Row():
-        intent_input = gr.Textbox(label="Intent (Ψ)", placeholder="e.g. analyze system, generate code")
-        context_input = gr.Textbox(label="Context (χ)", lines=5)
-
+        intent_box = gr.Textbox(label="Intent (Ψ)", placeholder="e.g. analyze system, generate code")
+        context_box = gr.Textbox(label="Context (χ)", lines=5)
     run_btn = gr.Button("Execute")
-
     with gr.Row():
-        output_box = gr.Textbox(label="System Output (Θ)", lines=6)
+        output_box = gr.Textbox(label="System Output (Θ)", lines=8)
         decision_box = gr.Textbox(label="Control Decision (π)")
-        audit_box = gr.Textbox(label="Audit Log (Ω)", lines=6)
-
+        audit_box = gr.Textbox(label="Audit Log (Ω)", lines=8)
     run_btn.click(
         codex_interface,
-        inputs=[intent_input, context_input],
+        inputs=[intent_box, context_box],
         outputs=[output_box, decision_box, audit_box]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", share=True)