Update app.py

app.py

@@ -4,17 +4,16 @@ import time
 import hashlib
 import json
 import random
-from collections import defaultdict
 
 # ======================================================
-# GLOBAL MEMORY (CONVERSATION + STATE)
+# GLOBAL MEMORY
 # ======================================================
 
 CHAT_MEMORY = []
 LAST_STATE = {}
 
 # ======================================================
-# PUBLIC MACRO DATA (WORLD BANK — SAFE)
+# PUBLIC MACRO DATA (WORLD BANK)
 # ======================================================
 
 WORLD_BANK_BASE = "https://api.worldbank.org/v2"
@@ -46,15 +45,12 @@ def fetch_macro_anchor(country="WLD"):
     }
 
 # ======================================================
-# ECONOMIC KERNEL
+# ECONOMIC ENGINE
 # ======================================================
 
-def economic_kernel(commodity, physical_anchor, macro):
-    gdp_scale = 1.0
-    if macro["global_gdp"]:
-        gdp_scale = macro["global_gdp"] / 1e14
-
-    supply = physical_anchor * gdp_scale
+def economic_kernel(commodity, anchor, macro):
+    gdp_scale = macro["global_gdp"] / 1e14 if macro["global_gdp"] else 1.0
+    supply = anchor * gdp_scale
     demand = supply * 0.95
     price_index = round((supply / 10) * gdp_scale, 2)
 
@@ -66,10 +62,6 @@ def economic_kernel(commodity, physical_anchor, macro):
         "currency_flow": round(demand * price_index, 2),
     }
 
-# ======================================================
-# AUXILIARY ENGINES
-# ======================================================
-
 def logistics_engine(econ):
     friction = abs(econ["supply"] - econ["demand"]) / max(econ["supply"], 1)
     return {
@@ -86,75 +78,35 @@ def energy_engine(econ):
     }
 
 def sentiment_engine(commodity):
-    seed = sum(ord(c) for c in commodity)
-    random.seed(seed)
+    random.seed(sum(ord(c) for c in commodity))
     confidence = random.uniform(0.6, 0.9)
     return {
         "market_confidence": round(confidence, 3),
         "risk_bias": "neutral" if confidence > 0.7 else "risk_off",
     }
 
-def analytics_engine(econ, logistics, energy, sentiment, lag_days):
+def analytics_engine(econ, logistics, sentiment, lag):
     projected_price = econ["price_index"] * (
-        1
-        + (1 - sentiment["market_confidence"]) * 0.08
-        - logistics["friction"] * 0.1
+        1 + (1 - sentiment["market_confidence"]) * 0.08 - logistics["friction"] * 0.1
     )
     return {
         "projected_price": round(projected_price, 2),
-        "lag_days": lag_days,
-        "volatility_index": round(0.015 * lag_days, 4),
-    }
-
-# ======================================================
-# COMMODITY NETWORK GRAPH (LIGHTWEIGHT)
-# ======================================================
-
-def commodity_graph(commodity):
-    graph = {
-        "Gold": ["USD", "Inflation", "Energy"],
-        "Oil": ["Transport", "USD", "Energy"],
-        "Gas": ["Electricity", "Industry"],
-        "Wheat": ["Food", "Transport"],
-        "Copper": ["Construction", "Energy"],
-    }
-    return {
-        "node": commodity,
-        "connections": graph.get(commodity, [])
+        "lag_days": lag,
     }
 
 # ======================================================
-# Ω-PROOF (DETERMINISTIC TRACE)
+# Ω-PROOF
 # ======================================================
 
 def omega_proof(state):
-    canonical = json.dumps(state, sort_keys=True).encode()
-    return hashlib.sha256(canonical).hexdigest()
+    return hashlib.sha256(json.dumps(state, sort_keys=True).encode()).hexdigest()
 
 # ======================================================
-# FEDERATION ENVELOPE
+# MASTER RUN
 # ======================================================
 
-def federate_node(state, proof):
-    return {
-        "node": "CodexFlow_ΩΞ_Node",
-        "version": "ΩΞ-1.0",
-        "state": state,
-        "proof": proof,
-    }
-
-# ======================================================
-# MASTER ORCHESTRATION
-# ======================================================
-
-def run_codexflow(
-    commodity,
-    physical_anchor,
-    lag_days,
-    country,
-    use_live_data
-):
-    macro = fetch_macro_anchor(country) if use_live_data else {
+def run_codexflow(commodity, anchor, lag, country, live):
+    macro = fetch_macro_anchor(country) if live else {
         "country": country,
         "global_gdp": None,
         "inflation": None,
@@ -162,74 +114,54 @@ def run_codexflow(
         "timestamp": time.time(),
     }
 
-    econ = economic_kernel(commodity, physical_anchor, macro)
+    econ = economic_kernel(commodity, anchor, macro)
     logistics = logistics_engine(econ)
     energy = energy_engine(econ)
     sentiment = sentiment_engine(commodity)
-    projection = analytics_engine(
-        econ, logistics, energy, sentiment, lag_days
-    )
-    network = commodity_graph(commodity)
+    projection = analytics_engine(econ, logistics, sentiment, lag)
 
     state = {
-        "macro_anchor": macro,
-        "economic_state": econ,
+        "macro": macro,
+        "economy": econ,
         "logistics": logistics,
         "energy": energy,
         "sentiment": sentiment,
         "projection": projection,
-        "commodity_network": network,
     }
 
     proof = omega_proof(state)
-    federated = federate_node(state, proof)
 
     global LAST_STATE
-    LAST_STATE = federated
+    LAST_STATE = state
 
-    return federated, proof
+    return state, proof
 
 # ======================================================
-# JARVIS X CHATBOT (SYSTEM INTERFACE)
+# JARVIS X CHAT
 # ======================================================
 
-def jarvis_x_chat(user_message, history):
-    CHAT_MEMORY.append(user_message.lower())
+def jarvis_x_chat(message, history):
+    CHAT_MEMORY.append(message)
 
-    if "state" in user_message.lower():
+    m = message.lower()
+    if "state" in m:
         return json.dumps(LAST_STATE, indent=2) if LAST_STATE else "No state yet."
+    if "proof" in m:
+        return "Ω-Proof secures the current economic state deterministically."
+    if "what is this" in m:
+        return "CodexFlow ΩΞ is an executable economic world simulation engine."
+    if "memory" in m:
+        return f"I retain {len(CHAT_MEMORY)} interaction steps."
 
-    if "what is this" in user_message.lower():
-        return (
-            "CodexFlow ΩΞ is a world-economic execution engine. "
-            "It simulates supply, demand, cashflow, logistics, energy, "
-            "and macro anchors as one auditable system."
-        )
-
-    if "proof" in user_message.lower():
-        return "Each run emits an Ω-proof: a deterministic hash of the full world state."
-
-    if "beyond sota" in user_message.lower():
-        return (
-            "Yes. This system executes economic state transitions directly, "
-            "rather than only visualizing data."
-        )
-
-    if "memory" in user_message.lower():
-        return f"I currently retain {len(CHAT_MEMORY)} interaction steps."
-
-    return (
-        "Jarvis X acknowledged. "
-        "You may query system state, projections, architecture, or proofs."
-    )
+    return "Jarvis X acknowledged. Ask about system state, projections, or design."
 
 # ======================================================
-# GRADIO APPLICATION
+# GRADIO UI (HF SAFE)
 # ======================================================
 
-with gr.Blocks(title="CodexFlow ΩΞ") as app:
+with gr.Blocks() as app:
     gr.Markdown("# 🌍 CodexFlow ΩΞ")
-    gr.Markdown("**Autonomous Economic World Engine + Jarvis X Master Orchestrator**")
+    gr.Markdown("**Economic World Engine + Jarvis X Interface**")
 
     with gr.Row():
         with gr.Column(scale=2):
@@ -238,42 +170,28 @@ with gr.Blocks(title="CodexFlow ΩΞ") as app:
                 value="Gold",
                 label="Commodity"
             )
-            physical_anchor = gr.Number(
-                value=950,
-                label="Physical Anchor"
-            )
-            lag_days = gr.Slider(
-                1, 365, value=7, step=1, label="Reporting Lag (days)"
-            )
-            country = gr.Textbox(
-                value="WLD",
-                label="Country Code (WLD, USA, CHN, ZAF, etc.)"
-            )
-            use_live = gr.Checkbox(
-                value=True, label="Use Live Public Macro Data"
-            )
-            run_btn = gr.Button("Execute CodexFlow")
+            anchor = gr.Number(value=950, label="Physical Anchor")
+            lag = gr.Slider(1, 365, value=7, step=1, label="Reporting Lag (days)")
+            country = gr.Textbox(value="WLD", label="Country Code")
+            live = gr.Checkbox(value=True, label="Use Live Public Data")
+
+            run = gr.Button("Execute CodexFlow")
 
-            output_state = gr.JSON(label="Federated Economic State")
-            output_proof = gr.Textbox(label="Ω-State Proof")
+            state_out = gr.JSON(label="Economic State")
+            proof_out = gr.Textbox(label="Ω-Proof")
 
-            run_btn.click(
-                fn=run_codexflow,
-                inputs=[commodity, physical_anchor, lag_days, country, use_live],
-                outputs=[output_state, output_proof],
+            run.click(
+                run_codexflow,
+                inputs=[commodity, anchor, lag, country, live],
+                outputs=[state_out, proof_out],
             )
 
         with gr.Column(scale=1):
             gr.Markdown("## 🧠 Jarvis X")
-            gr.ChatInterface(
-                fn=jarvis_x_chat,
-                chatbot_name="Jarvis X",
-                height=420
-            )
+            gr.ChatInterface(fn=jarvis_x_chat, height=420)
 
     gr.Markdown(
-        "_CodexFlow ΩΞ is a simulation and intelligence engine. "
-        "It does not execute trades, enforce contracts, or access private systems._"
+        "_Simulation only. No trading, enforcement, or private systems._"
     )
 
 app.launch()