Update app.py

app.py

@@ -1,442 +1,992 @@
 """
-corrected_bridge.py
-────────────────────────────────────────────────────────────────
-The honest architecture:
-
-  1. Perspective Engine  →  finds C (the hidden numbers).  Pure math.
-  2. StructuredBridge    →  turns C into a clean, rich context string.
-  3. DeepSeek / any LLM →  reads that string and reasons in language.
-
-There is NO tensor injection into BART / DeepSeek.
-That approach failed because the LatentProjector was never trained
-with a language objective — it only ever minimised noise-prediction loss.
-
-Instead, the bridge is a structured formatter. This is not a compromise:
-it IS the correct separation of concerns. The engine's job ends at numbers.
-The LLM's job starts at language. They should not share a tensor space
-unless both sides are jointly trained on a language reconstruction loss
-(a separate, significant fine-tuning task we have NOT done yet).
-
-If you want to run the full loop:
-  pip install torch transformers requests gradio fastapi uvicorn
-
-Run:
-  python corrected_bridge.py
+universal_constraint_engine_v2.py
+══════════════════════════════════════════════════════════════════════════════
+Universal Constraint Engine  —  v2  (Single Script)
+
+Theory being validated:
+  A  =  constraint / rule  (text → frozen sentence embedding)
+  B  =  observed outcome   (normalised float)
+  C  =  hidden variables   (what the engine retraces via reverse diffusion)
+
+What this script does on a single run:
+  1. FETCH    — stream real triples from 3 sources:
+                  (a) Synthetic formula families (physics, economics, chemistry)
+                  (b) Executable Python function templates → sample C, run, get B
+                  (c) HuggingFace C4 stream → regex-extract explicit variable=value patterns
+  2. ENCODE   — embed every A string with frozen sentence-transformers/all-MiniLM-L6-v2
+  3. TRAIN    — cross-attention diffusion network (~5–8M params)
+  4. EVALUATE — self-test suite across all domains, log every number
+  5. BRIDGE   — send structured JSON context to external LLM via /chat endpoint
+
+Run anywhere:
+  pip install torch transformers sentence-transformers datasets requests gradio
+  python universal_constraint_engine_v2.py
+
+  Or set LLM_CHAT_URL env var to point at your DeepSeek server:
+  LLM_CHAT_URL=http://your-server:7860 python universal_constraint_engine_v2.py
+══════════════════════════════════════════════════════════════════════════════
 """
 
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import math, time, threading, random, json
-import gradio as gr
-
-# ─────────────────────────────────────────────────────────────
-# 0. DEVICE
-# ─────────────────────────────────────────────────────────────
-DEVICE  = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-USE_AMP = torch.cuda.is_available()
-
-# ─────────────────────────────────────────────────────────────
-# 1. DOMAINS  (same physics as always)
-# ─────────────────────────────────────────────────────────────
-DOMAINS = {
-    0: {
-        "name":   "Ecology",
-        "labels": ("Fox Population", "Rabbit Population"),
-        "c_min":  [5.0,   50.0],
-        "c_max":  [50.0,  500.0],
-        "b_norm": 300.0,
-        "unit":   "surviving rabbits",
-        "sim":    lambda c0, c1: c1 * math.exp(-0.05 * c0),
-        "sim_t":  lambda c0, c1: c1 * torch.exp(-0.05 * c0),
-        "rule_text": (
-            "Ecosystem predator-prey dynamics. "
-            "Rabbit survival decays exponentially with fox population. "
-            "Rule: survivors = rabbits × e^(−0.05 × foxes)"
-        ),
+# ─────────────────────────────────────────────────────────────────────────────
+# 0. BOOTSTRAP — catch import errors loudly so the user knows exactly what's missing
+# ─────────────────────────────────────────────────────────────────────────────
+import sys, os, time, math, re, json, random, threading, traceback
+from datetime import datetime
+
+def ts():
+    return datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+def log(msg, level="INFO"):
+    prefix = {"INFO": "  ", "WARN": "⚠ ", "ERROR": "✖ ", "OK": "✔ ", "HEAD": "━━"}.get(level, "  ")
+    line = f"[{ts()}] {prefix} {msg}"
+    print(line, flush=True)
+    _LOG_LINES.append(line)
+    if len(_LOG_LINES) > 500:
+        _LOG_LINES.pop(0)
+
+_LOG_LINES = []
+
+log("Importing core libraries…", "HEAD")
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    import torch.nn.functional as F
+    log(f"torch {torch.__version__}  CUDA={torch.cuda.is_available()}", "OK")
+except ImportError as e:
+    print(f"FATAL: torch not found — {e}"); sys.exit(1)
+
+try:
+    from sentence_transformers import SentenceTransformer
+    log("sentence-transformers ready", "OK")
+    SENT_OK = True
+except ImportError:
+    log("sentence-transformers not installed — A embeddings will use random fallback", "WARN")
+    SENT_OK = False
+
+try:
+    from datasets import load_dataset
+    log("HuggingFace datasets ready", "OK")
+    HF_OK = True
+except ImportError:
+    log("datasets not installed — C4 stream phase will be skipped", "WARN")
+    HF_OK = False
+
+try:
+    import requests as _req
+    log("requests ready", "OK")
+except ImportError:
+    log("requests not installed — LLM bridge will be skipped", "WARN")
+    _req = None
+
+try:
+    import gradio as gr
+    log("gradio ready", "OK")
+    GR_OK = True
+except ImportError:
+    log("gradio not installed — will print results to console only", "WARN")
+    GR_OK = False
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 1. GLOBAL CONFIG
+# ─────────────────────────────────────────────────────────────────────────────
+log("Loading config…", "HEAD")
+
+DEVICE   = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+USE_AMP  = torch.cuda.is_available()
+log(f"Compute device: {DEVICE}  AMP: {USE_AMP}", "OK")
+
+# Sentence encoder  (frozen — never updated)
+SENT_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+A_DIM           = 384    # all-MiniLM output dimension
+A_CTX           = 128    # projected down for engine cross-attention keys/values
+
+# Diffusion
+T_STEPS  = 80
+LATENT_D = 2             # hidden variables per problem (normalised to [0,1])
+
+# Network
+HIDDEN = 256
+N_HEADS = 4
+DEPTH  = 8               # DiT blocks — tune down to 6 if memory is tight
+HEAD_DIM = HIDDEN // N_HEADS   # 64
+
+# Training
+EPOCHS  = 600
+BATCH   = 256
+LR      = 2e-3
+
+# Data budgets (per source)
+N_SYNTHETIC  = 40_000
+N_CODE       = 15_000
+N_C4         = 10_000    # streamed; actual yield may be lower
+C4_SCAN_CAP  = 50_000    # max C4 documents to scan for regex matches
+
+# LLM bridge
+LLM_CHAT_URL = os.getenv("LLM_CHAT_URL", "")   # e.g. http://localhost:7860
+log(f"LLM_CHAT_URL: '{LLM_CHAT_URL}' ({'set' if LLM_CHAT_URL else 'not set — bridge skipped'})")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 2. SENTENCE ENCODER  (load once, freeze forever)
+# ─────────────────────────────────────────────────────────────────────────────
+log("Loading sentence encoder…", "HEAD")
+_sent_enc = None
+
+def get_sent_enc():
+    global _sent_enc
+    if _sent_enc is None:
+        if SENT_OK:
+            try:
+                log(f"Downloading {SENT_MODEL_NAME} (22M params, ~90MB)…")
+                _sent_enc = SentenceTransformer(SENT_MODEL_NAME, device=str(DEVICE))
+                for p in _sent_enc.parameters():
+                    p.requires_grad_(False)
+                log(f"Sentence encoder loaded on {DEVICE}", "OK")
+            except Exception as e:
+                log(f"Sentence encoder load failed: {e}", "ERROR")
+                log("Falling back to random 384-dim embeddings", "WARN")
+                _sent_enc = None
+        else:
+            log("sentence-transformers unavailable — using random embeddings", "WARN")
+    return _sent_enc
+
+def encode_texts(texts: list[str]) -> torch.Tensor:
+    """Returns [N, A_DIM] float32 tensor."""
+    enc = get_sent_enc()
+    if enc is None:
+        # Deterministic random fallback: same text → same vector via hash
+        vecs = []
+        for t in texts:
+            rng = random.Random(hash(t) & 0xFFFFFFFF)
+            vecs.append([rng.gauss(0, 1) for _ in range(A_DIM)])
+        return torch.tensor(vecs, dtype=torch.float32, device=DEVICE)
+    with torch.no_grad():
+        emb = enc.encode(texts, convert_to_tensor=True,
+                         show_progress_bar=False, batch_size=256)
+    return emb.to(dtype=torch.float32, device=DEVICE)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 3. DATA PIPELINE
+# ─────────────────────────────────────────────────────────────────────────────
+log("Defining data pipeline…", "HEAD")
+
+# ── 3a. Synthetic formula families ──────────────────────────────────────────
+
+FORMULA_FAMILIES = [
+    {
+        "name": "projectile_drag",
+        "rule_text": "Projectile range with exponential atmospheric drag. "
+                     "Formula: range = (v^2 * sin(2*theta) / 9.81) * exp(-v/100). "
+                     "Variables: v=launch velocity m/s, theta=angle degrees.",
+        "c_ranges": [(10, 120), (5, 85)],
+        "b_norm": 600.0,
+        "forward": lambda c: ((c[0]**2 * math.sin(2*c[1]*math.pi/180)) / 9.81) * math.exp(-c[0]/100),
     },
-    1: {
-        "name":   "Market",
-        "labels": ("Supply (units)", "Demand (units)"),
-        "c_min":  [10.0,  10.0],
-        "c_max":  [100.0, 100.0],
+    {
+        "name": "market_price",
+        "rule_text": "Non-linear commodity market pricing. "
+                     "Formula: price = (demand^2 / supply) * 1.2. "
+                     "Variables: supply=units available, demand=units requested.",
+        "c_ranges": [(10, 100), (10, 100)],
         "b_norm": 1200.0,
-        "unit":   "price ($)",
-        "sim":    lambda s, d: (d ** 2 / s) * 1.2,
-        "sim_t":  lambda s, d: (d ** 2 / s) * 1.2,
-        "rule_text": (
-            "Non-linear commodity market. "
-            "Price scales with demand squared and inversely with supply. "
-            "Rule: price = (demand² / supply) × 1.2"
-        ),
+        "forward": lambda c: (c[1]**2 / c[0]) * 1.2,
     },
-    2: {
-        "name":   "Physics",
-        "labels": ("Launch Velocity (m/s)", "Launch Angle (°)"),
-        "c_min":  [10.0,  5.0],
-        "c_max":  [120.0, 85.0],
-        "b_norm": 600.0,
-        "unit":   "range (m)",
-        "sim":    lambda v, a: ((v**2 * math.sin(math.radians(2*a))) / 9.81) * math.exp(-v/100),
-        "sim_t":  lambda v, a: ((v**2 * torch.sin(2*a*math.pi/180.0)) / 9.81) * torch.exp(-v/100),
-        "rule_text": (
-            "Projectile with atmospheric drag. "
-            "Range follows ballistic formula modulated by exponential drag. "
-            "Rule: range = (v² × sin(2θ) / 9.81) × e^(−v/100)"
-        ),
+    {
+        "name": "predator_prey",
+        "rule_text": "Lotka-Volterra predator suppression. "
+                     "Formula: survivors = prey * exp(-0.05 * predators). "
+                     "Variables: predators=fox count, prey=rabbit population.",
+        "c_ranges": [(5, 50), (50, 500)],
+        "b_norm": 300.0,
+        "forward": lambda c: c[1] * math.exp(-0.05 * c[0]),
+    },
+    {
+        "name": "compound_interest",
+        "rule_text": "Compound interest accumulation. "
+                     "Formula: amount = principal * (1 + rate)^years. "
+                     "Variables: principal=initial dollars, rate=annual fraction.",
+        "c_ranges": [(100, 10000), (0.01, 0.20)],
+        "b_norm": 50000.0,
+        "forward": lambda c: c[0] * (1 + c[1]) ** 10,
+    },
+    {
+        "name": "ohms_power",
+        "rule_text": "Electrical power dissipation. "
+                     "Formula: power = voltage^2 / resistance. "
+                     "Variables: voltage=volts, resistance=ohms.",
+        "c_ranges": [(1, 240), (1, 1000)],
+        "b_norm": 60000.0,
+        "forward": lambda c: (c[0]**2) / c[1],
+    },
+    {
+        "name": "fluid_flow",
+        "rule_text": "Hagen-Poiseuille laminar flow rate. "
+                     "Formula: flow = pi * radius^4 * pressure / (8 * viscosity * length). "
+                     "Variables: radius=pipe radius m, pressure=pressure diff Pa.",
+        "c_ranges": [(0.001, 0.05), (100, 100000)],
+        "b_norm": 1.0,
+        "forward": lambda c: math.pi * (c[0]**4) * c[1] / (8 * 0.001 * 1.0),
+    },
+    {
+        "name": "chemical_rate",
+        "rule_text": "Arrhenius reaction rate law. "
+                     "Formula: rate = A * exp(-Ea / (R * T)) where R=8.314, A=1e6. "
+                     "Variables: Ea=activation energy J/mol, T=temperature Kelvin.",
+        "c_ranges": [(5000, 80000), (200, 1000)],
+        "b_norm": 1e6,
+        "forward": lambda c: 1e6 * math.exp(-c[0] / (8.314 * c[1])),
+    },
+    {
+        "name": "population_growth",
+        "rule_text": "Logistic population growth model. "
+                     "Formula: final = K / (1 + ((K - N0) / N0) * exp(-r * t)) where t=20, K=10000. "
+                     "Variables: N0=initial population, r=growth rate.",
+        "c_ranges": [(10, 1000), (0.01, 0.5)],
+        "b_norm": 10000.0,
+        "forward": lambda c: 10000 / (1 + ((10000 - c[0]) / max(c[0], 1)) * math.exp(-c[1] * 20)),
+    },
+]
+
+def generate_synthetic(n=N_SYNTHETIC, seed=42) -> tuple:
+    """Returns (A_texts, B_vals, C_norm_vals) as Python lists."""
+    random.seed(seed)
+    A_texts, B_vals, C_norms = [], [], []
+    per = n // len(FORMULA_FAMILIES)
+    total_ok = 0; total_skip = 0
+
+    for fam in FORMULA_FAMILIES:
+        ok = 0; skip = 0
+        for _ in range(per * 3):   # oversample to account for out-of-range B
+            if ok >= per: break
+            c_raw = [random.uniform(*r) for r in fam["c_ranges"]]
+            try:
+                b_raw = fam["forward"](c_raw)
+            except (ZeroDivisionError, ValueError, OverflowError):
+                skip += 1; continue
+
+            if not math.isfinite(b_raw) or b_raw <= 0:
+                skip += 1; continue
+
+            b_norm = b_raw / fam["b_norm"]
+            if not (0.0 < b_norm < 1.0):
+                skip += 1; continue
+
+            c_norm = [(c_raw[i] - fam["c_ranges"][i][0]) /
+                      (fam["c_ranges"][i][1] - fam["c_ranges"][i][0])
+                      for i in range(2)]
+            c_norm = [max(0.0, min(1.0, v)) for v in c_norm]
+
+            A_texts.append(fam["rule_text"])
+            B_vals.append(b_norm)
+            C_norms.append(c_norm)
+            ok += 1
+
+        total_ok += ok; total_skip += skip
+        log(f"  {fam['name']:25s}: {ok:>5} triples  ({skip} skipped)")
+
+    log(f"Synthetic: {total_ok} total triples  ({total_skip} rejected)", "OK")
+    return A_texts, B_vals, C_norms
+
+
+# ── 3b. Executable Python function templates ────────────────────────────────
+
+CODE_TEMPLATES = [
+    {
+        "text": "def score(accuracy, recall):\n    return 2*(accuracy*recall)/(accuracy+recall+1e-9)",
+        "ranges": [(0.1, 1.0), (0.1, 1.0)],
+        "b_norm": 1.0,
+        "fn": lambda c: 2*(c[0]*c[1])/(c[0]+c[1]+1e-9),
+    },
+    {
+        "text": "def revenue(price, quantity):\n    elasticity = -1.5\n    return price * quantity * (1 + elasticity * (price/50 - 1))",
+        "ranges": [(10, 100), (100, 10000)],
+        "b_norm": 1_000_000.0,
+        "fn": lambda c: c[0] * c[1] * (1 + (-1.5) * (c[0]/50 - 1)),
+    },
+    {
+        "text": "def signal_snr(power, noise):\n    import math\n    return 10 * math.log10(power / max(noise, 1e-9))",
+        "ranges": [(0.001, 1000), (0.001, 10)],
+        "b_norm": 60.0,
+        "fn": lambda c: 10 * math.log10(c[0] / max(c[1], 1e-9)),
+    },
+    {
+        "text": "def bond_duration(coupon_rate, yield_rate):\n    T = 10\n    return sum(t * coupon_rate * (1+yield_rate)**-t for t in range(1,T+1)) + T*(1+yield_rate)**-T",
+        "ranges": [(0.01, 0.15), (0.01, 0.20)],
+        "b_norm": 15.0,
+        "fn": lambda c: sum(t*c[0]*(1+c[1])**-t for t in range(1,11)) + 10*(1+c[1])**-10,
+    },
+    {
+        "text": "def mixing_entropy(p1, p2):\n    import math\n    p3 = max(1e-9, 1-p1-p2)\n    return -(p1*math.log(p1+1e-9)+p2*math.log(p2+1e-9)+p3*math.log(p3))",
+        "ranges": [(0.05, 0.60), (0.05, 0.60)],
+        "b_norm": 2.0,
+        "fn": lambda c: -(c[0]*math.log(c[0]+1e-9) + c[1]*math.log(c[1]+1e-9) +
+                          max(1e-9, 1-c[0]-c[1])*math.log(max(1e-9, 1-c[0]-c[1]))),
+    },
+    {
+        "text": "def satellite_orbit(mass, radius):\n    G = 6.674e-11; M = 5.972e24\n    return math.sqrt(G * M / max(radius, 1)) * mass / 1e6",
+        "ranges": [(100, 5000), (6.4e6, 4.2e7)],
+        "b_norm": 50.0,
+        "fn": lambda c: math.sqrt(6.674e-11 * 5.972e24 / max(c[1], 1)) * c[0] / 1e6,
     },
-}
-
-TEST_SUITE = [
-    (0,  120.0),
-    (0,   55.0),
-    (1,  450.0),
-    (1,  900.0),
-    (2,  320.0),
-    (2,  150.0),
-    (2,  500.0),
 ]
 
-# ─────────────────────────────────────────────────────────────
-# 2. DIFFUSION SCHEDULE
-# ─────────────────────────────────────────────────────────────
-T_STEPS = 60
+def generate_code_triples(n=N_CODE, seed=99) -> tuple:
+    random.seed(seed)
+    A_texts, B_vals, C_norms = [], [], []
+    per = n // len(CODE_TEMPLATES)
+    total_ok = 0; total_skip = 0
+
+    for tmpl in CODE_TEMPLATES:
+        ok = 0; skip = 0
+        for _ in range(per * 5):
+            if ok >= per: break
+            c_raw = [random.uniform(*r) for r in tmpl["ranges"]]
+            try:
+                b_raw = tmpl["fn"](c_raw)
+            except Exception:
+                skip += 1; continue
+            if not math.isfinite(b_raw):
+                skip += 1; continue
+            b_norm = b_raw / tmpl["b_norm"]
+            if not (0.001 < b_norm < 0.999):
+                skip += 1; continue
+            c_norm = [(c_raw[i] - tmpl["ranges"][i][0]) /
+                      (tmpl["ranges"][i][1] - tmpl["ranges"][i][0])
+                      for i in range(2)]
+            c_norm = [max(0.0, min(1.0, v)) for v in c_norm]
+            A_texts.append(tmpl["text"])
+            B_vals.append(b_norm)
+            C_norms.append(c_norm)
+            ok += 1
+
+        total_ok += ok; total_skip += skip
+        log(f"  code_tmpl '{tmpl['text'][:40]}…': {ok} triples")
+
+    log(f"Code templates: {total_ok} total  ({total_skip} rejected)", "OK")
+    return A_texts, B_vals, C_norms
+
+
+# ── 3c. C4 stream — extract explicit variable=value patterns ────────────────
+
+# Patterns that look like: "with v=90 and theta=53, range=320"
+# or "x1=0.4, x2=0.7 yields output=1.23"
+C4_REGEX = re.compile(
+    r'(?P<rule>[^.]{20,120}(?:formula|equation|law|rule|function|model)[^.]{0,60})\.'
+    r'|'
+    r'(?:where|with|given|using|when)\s+'
+    r'(?P<var1>[a-zA-Z_]\w{0,15})\s*[=≈]\s*(?P<val1>-?\d+\.?\d*(?:e[+-]?\d+)?)'
+    r'[,\s]+(?:and\s+)?'
+    r'(?P<var2>[a-zA-Z_]\w{0,15})\s*[=≈]\s*(?P<val2>-?\d+\.?\d*(?:e[+-]?\d+)?)'
+    r'[,\s]*(?:,\s*(?:the\s+)?(?P<out_var>[a-zA-Z_]\w{0,15})\s*'
+    r'(?:=|is|equals|becomes|gives)\s*(?P<out_val>-?\d+\.?\d*(?:e[+-]?\d+)?))?',
+    re.IGNORECASE
+)
+
+def stream_c4_triples(max_triples=N_C4, scan_cap=C4_SCAN_CAP) -> tuple:
+    """
+    Streams C4 and extracts (rule_sentence, B, C) triples.
+    B and C are extracted from explicit numeric variable=value patterns.
+    Falls back to empty lists if datasets not available.
+    """
+    if not HF_OK:
+        log("datasets unavailable — C4 phase skipped", "WARN")
+        return [], [], []
+
+    log(f"Streaming C4 (scan up to {scan_cap} docs for {max_triples} triples)…")
+    A_texts, B_vals, C_norms = [], [], []
+    scanned = 0; found = 0; parse_errors = 0
+
+    try:
+        ds = load_dataset("allenai/c4", "en", split="train", streaming=True,
+                          trust_remote_code=True)
+    except Exception as e:
+        log(f"C4 load failed: {e}", "ERROR")
+        log("Trying fallback dataset: wikitext-103-raw-v1", "WARN")
+        try:
+            ds = load_dataset("wikitext", "wikitext-103-raw-v1",
+                              split="train", streaming=True)
+        except Exception as e2:
+            log(f"Fallback also failed: {e2}", "ERROR")
+            return [], [], []
+
+    try:
+        for doc in ds:
+            if scanned >= scan_cap or found >= max_triples:
+                break
+            scanned += 1
+            text = doc.get("text", "")
+            if len(text) < 40:
+                continue
+
+            for m in C4_REGEX.finditer(text):
+                try:
+                    v1  = float(m.group("val1"))
+                    v2  = float(m.group("val2"))
+                    out = m.group("out_val")
+                    if out is None:
+                        continue
+                    b_raw = float(out)
+                    if b_raw <= 0 or not math.isfinite(b_raw):
+                        continue
+
+                    # Build rule text from surrounding sentence
+                    start = max(0, m.start() - 80)
+                    rule_sentence = text[start: m.end() + 80].replace('\n', ' ').strip()
+                    rule_sentence = rule_sentence[:200]
+
+                    # Normalise: use per-sample scale (store as b_norm=b_raw, C as ratio)
+                    b_norm_val = b_raw / (abs(b_raw) * 2 + 1e-9)   # crude [0,1]
+                    c1_norm = abs(v1) / (abs(v1) * 2 + 1e-9)
+                    c2_norm = abs(v2) / (abs(v2) * 2 + 1e-9)
+
+                    if not (0.01 < b_norm_val < 0.99):
+                        continue
+
+                    A_texts.append(rule_sentence)
+                    B_vals.append(b_norm_val)
+                    C_norms.append([c1_norm, c2_norm])
+                    found += 1
+
+                    if found % 500 == 0:
+                        log(f"  C4 progress: {found} triples  ({scanned} docs scanned)")
+
+                except (ValueError, TypeError) as pe:
+                    parse_errors += 1
+                    continue
+
+    except Exception as e:
+        log(f"C4 stream interrupted: {e}", "WARN")
+        log(traceback.format_exc(), "ERROR")
+
+    log(f"C4 scan complete: {found} triples from {scanned} docs  "
+        f"({parse_errors} parse errors)", "OK")
+    return A_texts, B_vals, C_norms
+
+
+# ── 3d. Combine and tensorise ────────────────────────────────────────────────
+
+_dataset_cache = None   # (A_emb, B_tensor, C_tensor)
+
+def build_dataset(seed=42) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    global _dataset_cache
+    if _dataset_cache is not None:
+        return _dataset_cache
+
+    log("Building combined dataset…", "HEAD")
+
+    log("Phase A: synthetic formula families")
+    sA, sB, sC = generate_synthetic(N_SYNTHETIC, seed=seed)
+
+    log("Phase B: executable code templates")
+    cA, cB, cC = generate_code_triples(N_CODE, seed=seed+1)
+
+    log("Phase C: C4 web stream")
+    wA, wB, wC = stream_c4_triples(N_C4, C4_SCAN_CAP)
+
+    all_A = sA + cA + wA
+    all_B = sB + cB + wB
+    all_C = sC + cC + wC
+
+    log(f"Total triples before embedding: {len(all_A)}", "OK")
+    log(f"  Synthetic:      {len(sA)}")
+    log(f"  Code templates: {len(cA)}")
+    log(f"  C4 web:         {len(wA)}")
+
+    if len(all_A) == 0:
+        log("FATAL: zero triples collected — check data pipeline", "ERROR")
+        sys.exit(1)
+
+    # Embed all A strings in one batched pass
+    log(f"Encoding {len(all_A)} constraint texts → {A_DIM}-dim embeddings…")
+    t0 = time.time()
+    A_emb = encode_texts(all_A)   # [N, A_DIM]
+    log(f"Encoding done in {time.time()-t0:.1f}s  shape={tuple(A_emb.shape)}", "OK")
+
+    B_tensor = torch.tensor(all_B, dtype=torch.float32, device=DEVICE).unsqueeze(1)
+    C_tensor = torch.tensor(all_C, dtype=torch.float32, device=DEVICE)
+
+    log(f"Final dataset tensors: A{tuple(A_emb.shape)}  B{tuple(B_tensor.shape)}  C{tuple(C_tensor.shape)}", "OK")
+
+    _dataset_cache = (A_emb, B_tensor, C_tensor)
+    return _dataset_cache
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 4. NETWORK ARCHITECTURE  (~5–8M parameters)
+# ─────────────────────────────────────────────────────────────────────────────
+log("Defining network architecture…", "HEAD")
+
+class ConstraintProjector(nn.Module):
+    """Compresses frozen sentence embedding A [B, A_DIM] → [B, A_CTX] for cross-attention."""
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(A_DIM, 256), nn.GELU(),
+            nn.Linear(256, A_CTX), nn.LayerNorm(A_CTX)
+        )
+    def forward(self, a): return self.net(a).unsqueeze(1)   # [B, 1, A_CTX]
+
 
+class DiTBlock(nn.Module):
+    """
+    Diffusion Transformer block.
+    Self-attention on the latent c_t.
+    Cross-attention: c_t queries A_ctx (the constraint memory).
+    """
+    def __init__(self, hidden, n_heads, ctx_dim, shared_kv=None):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(hidden)
+        self.norm2 = nn.LayerNorm(hidden)
+        self.norm3 = nn.LayerNorm(hidden)
+
+        self.self_attn  = nn.MultiheadAttention(hidden, n_heads, batch_first=True)
+
+        # Cross-attention: Q from hidden, K/V from ctx_dim
+        self.cross_q    = nn.Linear(hidden, hidden)
+        # Shared KV across all blocks saves parameters
+        self.shared_kv  = shared_kv  # nn.Linear(ctx_dim, hidden*2) passed in
+        self.cross_out  = nn.Linear(hidden, hidden)
+
+        self.ffn = nn.Sequential(
+            nn.Linear(hidden, hidden * 4), nn.GELU(),
+            nn.Linear(hidden * 4, hidden)
+        )
+
+    def forward(self, x, a_ctx):
+        # x:     [B, 1, HIDDEN]   (single-token latent, treated as sequence of 1)
+        # a_ctx: [B, 1, A_CTX]
+
+        # Self-attention
+        x2, _ = self.self_attn(self.norm1(x), self.norm1(x), self.norm1(x))
+        x = x + x2
+
+        # Cross-attention
+        q   = self.cross_q(self.norm2(x))          # [B, 1, HIDDEN]
+        kv  = self.shared_kv(a_ctx)                 # [B, 1, HIDDEN*2]
+        k, v = kv.chunk(2, dim=-1)
+        # Manual scaled dot-product (cross-dim attention: q is HIDDEN, k/v are HIDDEN)
+        scale = (HEAD_DIM) ** -0.5
+        attn_w = torch.softmax((q @ k.transpose(-2, -1)) * scale, dim=-1)
+        x2 = self.cross_out(attn_w @ v)
+        x = x + x2
+
+        # FFN
+        x = x + self.ffn(self.norm3(x))
+        return x
+
+
+class UniversalConstraintEngine(nn.Module):
+    """
+    Input:
+      c_t   [B, LATENT_D]     — noisy latent at timestep t
+      t     [B, 1]            — normalised timestep
+      a_emb [B, A_DIM]        — frozen sentence embedding of constraint A
+      b     [B, 1]            — normalised observed outcome B
+    Output:
+      eps_pred [B, LATENT_D]  — predicted noise (standard diffusion objective)
+    """
+    def __init__(self):
+        super().__init__()
+        in_dim = LATENT_D + 1 + 1   # c_t + t + b  (A enters via cross-attn)
+
+        self.a_proj     = ConstraintProjector()
+        self.shared_kv  = nn.Linear(A_CTX, HIDDEN * 2)   # shared across all blocks
+        self.input_proj = nn.Linear(in_dim, HIDDEN)
+
+        self.blocks = nn.ModuleList([
+            DiTBlock(HIDDEN, N_HEADS, A_CTX, self.shared_kv)
+            for _ in range(DEPTH)
+        ])
+
+        self.head = nn.Sequential(
+            nn.LayerNorm(HIDDEN),
+            nn.Linear(HIDDEN, LATENT_D)
+        )
+
+    def forward(self, c_t, t, a_emb, b):
+        a_ctx = self.a_proj(a_emb)                         # [B, 1, A_CTX]
+        x = self.input_proj(torch.cat([c_t, t, b], dim=-1)).unsqueeze(1)   # [B, 1, HIDDEN]
+        for blk in self.blocks:
+            x = blk(x, a_ctx)
+        return self.head(x.squeeze(1))                     # [B, LATENT_D]
+
+
+def count_params(model):
+    total    = sum(p.numel() for p in model.parameters())
+    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    return total, trainable
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 5. DIFFUSION SCHEDULE
+# ─────────────────────────────────────────────────────────────────────────────
 def make_schedule(T, s=0.008):
-    x   = torch.linspace(0, T, T+1, device=DEVICE)
-    f   = torch.cos(((x/T)+s)/(1+s)*math.pi/2)**2
+    x = torch.linspace(0, T, T+1, device=DEVICE)
+    f = torch.cos(((x/T)+s)/(1+s)*math.pi/2)**2
     acp = f / f[0]
     betas = torch.clamp(1.0 - acp[1:]/acp[:-1], 1e-4, 0.999)
     return torch.cumprod(1.0 - betas, dim=0)
 
 ACP = make_schedule(T_STEPS)
 
-# ─────────────────────────────────────────────────────────────
-# 3. NETWORK  (unchanged — this part was always correct)
-# ─────────────────────────────────────────────────────────────
-HIDDEN = 256
-DEPTH  = 5
+# ─────────────────────────────────────────────────────────────────────────────
+# 6. TRAINING LOOP
+# ─────────────────────────────────────────────────────────────────────────────
+_engine      : UniversalConstraintEngine = None
+_train_state = {"phase": "idle", "epoch": 0, "loss": None, "elapsed": None}
 
-class ResBlock(nn.Module):
-    def __init__(self, d):
-        super().__init__()
-        self.net  = nn.Sequential(nn.Linear(d, d*2), nn.GELU(), nn.Linear(d*2, d))
-        self.norm = nn.LayerNorm(d)
-    def forward(self, x): return self.norm(x + self.net(x))
+def run_full_pipeline(seed=42):
+    global _engine, ACP, _train_state
 
-class PerspectiveEngine(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.proj   = nn.Linear(7, HIDDEN)   # c_t(2)+t(1)+a_oh(3)+b(1)
-        self.blocks = nn.ModuleList([ResBlock(HIDDEN) for _ in range(DEPTH)])
-        self.head   = nn.Sequential(nn.LayerNorm(HIDDEN), nn.Linear(HIDDEN, 2))
-    def forward(self, c_t, t, a, b):
-        x = self.proj(torch.cat([c_t, t, a, b], dim=-1))
-        for blk in self.blocks: x = blk(x)
-        return self.head(x)
-
-# ─────────────────────────────────────────────────────────────
-# 4. DATA + TRAINING
-# ─────────────────────────────────────────────────────────────
-N_TRAIN = 20_000
-EPOCHS  = 1_000
-BATCH   = 512
-LR      = 3e-3
-
-_engine: PerspectiveEngine = None
-_train_log = []
-_phase = "idle"
-
-def log(msg):
-    stamp = time.strftime("%H:%M:%S")
-    line  = f"[{stamp}] {msg}"
-    print(line)
-    _train_log.append(line)
-    if len(_train_log) > 300: _train_log.pop(0)
-
-def generate_data(seed=42):
-    torch.manual_seed(seed)
-    all_A, all_B, all_C = [], [], []
-    per = N_TRAIN // len(DOMAINS)
-    for did, dom in DOMAINS.items():
-        C_n = torch.rand(per, 2, device=DEVICE)
-        c0  = C_n[:,0]*(dom["c_max"][0]-dom["c_min"][0])+dom["c_min"][0]
-        c1  = C_n[:,1]*(dom["c_max"][1]-dom["c_min"][1])+dom["c_min"][1]
-        B_r = dom["sim_t"](c0, c1)
-        B_n = (B_r/dom["b_norm"]).clamp(0,1).unsqueeze(1)
-        A_oh = nn.functional.one_hot(
-            torch.full((per,), did, dtype=torch.long, device=DEVICE), 3
-        ).float()
-        all_A.append(A_oh); all_B.append(B_n); all_C.append(C_n)
-    return torch.cat(all_A), torch.cat(all_B), torch.cat(all_C)
-
-def run_training(seed=42):
-    global _engine, _phase, ACP
-    _phase = "generating"
-    log(f"Generating {N_TRAIN} samples (seed={seed})…")
-    A, B, C = generate_data(seed)
-    ACP = make_schedule(T_STEPS)
-
-    _phase = "training"
-    model  = PerspectiveEngine().to(DEVICE)
-    opt    = optim.AdamW(model.parameters(), lr=LR, weight_decay=1e-4)
-    sched  = optim.lr_scheduler.CosineAnnealingLR(opt, EPOCHS)
-    scaler = torch.cuda.amp.GradScaler(enabled=USE_AMP)
-    n      = len(A)
-    t0     = time.time()
-
-    for ep in range(1, EPOCHS+1):
-        perm    = torch.randperm(n, device=DEVICE)
-        ep_loss = 0.0; nb = 0
-        for i in range(0, n, BATCH):
-            idx    = perm[i:i+BATCH]
-            a_b, b_b, c_b = A[idx], B[idx], C[idx]
-            t_int  = torch.randint(0, T_STEPS, (len(a_b),), device=DEVICE)
-            t_norm = (t_int.float()/T_STEPS).unsqueeze(1)
-            acp_t  = ACP[t_int].unsqueeze(1)
-            noise  = torch.randn_like(c_b)
-            c_noisy = acp_t.sqrt()*c_b + (1-acp_t).sqrt()*noise
-
-            with torch.cuda.amp.autocast(enabled=USE_AMP):
-                loss = nn.functional.mse_loss(model(c_noisy, t_norm, a_b, b_b), noise)
-
-            opt.zero_grad()
-            scaler.scale(loss).backward()
-            scaler.unscale_(opt)
-            nn.utils.clip_grad_norm_(model.parameters(), 1.0)
-            scaler.step(opt); scaler.update()
-            ep_loss += loss.item(); nb += 1
-
-        sched.step()
-        if ep % 100 == 0:
-            log(f"Epoch {ep:>4}/{EPOCHS}  loss={ep_loss/nb:.5f}")
-
-    log(f"Training done in {time.time()-t0:.1f}s")
-    _engine = model.eval()
-    _phase  = "ready"
-    run_tests()
-
-# ─────────────────────────────────────────────────────────────
-# 5. INFERENCE
-# ─────────────────────────────────────────────────────────────
+    try:
+        # ── Data ──────────────────────────────────────────────────────────────
+        _train_state["phase"] = "fetching"
+        A_emb, B_tensor, C_tensor = build_dataset(seed)
+        n = len(A_emb)
+
+        # ── Model ──────────────────────────────────────────────────────────────
+        _train_state["phase"] = "training"
+        log("Instantiating UniversalConstraintEngine…", "HEAD")
+        model  = UniversalConstraintEngine().to(DEVICE)
+        total, trainable = count_params(model)
+        log(f"Parameters: {total:,} total  |  {trainable:,} trainable", "OK")
+
+        opt    = optim.AdamW(model.parameters(), lr=LR, weight_decay=1e-4)
+        sched  = optim.lr_scheduler.CosineAnnealingLR(opt, EPOCHS)
+        scaler = torch.cuda.amp.GradScaler(enabled=USE_AMP)
+        ACP    = make_schedule(T_STEPS)
+
+        log(f"Training: {EPOCHS} epochs  |  batch={BATCH}  |  n={n}  |  device={DEVICE}", "HEAD")
+        t0 = time.time()
+
+        for ep in range(1, EPOCHS+1):
+            model.train()
+            perm    = torch.randperm(n, device=DEVICE)
+            ep_loss = 0.0; nb = 0
+
+            for i in range(0, n, BATCH):
+                idx  = perm[i:i+BATCH]
+                a_b  = A_emb[idx]
+                b_b  = B_tensor[idx]
+                c_b  = C_tensor[idx]
+
+                t_int  = torch.randint(0, T_STEPS, (len(a_b),), device=DEVICE)
+                t_norm = (t_int.float()/T_STEPS).unsqueeze(1)
+                acp_t  = ACP[t_int].unsqueeze(1)
+                noise  = torch.randn_like(c_b)
+                c_noisy = acp_t.sqrt()*c_b + (1-acp_t).sqrt()*noise
+
+                with torch.cuda.amp.autocast(enabled=USE_AMP):
+                    eps_pred = model(c_noisy, t_norm, a_b, b_b)
+                    loss = F.mse_loss(eps_pred, noise)
+
+                opt.zero_grad()
+                scaler.scale(loss).backward()
+                scaler.unscale_(opt)
+                nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                scaler.step(opt); scaler.update()
+                ep_loss += loss.item(); nb += 1
+
+            sched.step()
+            avg = ep_loss / nb
+            _train_state.update({"epoch": ep, "loss": round(avg, 5)})
+
+            if ep % 50 == 0:
+                elapsed = time.time() - t0
+                log(f"Epoch {ep:>4}/{EPOCHS}  loss={avg:.5f}  "
+                    f"lr={sched.get_last_lr()[0]:.2e}  elapsed={elapsed:.0f}s")
+
+        elapsed = round(time.time()-t0, 1)
+        log(f"Training complete: {elapsed}s  final_loss={avg:.5f}", "OK")
+        _train_state["elapsed"] = elapsed
+
+        model.eval()
+        _engine = model
+
+        # ── Evaluation ────────────────────────────────────────────────────────
+        _train_state["phase"] = "evaluating"
+        run_self_evaluation()
+
+        _train_state["phase"] = "done"
+        log("Pipeline finished.", "OK")
+
+    except Exception as e:
+        _train_state["phase"] = "error"
+        log(f"Pipeline crashed: {e}", "ERROR")
+        log(traceback.format_exc(), "ERROR")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 7. INFERENCE — REVERSE DIFFUSION
+# ─────────────────────────────────────────────────────────────────────────────
 
 @torch.no_grad()
-def retrace(domain_id: int, target_b: float):
-    dom    = DOMAINS[domain_id]
-    b_norm = target_b / dom["b_norm"]
-    A  = nn.functional.one_hot(torch.tensor([domain_id], device=DEVICE), 3).float()
-    B  = torch.tensor([[b_norm]], device=DEVICE)
-    c_t = torch.randn(1, 2, device=DEVICE)
+def retrace(rule_text: str, b_norm: float) -> tuple[float, float, torch.Tensor]:
+    """
+    Given a text rule and normalised B, run reverse diffusion.
+    Returns (c0_norm, c1_norm, c_final_tensor).
+    """
+    a_emb = encode_texts([rule_text])            # [1, A_DIM]
+    B     = torch.tensor([[b_norm]], device=DEVICE)
+    c_t   = torch.randn(1, LATENT_D, device=DEVICE)
 
     for t in reversed(range(T_STEPS)):
         t_n      = torch.tensor([[t/T_STEPS]], device=DEVICE)
-        eps_pred = _engine(c_t, t_n, A, B)
+        eps_pred = _engine(c_t, t_n, a_emb, B)
         acp_t    = ACP[t]
         acp_prev = ACP[t-1] if t > 0 else torch.tensor(1.0, device=DEVICE)
-        x0 = ((c_t - (1-acp_t).sqrt()*eps_pred) / acp_t.sqrt()).clamp(0,1)
+        x0  = ((c_t - (1-acp_t).sqrt()*eps_pred) / acp_t.sqrt()).clamp(0, 1)
         c_t = acp_prev.sqrt()*x0 + (1-acp_prev).sqrt()*eps_pred
 
-    cn = c_t.clamp(0,1).squeeze().cpu().tolist()
-    c0 = cn[0]*(dom["c_max"][0]-dom["c_min"][0])+dom["c_min"][0]
-    c1 = cn[1]*(dom["c_max"][1]-dom["c_min"][1])+dom["c_min"][1]
-    verified = dom["sim"](c0, c1)
-    err = abs(verified - target_b) / max(abs(target_b), 1e-6) * 100
-    return c0, c1, verified, err
-
-# ─────────────────────────────────────────────────────────────
-# 6. STRUCTURED BRIDGE
-#    This is where the engine's numbers become language-ready.
-#    NOT tensor injection. Honest, clean structured text.
-#    The LLM (DeepSeek / any model) reads this as its system context.
-# ─────────────────────────────────────────────────────────────
-
-def build_llm_context(domain_id: int, target_b: float,
-                      c0: float, c1: float,
-                      verified: float, err: float) -> dict:
-    """
-    Builds a structured context dict that an LLM can receive
-    either as a system prompt injection or as a JSON API payload.
-
-    This replaces the failed LatentProjector → BART decoder approach.
-    The engine's job is to find the numbers. The LLM's job is language.
-    """
-    dom    = DOMAINS[domain_id]
-    status = "SETTLED" if err < 2.0 else ("APPROXIMATE" if err < 5.0 else "UNSTABLE")
-    confidence = max(0.0, round(100.0 - err, 2))
-
-    # System prompt the LLM receives (as plain text — no tensor magic needed)
-    system_prompt = f"""You are an analytical reasoning assistant.
-The Perspective Engine (a reverse-diffusion constraint solver) has finished
-navigating the geometry of a {dom['name']} system and settled on hidden variables.
-
-DOMAIN: {dom['name']}
-GOVERNING RULE: {dom['rule_text']}
-
-OBSERVED BYPRODUCT (what we saw): {target_b:.2f} {dom['unit']}
-ENGINE STATUS: {status} (convergence error: {err:.3f}%, confidence: {confidence}%)
-
-RETRACED HIDDEN VARIABLES:
-  {dom['labels'][0]}: {c0:.3f}
-  {dom['labels'][1]}: {c1:.3f}
-
-FORWARD VERIFICATION: plugging those back into the rule gives {verified:.3f} {dom['unit']}
-
-Your task: explain, in plain language, what these hidden variables mean,
-why this combination produces the observed outcome, and what it implies
-about the state of the system. Be precise but conversational."""
-
-    return {
-        "domain":          dom["name"],
-        "target_b":        target_b,
-        "unit":            dom["unit"],
-        "c0_label":        dom["labels"][0],
-        "c0_value":        round(c0, 3),
-        "c1_label":        dom["labels"][1],
-        "c1_value":        round(c1, 3),
-        "verified_b":      round(verified, 3),
-        "error_pct":       round(err, 4),
-        "status":          status,
-        "confidence":      confidence,
-        "system_prompt":   system_prompt,  # → inject directly into DeepSeek's context
-        "rule":            dom["rule_text"],
-    }
-
-# ───────────────────────���─────────────────────────────────────
-# 7. OPTIONAL: Ask DeepSeek to reason over the context
-#    Only runs if DEEPSEEK_URL is set in environment.
-#    Falls back to showing the raw structured context if not.
-# ─────────────────────────────────────────────────────────────
-import os, requests as _req
-
-DEEPSEEK_URL = os.getenv("DEEPSEEK_URL", "https://everydaytok-small-llm.hf.space")   # e.g. http://localhost:7860
-
-def ask_deepseek(context: dict) -> str:
-    """
-    Sends the structured context to your DeepSeek server as a plain text
-    system injection. The LLM reasons in language; the engine reasoned in math.
-    """
-    if not DEEPSEEK_URL:
-        return (
-            "DeepSeek not connected (set DEEPSEEK_URL env var).\n\n"
-            "Here is the raw structured context the LLM would receive:\n\n"
-            + context["system_prompt"]
-        )
-    try:
-        payload = {
-            "message": (
-                f"Given the Perspective Engine's findings above, "
-                f"explain what a {context['c0_label']} of {context['c0_value']} "
-                f"and a {context['c1_label']} of {context['c1_value']} means "
-                f"in the context of the {context['domain']} system, "
-                f"and why it produces {context['target_b']} {context['unit']}."
-            ),
-            "system": context["system_prompt"],
-        }
-        r = _req.post(f"{DEEPSEEK_URL}/chat", json=payload, timeout=60)
-        r.raise_for_status()
-        return r.json().get("response", str(r.json()))
-    except Exception as e:
-        return f"DeepSeek call failed: {e}\n\nRaw context:\n{context['system_prompt']}"
+    c_final = c_t.clamp(0, 1)
+    cn = c_final.squeeze().cpu().tolist()
+    return cn[0], cn[1], c_final
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 8. SELF-EVALUATION SUITE
+# ─────────────────────────────────────────────────────────────────────────────
+
+EVAL_CASES = [
+    # (rule_text, c0_true_raw, c1_true_raw, family_index_in FORMULA_FAMILIES)
+    # We compute B from the known C, then ask the engine to retrace C from B.
+    (0, 90.0,    53.0),    # projectile: v=90, θ=53  → ~320m
+    (0, 60.0,    30.0),    # projectile: v=60, θ=30
+    (1, 25.0,    90.0),    # market: supply=25, demand=90
+    (1, 70.0,    50.0),    # market: supply=70, demand=50
+    (2, 15.0,   200.0),    # predator-prey: foxes=15, rabbits=200
+    (2, 30.0,   400.0),    # predator-prey: foxes=30, rabbits=400
+    (3, 1000.0,  0.07),    # compound interest: $1000 @ 7%
+    (4, 120.0,  50.0),     # ohms: 120V / 50Ω
+]
 
-# ─────────────────────────────────────────────────────────────
-# 8. AUTO TEST SUITE
-# ─────────────────────────────────────────────────────────────
-_test_results = []
+_eval_results = []
 
-def run_tests():
-    global _phase, _test_results
-    _phase = "testing"
+def run_self_evaluation():
+    global _eval_results
+    log("Self-evaluation suite starting…", "HEAD")
     results = []
-    for did, target in TEST_SUITE:
-        dom = DOMAINS[did]
-        t0  = time.time()
-        c0, c1, verified, err = retrace(did, target)
-        ctx = build_llm_context(did, target, c0, c1, verified, err)
-        ms  = round((time.time()-t0)*1000, 1)
-        tick = "✅" if err < 5.0 else "⚠️"
-        log(f"{tick} {dom['name']:8s} | target={target:>6.1f} | "
-            f"{dom['labels'][0]}={c0:.2f}  {dom['labels'][1]}={c1:.2f} | "
-            f"verified={verified:.2f} | err={err:.3f}% | {ms}ms")
-        results.append({**ctx, "ms": ms})
-    _test_results = results
-    _phase = "done"
-    log("All tests complete.")
-
-# ─────────────────────────────────────────────────────────────
-# 9. LAUNCH ON BOOT
-# ─────────────────────────────────────────────────────────────
-threading.Thread(
-    target=run_training, kwargs={"seed": 42}, daemon=True
-).start()
-
-# ─────────────────────────────────────────────────────────────
-# 10. GRADIO UI
-# ─────────────────────────────────────────────────────────────
-DOMAIN_NAMES = {v["name"]: k for k, v in DOMAINS.items()}
-
-def ui_solve(domain_name, target_b):
-    if _phase != "ready" and _phase != "done" and _phase != "testing":
-        return f"Engine is still {_phase}. Wait for training to finish.", ""
-    did  = DOMAIN_NAMES[domain_name]
-    c0, c1, verified, err = retrace(did, float(target_b))
-    ctx  = build_llm_context(did, float(target_b), c0, c1, verified, err)
-    llm_out = ask_deepseek(ctx)
-    summary = json.dumps({k: v for k, v in ctx.items() if k != "system_prompt"}, indent=2)
-    return summary, llm_out
-
-def get_log(): return "\n".join(_train_log[-60:])
-
-def get_table():
-    if not _test_results: return []
-    return [
-        [r["domain"], r["target_b"], r["unit"],
-         f"{r['c0_label']}: {r['c0_value']}",
-         f"{r['c1_label']}: {r['c1_value']}",
-         f"{r['verified_b']}",
-         f"{r['error_pct']}%  {'✅' if r['error_pct']<5 else '⚠️'}"]
-        for r in _test_results
-    ]
-
-def get_phase_md():
-    icons = {"idle":"⏸","generating":"🌱","training":"🧠",
-             "testing":"🔬","ready":"✅","done":"✅","error":"❌"}
-    return f"## {icons.get(_phase,'❓')} Phase: **{_phase.upper()}**"
-
-with gr.Blocks(title="Perspective Engine — Corrected Bridge", theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown(
-        "# 🧠 Perspective Engine — Corrected Architecture\n"
-        "The engine finds hidden variables. Language is handled separately. No tensor injection."
-    )
 
-    phase_md = gr.Markdown(get_phase_md())
-
-    with gr.Tabs():
-        with gr.Tab("📊 Auto Test Results"):
-            results_table = gr.Dataframe(
-                headers=["Domain","Target","Unit","Hidden Var 1","Hidden Var 2","Verified","Error"],
-                value=get_table(), interactive=False, wrap=True
-            )
-
-        with gr.Tab("🔍 Manual Solve + LLM Context"):
-            with gr.Row():
-                domain_dd = gr.Dropdown(
-                    choices=list(DOMAIN_NAMES.keys()), value="Market", label="Domain"
-                )
-                target_sl = gr.Slider(50, 1000, value=450, label="Target B (observed byproduct)")
-            solve_btn = gr.Button("Retrace Hidden Variables", variant="primary")
-            with gr.Row():
-                raw_json = gr.Code(label="Structured Context (sent to LLM)", language="json", lines=14)
-                llm_out  = gr.Textbox(label="LLM Explanation (if DeepSeek connected)", lines=14)
-            solve_btn.click(ui_solve, [domain_dd, target_sl], [raw_json, llm_out])
-
-        with gr.Tab("📋 Live Log"):
-            log_box = gr.Textbox(value=get_log(), lines=20, interactive=False, autoscroll=True)
-
-    timer = gr.Timer(value=2)
-    timer.tick(
-        fn=lambda: (get_phase_md(), get_log(), get_table()),
-        outputs=[phase_md, log_box, results_table]
+    for fam_idx, c0_raw, c1_raw in EVAL_CASES:
+        fam = FORMULA_FAMILIES[fam_idx]
+        try:
+            b_raw = fam["forward"]([c0_raw, c1_raw])
+        except Exception as e:
+            log(f"  Forward sim failed for {fam['name']}: {e}", "ERROR"); continue
+
+        if not math.isfinite(b_raw) or b_raw <= 0:
+            log(f"  Skipping {fam['name']} (b_raw={b_raw})", "WARN"); continue
+
+        b_norm = b_raw / fam["b_norm"]
+        if not (0.0 < b_norm < 1.0):
+            log(f"  Skipping {fam['name']} (b_norm={b_norm:.3f} out of range)", "WARN"); continue
+
+        # Normalise true C for comparison
+        c0_norm_true = (c0_raw - fam["c_ranges"][0][0]) / (fam["c_ranges"][0][1] - fam["c_ranges"][0][0])
+        c1_norm_true = (c1_raw - fam["c_ranges"][1][0]) / (fam["c_ranges"][1][1] - fam["c_ranges"][1][0])
+
+        t0 = time.time()
+        c0_pred, c1_pred, _ = retrace(fam["rule_text"], b_norm)
+        ms = round((time.time()-t0)*1000, 1)
+
+        # Denormalise prediction
+        c0_pred_raw = c0_pred*(fam["c_ranges"][0][1]-fam["c_ranges"][0][0]) + fam["c_ranges"][0][0]
+        c1_pred_raw = c1_pred*(fam["c_ranges"][1][1]-fam["c_ranges"][1][0]) + fam["c_ranges"][1][0]
+
+        # Forward-verify with predicted C
+        try:
+            b_pred = fam["forward"]([c0_pred_raw, c1_pred_raw])
+        except Exception:
+            b_pred = float("nan")
+
+        err = abs(b_pred - b_raw) / max(abs(b_raw), 1e-6) * 100 if math.isfinite(b_pred) else 999.0
+        tick = "✅" if err < 5.0 else ("⚠️" if err < 20.0 else "❌")
+
+        log(
+            f"  {tick} {fam['name']:20s} | "
+            f"target_B={b_raw:.3f} | "
+            f"pred({fam['c_ranges'][0]}: {c0_pred_raw:.2f}, "
+            f"{fam['c_ranges'][1]}: {c1_pred_raw:.2f}) | "
+            f"verified_B={b_pred:.3f} | err={err:.3f}% | {ms}ms"
+        )
+
+        results.append({
+            "formula":      fam["name"],
+            "b_target":     round(b_raw, 4),
+            "b_norm":       round(b_norm, 4),
+            "c0_true":      c0_raw,  "c0_pred": round(c0_pred_raw, 3),
+            "c1_true":      c1_raw,  "c1_pred": round(c1_pred_raw, 3),
+            "b_verified":   round(b_pred, 4) if math.isfinite(b_pred) else None,
+            "error_pct":    round(err, 4),
+            "passed":       err < 5.0,
+            "ms":           ms,
+        })
+
+    n_pass = sum(1 for r in results if r["passed"])
+    log(f"Evaluation complete: {n_pass}/{len(results)} passed (<5% error)", "OK")
+    log(f"Pass rate: {100*n_pass/max(len(results),1):.1f}%",
+        "OK" if n_pass/max(len(results),1) > 0.6 else "WARN")
+    _eval_results = results
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 9. LLM BRIDGE  (calls external /chat endpoint)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def build_context(fam_idx: int, c0_raw: float, c1_raw: float,
+                  b_raw: float, err: float, b_norm: float) -> dict:
+    fam    = FORMULA_FAMILIES[fam_idx]
+    status = "SETTLED" if err < 2 else ("APPROXIMATE" if err < 5 else "UNSTABLE")
+
+    prompt = (
+        f"You are an analytical assistant. "
+        f"A constraint-diffusion engine has retraced hidden variables from an observed outcome.\n\n"
+        f"DOMAIN: {fam['name']}\n"
+        f"RULE: {fam['rule_text']}\n\n"
+        f"OBSERVED OUTCOME (B): {b_raw:.4f}\n"
+        f"ENGINE STATUS: {status}  (verification error: {err:.3f}%)\n\n"
+        f"RETRACED HIDDEN VARIABLES (C):\n"
+        f"  {fam['c_ranges'][0]}: {c0_raw:.3f}\n"
+        f"  {fam['c_ranges'][1]}: {c1_raw:.3f}\n\n"
+        f"Explain in plain language what these hidden variables mean in context, "
+        f"why they produce the observed outcome, and what the result implies about the system state."
     )
+    return {"rule": fam["rule_text"], "b": b_raw, "c0": c0_raw, "c1": c1_raw,
+            "error_pct": err, "status": status, "prompt": prompt}
 
-if __name__ == "__main__":
-    demo.launch(share=False)
+
+def call_llm(context: dict) -> str:
+    if not LLM_CHAT_URL or _req is None:
+        return (
+            "LLM not connected (set LLM_CHAT_URL env var).\n\n"
+            "Context that would be sent:\n\n" + context["prompt"]
+        )
+    try:
+        log(f"Calling LLM at {LLM_CHAT_URL}/chat…")
+        resp = _req.post(
+            f"{LLM_CHAT_URL}/chat",
+            json={"message": context["prompt"]},
+            timeout=90
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        text = data.get("response") or data.get("text") or data.get("content") or str(data)
+        log(f"LLM responded ({len(text)} chars)", "OK")
+        return text
+    except Exception as e:
+        log(f"LLM call failed: {e}", "ERROR")
+        return f"LLM call failed: {e}\n\nContext:\n{context['prompt']}"
+
+
+def run_llm_on_eval_results():
+    """After self-eval, send the best settled result to the LLM for interpretation."""
+    if not _eval_results:
+        log("No eval results to send to LLM", "WARN"); return
+    settled = [r for r in _eval_results if r["passed"]]
+    if not settled:
+        log("No settled results to send to LLM", "WARN"); return
+
+    best = min(settled, key=lambda r: r["error_pct"])
+    fam_idx = next(i for i,f in enumerate(FORMULA_FAMILIES) if f["name"] == best["formula"])
+    ctx = build_context(fam_idx, best["c0_pred"], best["c1_pred"],
+                        best["b_target"], best["error_pct"], best["b_norm"])
+    log(f"Sending best result ({best['formula']}, err={best['error_pct']}%) to LLM…")
+    response = call_llm(ctx)
+    log("── LLM RESPONSE ──────────────────────────────────", "HEAD")
+    for line in response.split("\n"):
+        log(f"  {line}")
+    log("──────────────────────────────────────────────────", "HEAD")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 10. LAUNCH  — background thread, then Gradio or console
+# ─────────────────────────────────────────────────────────────────────────────
+
+def pipeline_thread():
+    run_full_pipeline(seed=42)
+    run_llm_on_eval_results()
+
+log("Launching pipeline in background thread…", "HEAD")
+threading.Thread(target=pipeline_thread, daemon=True).start()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 11. GRADIO UI
+# ─────────────────────────────────────────────────────────────────────────────
+
+if GR_OK:
+    def get_phase_md():
+        p = _train_state["phase"]
+        icons = {"idle":"⏸","fetching":"🌐","training":"🧠",
+                 "evaluating":"🔬","done":"✅","error":"❌"}
+        ep   = _train_state.get("epoch", 0)
+        loss = _train_state.get("loss")
+        l    = f"  loss={loss}" if loss else ""
+        return f"## {icons.get(p,'❓')} **{p.upper()}**  epoch={ep}/{EPOCHS}{l}"
+
+    def get_log_str():
+        return "\n".join(_LOG_LINES[-80:])
+
+    def get_table():
+        if not _eval_results: return []
+        return [[r["formula"], r["b_target"],
+                 f"{r['c0_pred']} (true {r['c0_true']})",
+                 f"{r['c1_pred']} (true {r['c1_true']})",
+                 r["b_verified"], f"{r['error_pct']}%",
+                 "✅" if r["passed"] else "❌"] for r in _eval_results]
+
+    def ui_query(rule, b_val):
+        if _engine is None:
+            return "Engine not ready yet.", ""
+        try:
+            fam = next((f for f in FORMULA_FAMILIES if f["name"] in rule.lower()), FORMULA_FAMILIES[1])
+            fam_idx = FORMULA_FAMILIES.index(fam)
+            b_norm = float(b_val) / fam["b_norm"]
+            b_norm = max(0.01, min(0.99, b_norm))
+            c0, c1, _ = retrace(rule, b_norm)
+            c0r = c0*(fam["c_ranges"][0][1]-fam["c_ranges"][0][0])+fam["c_ranges"][0][0]
+            c1r = c1*(fam["c_ranges"][1][1]-fam["c_ranges"][1][0])+fam["c_ranges"][1][0]
+            b_v = fam["forward"]([c0r, c1r])
+            err = abs(b_v - float(b_val)) / max(abs(float(b_val)), 1e-6) * 100
+            ctx = build_context(fam_idx, c0r, c1r, float(b_val), err, b_norm)
+            raw = json.dumps({k:v for k,v in ctx.items() if k!="prompt"}, indent=2)
+            llm = call_llm(ctx)
+            return raw, llm
+        except Exception as e:
+            return f"Error: {e}\n{traceback.format_exc()}", ""
+
+    with gr.Blocks(title="Universal Constraint Engine v2", theme=gr.themes.Monochrome()) as demo:
+        gr.Markdown("# 🧠 Universal Constraint Engine v2\nA=constraint text, B=observed, C=retraced hidden vars")
+        phase_md = gr.Markdown(get_phase_md())
+
+        with gr.Tabs():
+            with gr.Tab("📊 Evaluation Results"):
+                tbl = gr.Dataframe(
+                    headers=["Formula","B target","C0 pred","C1 pred","B verified","Error","Pass"],
+                    value=get_table(), interactive=False, wrap=True)
+
+            with gr.Tab("🔍 Live Query"):
+                rule_box = gr.Textbox(label="Rule / Constraint text", value=FORMULA_FAMILIES[1]["rule_text"], lines=3)
+                b_box    = gr.Number(label="Observed B (raw, not normalised)", value=450.0)
+                go_btn   = gr.Button("Retrace →", variant="primary")
+                with gr.Row():
+                    raw_out = gr.Code(label="Structured context (JSON)", language="json", lines=14)
+                    llm_out = gr.Textbox(label="LLM interpretation", lines=14)
+                go_btn.click(ui_query, [rule_box, b_box], [raw_out, llm_out])
+
+            with gr.Tab("📋 Live Log"):
+                log_box = gr.Textbox(value=get_log_str(), lines=28, interactive=False, autoscroll=True)
+
+        timer = gr.Timer(value=3)
+        timer.tick(fn=lambda: (get_phase_md(), get_log_str(), get_table()),
+                   outputs=[phase_md, log_box, tbl])
+
+    if __name__ == "__main__":
+        demo.launch(share=False)
+
+else:
+    # No Gradio — block main thread so the daemon pipeline thread keeps running
+    if __name__ == "__main__":
+        log("Gradio not available — watching pipeline in console. Ctrl+C to stop.")
+        while _train_state["phase"] not in ("done", "error"):
+            time.sleep(5)
+        log("Pipeline finished. Final log above.")