Update app.py

app.py

@@ -1,176 +1,324 @@
 # app.py
-"""
-Dr Moagi IRE Equation • Autonomous Manifold Explorer
-Minimal autonomous simulation of the sealed governing equation
-dΞ/dt = -Λ ∇(Θ(Ξ) + Φ(Ξ) - Ψ(t) + Ω(t))
-
-Hugging Face Spaces demo - January 11, 2026
-"""
+# CodexFlow / GVBDMS v3 • January 11, 2026
+# Persistent provenance ledger + first gentle IRE influence (coherence check + Ω smoothing)
 
 import gradio as gr
-import torch
+import requests
+import time
+import json
+import hashlib
+import sqlite3
 import numpy as np
-import matplotlib.pyplot as plt
-from io import BytesIO
-import base64
-
-# ─── Configuration ────────────────────────────────────────────────
-DEFAULT_PARAMS = {
-    'steps': 600,
-    'dt': 0.075,
-    'noise': 0.38,
-    'lambda_': 3.4,
-    'omega_window': 14,
-    'intent_x': 2.1,
-    'intent_y': 1.4
+from typing import Dict, Any, List, Optional, Tuple
+from collections import deque
+
+# ──────────────────────────────────────────────────────────────
+# CONFIGURATION
+# ──────────────────────────────────────────────────────────────
+
+DB_PATH = "codexflow_gvbdms_v3.db"
+WORLD_BANK_BASE = "https://api.worldbank.org/v2"
+DEFAULT_YEAR = "2023"
+
+INDICATORS = {
+    "GDP": "NY.GDP.MKTP.CD",
+    "INFLATION": "FP.CPI.TOTL.ZG",
+    "POPULATION": "SP.POP.TOTL",
 }
 
-COHERENCE_WARN = 0.68
+# Very simple toy intent anchor for first coherence check
+INTENT_ANCHOR = {"stability": 0.92, "transparency": 0.88}
+COHERENCE_THRESHOLD = 0.65      # records below this are refused
 
-# ─── Core Simulation ──────────────────────────────────────────────
-def run_ire_simulation(steps, dt, noise_mag, lam, omega_len, intent):
-    device = torch.device("cpu")
-    
-    intent_target = torch.tensor([intent[0], intent[1]], dtype=torch.float32, device=device)
-    
-    Xi = torch.zeros(2, device=device, requires_grad=True)
-    Omega = []
-    trajectory = [Xi.detach().cpu().numpy().copy()]
+OMEGA_MEMORY = deque(maxlen=8)  # very light causal smoothing buffer
 
-    for step in range(steps):
-        t = step * dt
+# ──────────────────────────────────────────────────────────────
+# DATABASE LAYER
+# ──────────────────────────────────────────────────────────────
 
-        # Potential terms (toy implementations)
-        theta = 0.45 * (intent_target - Xi).pow(2).sum()
-        phi   = 0.28 * torch.sin(3.2 * torch.atan2(Xi[1], Xi[0])) * torch.cos(1.8 * Xi.norm()) + 0.15 * Xi.norm()**2
-        psi   = torch.randn(2, device=device) * noise_mag * (1.0 + 0.35 * torch.sin(t * 0.14))
-        omega_mean = torch.mean(torch.stack(Omega), dim=0) if Omega else torch.zeros(2, device=device)
+def init_db():
+    with sqlite3.connect(DB_PATH) as con:
+        cur = con.cursor()
+        cur.execute("""
+        CREATE TABLE IF NOT EXISTS records (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ts REAL NOT NULL,
+            hash TEXT UNIQUE NOT NULL,
+            prev_hash TEXT NOT NULL,
+            schema TEXT NOT NULL,
+            country TEXT NOT NULL,
+            source TEXT NOT NULL,
+            reliability REAL NOT NULL,
+            latency_s REAL NOT NULL,
+            payload_json TEXT NOT NULL,
+            metadata_json TEXT NOT NULL,
+            coherence_score REAL,
+            bytes INTEGER NOT NULL,
+            entropy_proxy REAL NOT NULL
+        )
+        """)
+        cur.execute("CREATE INDEX IF NOT EXISTS idx_schema_country ON records(schema, country)")
+        cur.execute("CREATE INDEX IF NOT EXISTS idx_ts ON records(ts)")
+    print("Database initialized.")
 
-        potential = theta + phi - psi + omega_mean
+init_db()
 
-        grad = torch.autograd.grad(potential, Xi, create_graph=False)[0]
-        dXi = -lam * grad
+def get_tip_hash() -> str:
+    with sqlite3.connect(DB_PATH) as con:
+        cur = con.cursor()
+        cur.execute("SELECT hash FROM records ORDER BY id DESC LIMIT 1")
+        row = cur.fetchone()
+    return row[0] if row else "GENESIS"
 
-        Xi = Xi + dt * dXi
-        Xi = Xi.detach().requires_grad_(True)
+def insert_record(rec: Dict) -> bool:
+    try:
+        with sqlite3.connect(DB_PATH) as con:
+            cur = con.cursor()
+            cur.execute("""
+                INSERT INTO records (
+                    ts, hash, prev_hash, schema, country, source, reliability, latency_s,
+                    payload_json, metadata_json, coherence_score, bytes, entropy_proxy
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                rec["ts"], rec["hash"], rec["prev_hash"], rec["schema"], rec["country"],
+                rec["source"], rec["reliability"], rec["latency_s"],
+                rec["payload_json"], rec["metadata_json"], rec.get("coherence_score"),
+                rec["bytes"], rec["entropy_proxy"]
+            ))
+        return True
+    except sqlite3.IntegrityError:
+        return False  # duplicate hash
 
-        Omega.append(Xi.detach().clone())
-        if len(Omega) > omega_len:
-            Omega.pop(0)
+# ──────────────────────────────────────────────────────────────
+# UTILITIES
+# ──────────────────────────────────────────────────────────────
 
-        trajectory.append(Xi.detach().cpu().numpy().copy())
+def canonical_bytes(obj: Any) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode('utf-8')
 
-    return np.array(trajectory)
+def compute_bit_stats(payload: Dict) -> Tuple[int, float]:
+    b = canonical_bytes(payload)
+    n = len(b)
+    return n, round(len(set(b)) / max(n, 1), 6)
 
+def hash_chain(payload: Dict, prev: str) -> str:
+    return hashlib.sha256(canonical_bytes({"payload": payload, "prev": prev})).hexdigest()
 
-def create_plot(traj, intent, lam, noise, steps):
-    fig, ax = plt.subplots(figsize=(8, 7.2), dpi=100)
-    
-    ax.plot(traj[:,0], traj[:,1], 'royalblue', lw=1.3, alpha=0.85, label='trajectory')
-    ax.plot(traj[0,0],  traj[0,1],  'o', ms=10, mec='k', mfc='#00ff9d', label='birth')
-    ax.plot(traj[-1,0], traj[-1,1], 'o', ms=12, mec='k', mfc='#ff3366',  label='present')
+def toy_coherence_score(values: Dict[str, float]) -> float:
+    """Extremely simple first coherence proxy against intent anchor"""
+    scores = []
+    for k, target in INTENT_ANCHOR.items():
+        v = values.get(k)
+        if v is not None:
+            diff = abs(v - target) / max(abs(target), 0.01)
+            scores.append(max(0.0, 1.0 - min(1.0, diff)))
+    return round(np.mean(scores) if scores else 0.5, 4)
 
-    ax.scatter(intent[0], intent[1], s=320, c='gold', marker='*',
-               edgecolor='navy', lw=2, label='semantic intent target')
+def omega_smooth(key: str, value: float) -> float:
+    if not OMEGA_MEMORY:
+        OMEGA_MEMORY.append({key: value})
+        return value
+    prev = OMEGA_MEMORY[-1].get(key, value)
+    smoothed = 0.25 * value + 0.75 * prev
+    OMEGA_MEMORY.append({key: smoothed})
+    return round(smoothed, 6)
 
-    # Coherence estimate
-    final_dist = np.linalg.norm(traj[-1] - np.array(intent))
-    coh = max(0.0, 1.0 - final_dist / 4.8)
-    coh_text = f"Coherence: {coh:.3f}"
-    if coh < COHERENCE_WARN:
-        coh_text += "  ⚠ drifting"
+# ──────────────────────────────────────────────────────────────
+# DATA INGEST & SIGNAL GENERATION
+# ──────────────────────────────────────────────────────────────
 
-    ax.set_title(
-        f"IRE Autonomous Manifold Evolution\n"
-        f"Λ = {lam:.2f} • noise = {noise:.2f} • steps = {steps}\n"
-        f"{coh_text}",
-        fontsize=13, pad=15
-    )
-    
-    ax.set_xlabel("Semantic Dimension 1", fontsize=11)
-    ax.set_ylabel("Semantic Dimension 2", fontsize=11)
-    ax.grid(True, alpha=0.15, linestyle='--')
-    ax.legend(loc='upper right', fontsize=9, framealpha=0.92)
-    ax.set_aspect('equal')
-    ax.set_facecolor('#f8f9fa')
-
-    buf = BytesIO()
-    plt.savefig(buf, format='png', bbox_inches='tight', dpi=120)
-    buf.seek(0)
-    img_base64 = base64.b64encode(buf.read()).decode('ascii')
-    plt.close(fig)
-
-    return f"data:image/png;base64,{img_base64}"
-
-
-# ─── Gradio Interface ─────────────────────────────────────────────
-with gr.Blocks(title="IRE Equation • Autonomous Manifold") as demo:
-    gr.Markdown(
-        """
-        # Dr Moagi IRE Equation  
-        **Autonomous Semantic Manifold Explorer**  
-        *Minimal canonical implementation — January 11, 2026*
-        
-        dΞ/dt = −Λ ∇(Θ(Ξ) + Φ(Ξ) − Ψ(t) + Ω(t))
-        """
+def fetch_macro(country: str, year: str) -> Dict:
+    result = {"type": "macro", "country": country, "year": year}
+    t0 = time.time()
+    for name, code in INDICATORS.items():
+        try:
+            r = requests.get(
+                f"{WORLD_BANK_BASE}/country/{country}/indicator/{code}?format=json&date={year}&per_page=1",
+                timeout=7
+            ).json()
+            result[name.lower()] = r[1][0]["value"] if len(r) > 1 and r[1] else None
+        except:
+            result[name.lower()] = None
+    latency = time.time() - t0
+    return result, latency
+
+def generate_signals(commodity: str, anchor: float, macro: Dict, lag_days: int) -> List[Tuple[Dict, str]]:
+    gdp_scale = macro.get("gdp", 1e14) / 1e14 if macro.get("gdp") else 1.0
+    supply = anchor * gdp_scale
+    price = omega_smooth("price_index", round((supply / 11.0) * gdp_scale, 6))
+
+    econ = {
+        "type": "commodity",
+        "commodity": commodity,
+        "supply": round(supply, 4),
+        "demand": round(supply * 0.95, 4),
+        "price_index": price,
+        "flow": round(supply * 0.95 * price, 4)
+    }
+
+    friction = abs(econ["supply"] - econ["demand"]) / max(econ["supply"], 1e-9)
+    logi = {"type": "logistics", "friction": round(friction, 6)}
+
+    ener = {"type": "energy", "cost_index": round(price * 0.42, 4),
+            "dependency": "high" if commodity.lower() in ["oil","gas"] else "moderate"}
+
+    sent = {"type": "sentiment", "confidence": omega_smooth("confidence", np.random.uniform(0.62, 0.91))}
+
+    feat = {
+        "type": "features",
+        "lag_days": lag_days,
+        "projected_price": round(price * (1 + (1 - sent["confidence"]) * 0.07), 6),
+        "volatility": round(0.012 * lag_days, 6)
+    }
+
+    return [(econ, "commodity.v1"), (logi, "logistics.v1"), (ener, "energy.v1"),
+            (sent, "sentiment.v1"), (feat, "features.v1")]
+
+# ──────────────────────────────────────────────────────────────
+# CORE TICK FUNCTION (with coherence refusal)
+# ──────────────────────────────────────────────────────────────
+
+def run_tick(commodity: str, anchor: float, country: str, lag_days: int, use_live: bool, year: str):
+    macro, latency = fetch_macro(country, year) if use_live else (
+        {"type": "macro", "country": country, "year": year, "gdp": None, "inflation": None, "population": None}, 0.0
     )
 
+    macro_coh = toy_coherence_score({
+        "stability": 1.0 - abs(macro.get("inflation", 0) or 0) / 10,
+    })
+
+    if macro_coh < COHERENCE_THRESHOLD:
+        return {"status": "refused", "reason": f"Macro coherence too low: {macro_coh:.3f}", "tip": get_tip_hash()}, None
+
+    macro_rec = {
+        "ts": time.time(),
+        "hash": hash_chain(macro, get_tip_hash()),
+        "prev_hash": get_tip_hash(),
+        "schema": "macro.v1",
+        "country": country,
+        "source": "world_bank" if use_live else "synthetic",
+        "reliability": 0.88 if use_live else 0.65,
+        "latency_s": round(latency, 4),
+        "payload_json": json.dumps(macro, sort_keys=True),
+        "metadata_json": json.dumps({"note": "anchor ingest"}, sort_keys=True),
+        "coherence_score": macro_coh,
+        "bytes": len(canonical_bytes(macro)),
+        "entropy_proxy": compute_bit_stats(macro)[1]
+    }
+
+    if not insert_record(macro_rec):
+        return {"status": "error", "reason": "duplicate hash"}, None
+
+    signals = generate_signals(commodity, anchor, macro, lag_days)
+    added = 0
+
+    for payload, schema in signals:
+        coh = toy_coherence_score({"stability": 1.0 - payload.get("friction", 0)})
+        if coh < COHERENCE_THRESHOLD:
+            continue  # refuse low-coherence derived signal
+
+        rec = {
+            "ts": time.time(),
+            "hash": hash_chain(payload, get_tip_hash()),
+            "prev_hash": get_tip_hash(),
+            "schema": schema,
+            "country": country,
+            "source": "derived",
+            "reliability": 0.92,
+            "latency_s": 0.0,
+            "payload_json": json.dumps(payload, sort_keys=True),
+            "metadata_json": json.dumps({"linked_macro": macro_rec["hash"]}, sort_keys=True),
+            "coherence_score": coh,
+            "bytes": len(canonical_bytes(payload)),
+            "entropy_proxy": compute_bit_stats(payload)[1]
+        }
+
+        if insert_record(rec):
+            added += 1
+
+    tip = get_tip_hash()
+    return {
+        "status": "ok",
+        "added": added,
+        "tip_hash": tip,
+        "macro_coherence": macro_coh
+    }, tip
+
+# ──────────────────────────────────────────────────────────────
+# QUERY & CHAT
+# ──────────────────────────────────────────────────────────────
+
+def query_records(limit: int = 50, schema: str = "ANY", country: str = "ANY") -> List[Dict]:
+    limit = max(1, min(int(limit), 300))
+    with sqlite3.connect(DB_PATH) as con:
+        cur = con.cursor()
+        where = []
+        params = []
+        if schema != "ANY":
+            where.append("schema = ?")
+            params.append(schema)
+        if country != "ANY":
+            where.append("country = ?")
+            params.append(country)
+
+        sql = "SELECT ts, hash, prev_hash, schema, country, coherence_score FROM records"
+        if where:
+            sql += " WHERE " + " AND ".join(where)
+        sql += " ORDER BY id DESC LIMIT ?"
+        params.append(limit)
+
+        cur.execute(sql, params)
+        rows = cur.fetchall()
+
+    return [{"ts": r[0], "hash": r[1], "prev": r[2], "schema": r[3], "country": r[4], "coherence": r[5]} for r in rows]
+
+def jarvis(message: str, history):
+    m = message.lower().strip()
+    if "latest" in m or "tip" in m:
+        recs = query_records(1)
+        return json.dumps(recs[0] if recs else {"status": "empty"}, indent=2)
+    if "coherence" in m:
+        recs = query_records(20)
+        coh_values = [r["coherence"] for r in recs if r["coherence"] is not None]
+        return f"Recent coherence (last {len(coh_values)}): mean = {np.mean(coh_values):.3f}" if coh_values else "No coherence data yet"
+    return "Commands: latest, tip, coherence"
+
+# ──────────────────────────────────────────────────────────────
+# GRADIO INTERFACE
+# ──────────────────────────────────────────────────────────────
+
+with gr.Blocks(title="CodexFlow v3 • IRE Influence") as app:
+    gr.Markdown("# CodexFlow v3 • Provenance Ledger + First IRE Touch")
+    gr.Markdown("SQLite • Hash chain • Bit stats • Simple coherence refusal & smoothing")
+
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Control Parameters")
-
-            steps = gr.Slider(200, 1500, value=DEFAULT_PARAMS['steps'], 
-                             step=50, label="Simulation steps")
-            
-            noise = gr.Slider(0.00, 1.20, value=DEFAULT_PARAMS['noise'], 
-                             step=0.02, label="External noise strength (Ψ)")
-            
-            lam = gr.Slider(0.5, 10.0, value=DEFAULT_PARAMS['lambda_'], 
-                           step=0.1, label="Constraint strength (Λ)")
-            
-            intent_x = gr.Number(value=DEFAULT_PARAMS['intent_x'], 
-                                label="Intent target X")
-            intent_y = gr.Number(value=DEFAULT_PARAMS['intent_y'], 
-                                label="Intent target Y")
-
-            run_btn = gr.Button("Run Autonomous Evolution", variant="primary")
-
-        with gr.Column(scale=3):
-            output_image = gr.Image(label="Manifold Trajectory", type="filepath")
-            gr.Markdown(
-                """
-                **Legend**  
-                • Green circle → starting point  
-                • Red circle → current position  
-                • Gold star → semantic intent attractor  
-                • Blue path → autonomous trajectory under the sealed equation
-                
-                Higher Λ → stronger law & refusal of drift  
-                Higher noise → more chaotic external pressure
-                """
-            )
-
-    # Footer explanation
-    gr.Markdown(
-        """
-        ---
-        **Current status**: 2D toy prototype • pure mathematical core  
-        • constraint-dominant flow • causal memory smoothing • stochastic reality pressure  
-        • No language, no high dimensions, no external data — only the law breathing
-        """
-    )
+        with gr.Column(scale=2):
+            comm = gr.Dropdown(["Gold","Oil","Gas","Wheat","Copper"], "Gold", label="Commodity")
+            anch = gr.Number(950, label="Anchor")
+            cntry = gr.Textbox("WLD", label="Country")
+            lag_d = gr.Slider(1, 365, 7, label="Lag days")
+            yr = gr.Textbox(DEFAULT_YEAR, label="Year")
+            live = gr.Checkbox(True, label="Live World Bank")
 
-    def on_run(steps, noise, lam, ix, iy):
-        traj = run_ire_simulation(steps, DEFAULT_PARAMS['dt'], noise, lam, 
-                                 DEFAULT_PARAMS['omega_window'], (ix, iy))
-        img = create_plot(traj, (ix, iy), lam, noise, steps)
-        return img
+            btn = gr.Button("Run Tick", variant="primary")
+            res = gr.JSON(label="Result")
+            tip = gr.Textbox(label="Tip Hash", interactive=False)
 
-    run_btn.click(
-        on_run,
-        inputs=[steps, noise, lam, intent_x, intent_y],
-        outputs=output_image
-    )
+            btn.click(run_tick, [comm, anch, cntry, lag_d, live, yr], [res, tip])
+
+            gr.Markdown("### Query")
+            lim = gr.Slider(5, 200, 30, label="Limit")
+            sch = gr.Dropdown(["ANY", "macro.v1", "commodity.v1", "features.v1"], "ANY", label="Schema")
+            qry_btn = gr.Button("Query")
+            out = gr.JSON(label="Records")
+
+            qry_btn.click(query_records, [lim, sch, cntry], out)
+
+        with gr.Column(scale=1):
+            gr.Markdown("### Jarvis X")
+            gr.ChatInterface(jarvis, chatbot=gr.Chatbot(height=400))
+
+    gr.Markdown("**v3** • First coherence check & Ω smoothing • Still toy-level IRE influence")
 
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()