Update app.py

app.py

@@ -3,19 +3,17 @@ import requests
 import time
 import json
 import hashlib
-import random
+from collections import deque
+import numpy as np
 from typing import Dict, Any, List
 
 # ======================================================
-# GLOBAL LEDGER (in-memory for HF; can persist later)
+# CONFIG & GLOBAL STATE
 # ======================================================
 
 LEDGER: List[Dict[str, Any]] = []
 CHAT_MEMORY: List[str] = []
-
-# ======================================================
-# PUBLIC MACRO DATA (World Bank)
-# ======================================================
+OMEGA_MEMORY: deque = deque(maxlen=16)          # Causal smoothing buffer (Ω influence)
 
 WORLD_BANK_BASE = "https://api.worldbank.org/v2"
 INDICATORS = {
@@ -24,252 +22,333 @@ INDICATORS = {
     "POPULATION": "SP.POP.TOTL",
 }
 
-def fetch_indicator(indicator, country="WLD", year="2022"):
+# Simple semantic intent anchor (toy version of Θ projection target)
+INTENT_ANCHOR = {
+    "stability": 0.92,
+    "transparency": 0.88,
+    "realism": 0.85
+}
+COHERENCE_THRESHOLD = 0.65      # Below this → refusal/quarantine
+
+# ======================================================
+# WORLD BANK MACRO FETCH
+# ======================================================
+
+def fetch_indicator(indicator: str, country: str = "WLD", year: str = "2023") -> float | None:
     try:
-        url = (
-            f"{WORLD_BANK_BASE}/country/{country}/indicator/"
-            f"{indicator}?format=json&per_page=1&date={year}"
-        )
-        r = requests.get(url, timeout=8)
-        return r.json()[1][0]["value"]
+        url = f"{WORLD_BANK_BASE}/country/{country}/indicator/{indicator}?format=json&per_page=1&date={year}"
+        r = requests.get(url, timeout=7)
+        r.raise_for_status()
+        data = r.json()
+        if len(data) > 1 and data[1]:
+            return float(data[1][0].get("value", np.nan))
+        return None
     except Exception:
         return None
 
-def fetch_macro_anchor(country="WLD"):
+def fetch_macro_anchor(country: str = "WLD", use_live: bool = True) -> Dict[str, Any]:
+    if not use_live:
+        return {"country": country, "gdp": None, "inflation": None, "population": None}
+    
+    gdp = fetch_indicator(INDICATORS["GDP"], country)
+    inflation = fetch_indicator(INDICATORS["INFLATION"], country)
+    population = fetch_indicator(INDICATORS["POPULATION"], country)
+    
     return {
         "country": country,
-        "gdp": fetch_indicator(INDICATORS["GDP"], country),
-        "inflation": fetch_indicator(INDICATORS["INFLATION"], country),
-        "population": fetch_indicator(INDICATORS["POPULATION"], country),
+        "gdp": gdp if gdp is not None else np.nan,
+        "inflation": inflation if inflation is not None else np.nan,
+        "population": population if population is not None else np.nan,
     }
 
 # ======================================================
-# BIT + METADATA LAYER
+# BIT + HASH + COHERENCE LAYER
 # ======================================================
 
 def canonical_bytes(obj: Any) -> bytes:
-    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode()
+    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode('utf-8')
 
-def bit_stats(payload: Dict[str, Any]) -> Dict[str, Any]:
+def compute_bit_stats(payload: Dict) -> Dict:
     b = canonical_bytes(payload)
+    unique = len(set(b))
     return {
         "bytes": len(b),
         "bits": len(b) * 8,
-        "symbol_diversity": len(set(b)),
-        "entropy_proxy": round(len(set(b)) / max(len(b), 1), 6)
+        "symbol_diversity": unique,
+        "entropy_proxy": round(unique / max(len(b), 1), 6)
     }
 
-def hash_payload(payload: Dict[str, Any], prev_hash: str) -> str:
-    b = canonical_bytes({"payload": payload, "prev_hash": prev_hash})
-    return hashlib.sha256(b).hexdigest()
-
-def reliability_score(source: str, latency_s: float) -> float:
-    # simple, explainable scoring model (can be replaced with learned model)
-    base = 0.85 if source == "world_bank" else 0.65
-    penalty = min(0.25, latency_s / 20.0)
-    return round(max(0.1, base - penalty), 3)
+def hash_record(payload: Dict, prev_hash: str) -> str:
+    data = {"payload": payload, "prev_hash": prev_hash}
+    return hashlib.sha256(canonical_bytes(data)).hexdigest()
+
+def compute_coherence_score(values_dict: Dict[str, float]) -> float:
+    """Very simple toy coherence metric (closer to intent anchor = higher score)"""
+    if not values_dict:
+        return 0.0
+    
+    scores = []
+    for k, target in INTENT_ANCHOR.items():
+        if k in values_dict and not np.isnan(values_dict[k]):
+            val = values_dict[k]
+            norm_diff = min(1.0, abs(val - target) / max(abs(target), 0.01))
+            scores.append(1.0 - norm_diff)
+    
+    return round(np.mean(scores) if scores else 0.5, 4)
+
+def omega_smooth(key: str, new_value: float) -> float:
+    """Simple EMA style smoothing (early Ω influence)"""
+    if not OMEGA_MEMORY:
+        OMEGA_MEMORY.append({key: new_value})
+        return new_value
+    
+    prev = OMEGA_MEMORY[-1].get(key, new_value)
+    alpha = 0.3
+    smoothed = alpha * new_value + (1 - alpha) * prev
+    OMEGA_MEMORY.append({key: smoothed})
+    return round(smoothed, 6)
 
 # ======================================================
-# SIGNAL GENERATORS (global “bit rails”)
+# SIGNAL GENERATORS (now with smoothing)
 # ======================================================
 
-def commodity_signal(commodity: str, anchor: float, macro: Dict[str, Any]) -> Dict[str, Any]:
-    gdp_scale = (macro["gdp"] / 1e14) if macro.get("gdp") else 1.0
+def commodity_signal(commodity: str, anchor: float, macro: Dict) -> Dict:
+    gdp_scale = macro.get("gdp", 1e14) / 1e14 if macro.get("gdp") else 1.0
     supply = anchor * gdp_scale
-    demand = supply * 0.95
-    price_index = round((supply / 10.0) * gdp_scale, 4)
+    demand = supply * 0.94
+    price_index = round((supply / 12.0) * gdp_scale, 4)
+    
+    smoothed_price = omega_smooth("price_index", price_index)
+    
     return {
         "type": "commodity",
         "commodity": commodity,
         "supply": round(supply, 4),
         "demand": round(demand, 4),
-        "price_index": price_index,
-        "currency_flow": round(demand * price_index, 4),
+        "price_index": smoothed_price,
+        "currency_flow": round(demand * smoothed_price, 4),
     }
 
-def logistics_signal(econ: Dict[str, Any]) -> Dict[str, Any]:
+def logistics_signal(econ: Dict) -> Dict:
     friction = abs(econ["supply"] - econ["demand"]) / max(econ["supply"], 1e-9)
-    return {
-        "type": "logistics",
-        "throughput": round(econ["supply"] * (1 - friction), 4),
-        "friction": round(friction, 6),
-    }
+    return {"type": "logistics", "friction": round(friction, 6)}
 
-def energy_signal(econ: Dict[str, Any]) -> Dict[str, Any]:
+def energy_signal(econ: Dict) -> Dict:
     return {
         "type": "energy",
-        "energy_cost_index": round(econ["price_index"] * 0.4, 4),
-        "dependency": "high" if econ["commodity"].lower() in ["oil", "gas"] else "moderate",
+        "energy_cost_index": round(econ["price_index"] * 0.42, 4),
+        "dependency": "high" if "oil" in econ["commodity"].lower() or "gas" in econ["commodity"].lower() else "moderate"
     }
 
-def sentiment_signal(seed_key: str) -> Dict[str, Any]:
-    random.seed(sum(ord(c) for c in seed_key))
-    confidence = random.uniform(0.6, 0.9)
+def sentiment_signal(seed: str) -> Dict:
+    import random
+    random.seed(sum(ord(c) for c in seed + str(time.time())[:8]))
+    conf = random.uniform(0.62, 0.91)
     return {
         "type": "sentiment",
-        "market_confidence": round(confidence, 6),
-        "risk_bias": "neutral" if confidence > 0.7 else "risk_off",
-    }
-
-def derived_features(econ, logi, energy, sent, lag_days: int) -> Dict[str, Any]:
-    projected_price = econ["price_index"] * (
-        1 + (1 - sent["market_confidence"]) * 0.08 - logi["friction"] * 0.1
-    )
-    return {
-        "type": "features",
-        "lag_days": lag_days,
-        "projected_price": round(projected_price, 6),
-        "volatility_proxy": round(0.015 * lag_days, 6),
+        "market_confidence": round(omega_smooth("confidence", conf), 6)
     }
 
 # ======================================================
-# LEDGER APPEND (global bit+metadata record)
+# LEDGER OPERATIONS
 # ======================================================
 
-def append_record(payload: Dict[str, Any], meta: Dict[str, Any]) -> Dict[str, Any]:
-    prev = LEDGER[-1]["hash"] if LEDGER else "GENESIS"
-    h = hash_payload(payload, prev)
+def append_to_ledger(payload: Dict, meta: Dict, coherence: float) -> Dict | None:
+    if coherence < COHERENCE_THRESHOLD:
+        return {
+            "status": "refused",
+            "reason": f"Coherence too low: {coherence:.4f} < {COHERENCE_THRESHOLD}",
+            "payload": payload
+        }
+    
+    prev_hash = LEDGER[-1]["hash"] if LEDGER else "GENESIS"
+    record_hash = hash_record(payload, prev_hash)
+    
     record = {
-        "hash": h,
-        "prev_hash": prev,
+        "hash": record_hash,
+        "prev_hash": prev_hash,
         "payload": payload,
-        "metadata": meta,
-        "bit_stats": bit_stats(payload),
+        "metadata": {**meta, "coherence_score": coherence},
+        "bit_stats": compute_bit_stats(payload),
         "ts": time.time(),
     }
+    
     LEDGER.append(record)
     return record
 
 def run_tick(commodity: str, anchor: float, country: str, lag_days: int, use_live: bool):
     t0 = time.time()
-
-    macro = fetch_macro_anchor(country) if use_live else {"country": country, "gdp": None, "inflation": None, "population": None}
+    
+    macro = fetch_macro_anchor(country, use_live)
     latency = time.time() - t0
-
-    # 1) macro record
+    
     meta_macro = {
-        "source": "world_bank" if use_live else "synthetic",
+        "source": "world_bank" if use_live and macro["gdp"] is not None else "synthetic",
         "country": country,
         "latency_s": round(latency, 4),
-        "reliability": reliability_score("world_bank" if use_live else "synthetic", latency),
-        "schema": "macro.v1",
+        "schema": "macro.v1"
     }
-    append_record({"type": "macro", **macro}, meta_macro)
-
-    # 2) derived signals
+    
+    # Macro coherence (very basic)
+    macro_coherence = compute_coherence_score({
+        "stability": 1.0 - abs(macro.get("inflation", 0))/10,
+        "realism": 1.0 if macro.get("gdp") is not None else 0.4
+    })
+    
+    macro_record = append_to_ledger({"type": "macro", **macro}, meta_macro, macro_coherence)
+    if macro_record and "status" in macro_record and macro_record["status"] == "refused":
+        return {"status": "macro_refused", "detail": macro_record}, None
+    
+    # Derived signals
     econ = commodity_signal(commodity, anchor, macro)
     logi = logistics_signal(econ)
     ener = energy_signal(econ)
-    sent = sentiment_signal(commodity + country)
-    feat = derived_features(econ, logi, ener, sent, lag_days)
-
+    sent = sentiment_signal(commodity + country + str(int(time.time())))
+    
+    feat = {
+        "type": "features",
+        "lag_days": lag_days,
+        "projected_price": round(econ["price_index"] * (1 + (1 - sent["market_confidence"]) * 0.07), 6),
+        "volatility_proxy": round(0.012 * lag_days, 6)
+    }
+    
+    results = []
     for payload, schema in [
         (econ, "commodity.v1"),
         (logi, "logistics.v1"),
         (ener, "energy.v1"),
         (sent, "sentiment.v1"),
-        (feat, "features.v1"),
+        (feat, "features.v1")
     ]:
+        coherence = compute_coherence_score({
+            "stability": 1.0 - abs(logi["friction"]),
+            "transparency": sent["market_confidence"]
+        })
+        
         meta = {
             "source": "derived",
-            "country": country,
-            "latency_s": 0.0,
-            "reliability": 0.9,
             "schema": schema,
+            "coherence_score": coherence
         }
-        append_record(payload, meta)
-
+        rec = append_to_ledger(payload, meta, coherence)
+        if rec:
+            results.append(rec)
+    
+    tip = LEDGER[-1] if LEDGER else None
     return {
-        "status": "tick_ok",
-        "ledger_len": len(LEDGER),
-        "tip_hash": LEDGER[-1]["hash"],
-        "latest_macro": macro,
-        "latest_features": feat,
-    }, LEDGER[-1]["hash"]
-
-def query_ledger(n: int):
-    n = max(1, min(int(n), 200))
-    return LEDGER[-n:]
+        "status": "tick_complete",
+        "ledger_length": len(LEDGER),
+        "tip_hash": tip["hash"] if tip else None,
+        "latest_coherence": tip["metadata"].get("coherence_score") if tip else None,
+        "records_added": len(results)
+    }, tip["hash"] if tip else None
 
 # ======================================================
-# CHAT INTERFACE (queries the ledger)
+# CHAT INTERFACE - Jarvis X (enhanced awareness)
 # ======================================================
 
-def jarvis_chat(msg, history):
-    CHAT_MEMORY.append(msg)
-    m = msg.lower().strip()
-
-    if "latest" in m or "tip" in m:
-        if not LEDGER:
-            return "Ledger is empty. Run a tick first."
-        r = LEDGER[-1]
-        return json.dumps({"tip_hash": r["hash"], "payload": r["payload"], "metadata": r["metadata"]}, indent=2)
-
-    if "ledger" in m or "records" in m:
-        return f"Ledger records: {len(LEDGER)}. Ask 'latest' or 'show last 10'."
-
-    if "show last" in m:
-        try:
-            k = int(m.split("show last")[-1].strip())
-        except Exception:
-            k = 10
-        data = query_ledger(k)
-        return json.dumps(data, indent=2)
-
-    if "proof" in m or "hash" in m:
-        if not LEDGER:
-            return "No proof yet. Run a tick to generate chained hashes."
-        return f"Tip hash: {LEDGER[-1]['hash']} (prev: {LEDGER[-1]['prev_hash']})"
-
-    if "what is this" in m:
-        return (
-            "This is GVBDMS v1: a Global Virtual Bit + Metadata Ledger. "
-            "It ingests public anchors, derives signals, stores payload+metadata, "
-            "and chains records with hashes for tamper-evident provenance."
-        )
-
-    return "Ask: 'latest', 'proof', 'show last 10', or run a tick to ingest data."
+def jarvis_x_chat(message: str, history: List):
+    CHAT_MEMORY.append(message)
+    m = message.lower().strip()
+    
+    if not LEDGER:
+        return "The ledger is still in genesis state. Please run a tick first.", history
+    
+    tip = LEDGER[-1]
+    
+    if any(k in m for k in ["latest", "tip", "current"]):
+        return json.dumps({
+            "tip_hash": tip["hash"],
+            "prev_hash": tip["prev_hash"],
+            "coherence": tip["metadata"].get("coherence_score", "N/A"),
+            "type": tip["payload"].get("type"),
+            "timestamp": time.ctime(tip["ts"])
+        }, indent=2), history
+    
+    if "ledger" in m or "size" in m:
+        return f"Current ledger contains {len(LEDGER)} records. Average coherence: {np.mean([r['metadata'].get('coherence_score',0) for r in LEDGER]):.4f}", history
+    
+    if "coherence" in m or "health" in m:
+        coherences = [r["metadata"].get("coherence_score", 0) for r in LEDGER[-12:]]
+        return f"Recent coherence trend (last {len(coherences)}): {coherences}\nAverage: {np.mean(coherences):.4f}", history
+    
+    if "refused" in m or "rejected" in m:
+        refused = [r for r in LEDGER if r["metadata"].get("coherence_score", 1) < COHERENCE_THRESHOLD]
+        return f"{len(refused)} records were refused due to low coherence.", history
+    
+    return (
+        "Jarvis X online. Available commands:\n"
+        "• latest / tip\n"
+        "• ledger / size\n"
+        "• coherence / health\n"
+        "• refused / rejected\n\n"
+        "The manifold is permeating... speak your intent."
+    ), history
 
 # ======================================================
-# GRADIO UI (HF SAFE)
+# GRADIO INTERFACE
 # ======================================================
 
-with gr.Blocks() as app:
-    gr.Markdown("# 🌐 CodexFlow — Global Virtual Bit + Metadata System (GVBDMS v1)")
-    gr.Markdown("A byte-verifiable, provenance-tracked ledger for global economic signals.")
+css = """
+.gradio-container {font-family: 'Segoe UI', system-ui;}
+.header {text-align: center; padding: 1rem; background: linear-gradient(90deg, #1e3a8a, #3b82f6);}
+"""
 
+with gr.Blocks(css=css) as app:
+    gr.Markdown(
+        """
+        # 🌌 CodexFlow • IRE Permeation Engine
+        **Global Virtual Bit + Metadata System with Early Semantic Coherence Enforcement**  
+        _January 11, 2026 — Beyond SOTA prototype_
+        """,
+        elem_classes="header"
+    )
+    
     with gr.Row():
         with gr.Column(scale=2):
-            commodity = gr.Dropdown(["Gold","Oil","Gas","Wheat","Copper"], value="Gold", label="Commodity")
-            anchor = gr.Number(value=950, label="Physical Anchor")
-            country = gr.Textbox(value="WLD", label="Country Code (WLD/USA/CHN/ZAF...)")
-            lag = gr.Slider(1, 365, value=7, step=1, label="Reporting Lag (days)")
-            live = gr.Checkbox(value=True, label="Use Live World Bank Anchors")
-
-            run_btn = gr.Button("Run Tick (Ingest + Derive + Ledger Append)")
-
-            tick_out = gr.JSON(label="Tick Result")
-            tip_hash = gr.Textbox(label="Tip Hash")
-
+            gr.Markdown("### Data Ingestion & Tick Controls")
+            
+            with gr.Row():
+                commodity = gr.Dropdown(
+                    choices=["Gold", "Oil", "Gas", "Wheat", "Copper", "Lithium"],
+                    value="Gold",
+                    label="Commodity"
+                )
+                anchor = gr.Number(value=1200, label="Physical Anchor (tons/price unit)")
+            
+            with gr.Row():
+                country = gr.Textbox(value="WLD", label="Country Code (WLD = World)")
+                live_data = gr.Checkbox(value=True, label="Use Live World Bank Data")
+                lag_days = gr.Slider(1, 180, value=7, step=1, label="Lag (days)")
+            
+            run_btn = gr.Button("Run Tick → Permeate Ledger", variant="primary")
+            
+            tick_result = gr.JSON(label="Tick Result")
+            current_tip = gr.Textbox(label="Current Tip Hash", interactive=False)
+            
             run_btn.click(
                 fn=run_tick,
-                inputs=[commodity, anchor, country, lag, live],
-                outputs=[tick_out, tip_hash],
+                inputs=[commodity, anchor, country, lag_days, live_data],
+                outputs=[tick_result, current_tip]
             )
-
-            n = gr.Slider(1, 200, value=20, step=1, label="Query last N records")
-            q_btn = gr.Button("Query Ledger")
-            ledger_out = gr.JSON(label="Ledger Records (last N)")
-
-            q_btn.click(fn=query_ledger, inputs=[n], outputs=[ledger_out])
-
+        
         with gr.Column(scale=1):
-            gr.Markdown("## 🧠 Jarvis X — Ledger Interface")
-            gr.ChatInterface(fn=jarvis_chat, height=420)
+            gr.Markdown("### Jarvis X • Manifold Interface")
+            chat = gr.ChatInterface(
+                fn=jarvis_x_chat,
+                chatbot=gr.Chatbot(height=380),
+                title="Jarvis X Resonance",
+                description="Query the manifold state • coherence • provenance"
+            )
 
     gr.Markdown(
-        "_GVBDMS stores public/derived signals with metadata & hash chaining. "
-        "It is not a trading system, bank interface, or contract enforcer._"
+        """
+        ---
+        **Status**: Early IRE permeation • Λ constraint stub • Ω memory smoothing  
+        **Coherence threshold**: 0.65 • Records refused below this level are quarantined  
+        *Not financial advice — research & provenance-first prototype*
+        """
     )
 
-app.launch()
+if __name__ == "__main__":
+    app.launch()