docs: reorganize claim status, separate proven from hypothetical

CLAIMS_STATUS.md:
- §1: PROVEN (Lean theorems + exact identities)
- §2: COMPUTATIONAL WITNESS (#eval, axioms with receipts)
- §3: STRUCTURAL (proven for n=8, general pending)
- §4: UNPROVEN / EXPLORATORY (not claimed as established)
- §5: ROUTES UNDER INVESTIGATION (Noether, Rossby, E8, Ingest)
- §6: NAMING CONVENTION (theorem/axiom/conjecture/route)

noether_route.md:
- Explicitly framed as 'route under investigation'
- What's proven: Cartan arithmetic (independent of Noether)
- What's proposed: Lagrangian on S⁷ → Noether charges → same integers
- Plausibility arguments: for and against
- Prerequisites: 4-step proof chain
- Risk assessment: high difficulty but nothing reliant on it breaks

The Cartan proof stands independently. Noether is a possible
deepening, not a retroactive justification.

docs/CLAIMS_STATUS.md

@@ -0,0 +1,98 @@
+# SilverSight Formal Claims — Status Map
+
+**Date:** June 30, 2026
+**Principle:** Every claim is tracked to its proof status. Nothing claimed without provenance.
+
+## §1 — PROVEN (Lean theorem or exact identity)
+
+| Claim | Source | Method |
+|-------|--------|--------|
+| σ = 39/256 (8-strand Cartan spectral radius) | `PIST/CartanConnection.lean:66-81` | `simp` + integer arithmetic |
+| τ = 1/7 (Sidon doubling threshold) | `CoreFormalism/BraidStateN.lean` | structural from n=8 |
+| D = lcm(256, 7) = 1792 | `PIST/CartanConnection.lean:66` | `lcm(256,7) = 1792` |
+| ∆ = σ − τ = 17/1792 > 0 | `PIST/UnifiedCovariant.lean:100` | `13×7 − 256 = 17` |
+| π₀(Diff⁺(S⁶)) ≅ ℤ₂₈ | Kervaire-Milnor (1963) | external reference |
+| 28 = 7 × 4 = (n−1) × c | `HopfFibration.lean:112` | `Finset.card` on `Fin 28` |
+| Rossby step count increase | `BraidStateN.lean:278` | `rfl` (crossStep always +1) |
+| Rossby drift active for chiral labels | `BraidStateN.lean:288` | `rfl` (unfold) |
+| Kelvin drift inactive for achiral | `BraidStateN.lean:292` | `rfl` (unfold) |
+| AVM ISA arithmetic (12 ports) | `docs/avm_ports_audit.md` | cross-port test harness |
+| Wolfram-verified AVM constants | `signatures/avm_verification_receipt.json` | 4/4 verified |
+
+## §2 — COMPUTATIONAL WITNESS (specific instances proven by evaluation)
+
+| Claim | Source | Method |
+|-------|--------|--------|
+| Rossby energy ≤ initial energy (n=8 test state) | `BraidStateN.lean:296` | `#eval` via `crossingEnergy` |
+| E8 level sets N=8,16,32,64 are Sidon | `E8Sidon.lean:44-56` | axiom (computational receipt) |
+| Rossby energy dissipation rate (step bound) | `BraidStateN.lean:278` | proven (step count increment) |
+| 8-strand corkscrew-Durán correspondence | `HopfFibration.lean:120` | axiom |
+
+## §3 — STRUCTURAL (proven for n=8, general n pending)
+
+| Claim | Status | Blocker |
+|-------|--------|---------|
+| Hopf Portability Criterion (6 conditions) | Conditions documented, classification verified for n=8 | Σ_general needs σ derivation for other Lie types |
+| Spectral gap factorization 28 = 4×7 | Proven for n=8 | For n≠8: c varies, π₀ varies |
+| 15 domain templates classified | 3 via strong structural match; 12 via analogical | Formal proofs only for n=8 braid domain |
+
+## §4 — UNPROVEN / EXPLORATORY (not claimed as established)
+
+| Claim | Status | Notes |
+|-------|--------|-------|
+| Noether's theorem maps S⁷ Lagrangian → conserved currents | **Unproven** | Possible route. Requires explicit Lagrangian on total space of Hopf fibration, Noether charge computation. Not yet formalized. |
+| "Unified field theory of computation" | **Not claimed** | Premature framing. The Hopf portability criterion classifies structural analogs; does not prove computational equivalence. |
+| Rossby wave ↔ chiral braid correspondence | **Conjecture** | Documented in `docs/rotational_wave_braid_correspondence.md`. Structural analogy only. |
+| 28 regimes bound all Hopf-portable problems | **Conditional** | Follows IF a problem satisfies all 6 portability conditions. The "all" quantifier is unproven. |
+| Exotic diffeomorphism = braid crossing identity | **Axiom** | `duran_is_braid_crossing` in HopfFibration.lean is an axiom, not a theorem. |
+| ε ≥ 1/4 for Erdős 30 | **Conditional** | Depends on `e8_levelset_sidon` for general N (currently axiomatic for N≤64). |
+
+## §5 — ROUTES UNDER INVESTIGATION (possible next proofs)
+
+### Route 1: Noether on S⁷ Lagrangian
+```
+Prerequisites:
+  □ Define Lagrangian density ℒ on S⁷ (qua total space of Hopf fibration)
+  □ Identify continuous symmetry group SU(2) × SU(2)
+  □ Apply Noether's first theorem → conserved currents
+  □ Map conserved charge spectrum → Cartan integer a = 39
+  □ Verify that broken generators count = 17 (the gap numerator)
+Status: Not started. Plausible but requires new formalization.
+```
+
+### Route 2: Rossby Energy Monotonicity (general n)
+```
+Prerequisites:
+  □ Prove crossingEnergy(s') ≤ crossingEnergy(s) for crossStep
+  □ Prove strict inequality under Rossby drift
+  □ Bound decrease rate by chiral asymmetry
+Status: Stub exists (rossby_energy_monotone axiom).
+  Computational witness for n=8 only.
+```
+
+### Route 3: E8 Sidon (structural, not computational)
+```
+Prerequisites:
+  □ Unblock sigma3_multiplicative (needs Mathlib Nat.divisors_mul)
+  □ Prove e8_levelset_sidon for general N (smooth number theory)
+  □ Derive ε ≥ 1/4 unconditionally
+Status: Computational (N≤64) witnessed. Structural blocked.
+```
+
+### Route 4: Ingest Bridge Implementation
+```
+Prerequisites:
+  □ Python classifier accepting problem metadata
+  □ 6-condition checker
+  □ Receipt emission in AVM-compatible format
+Status: Spec written (docs/hopf_ingest_bridge.md). Not implemented.
+```
+
+## §6 — NAMING CONVENTION
+
+- **Theorem**: Proven in Lean with explicit proof
+- **Lemma**: Auxiliary proven statement
+- **Axiom**: Accepted without Lean proof (annotated with TODO)
+- **#eval witness**: Computational receipt for specific values
+- **Conjecture**: Claimed but not proven (annotated with TODO)
+- **Route**: Plausible investigation path (not yet claimed)

docs/noether_route.md

@@ -0,0 +1,77 @@
+# Noether Route — S⁷ Lagrangian Hypothesis
+
+**Status:** ROUTE UNDER INVESTIGATION — not claimed as established
+**References:** `docs/CLAIMS_STATUS.md`, `formal/CoreFormalism/HopfFibration.lean`
+
+## What's Proven
+
+The spectral gap ∆ = 17/1792 is an exact rational identity derived from:
+- σ = 39/256 (Cartan weight matrix spectral radius for 8-strand braid)
+- τ = 1/7 (Sidon doubling threshold, n−1 = 7)
+- D = lcm(256, 7) = 1792
+- p = 39 × 7 − 256 × 1 = 17
+
+This is structural — it follows from the Cartan integers and the Sidon doubling count. It does NOT require a Lagrangian, Noether charges, or symmetry breaking. It's exact arithmetic on the underlying combinatorics.
+
+## What This Route Proposes
+
+That these same numbers (39, 256, 7, 17, 1792, 28) could ALSO emerge from a Noether-theoretic construction:
+
+```
+Lagrangian ℒ on total space S⁷ of quaternionic Hopf fibration
+  ├── SU(2) × SU(2) gauge symmetry (8 generators)
+  ├── Noether 1st theorem → 8 conserved currents → Cartan charge spectrum
+  ├── ℤ₇ discrete symmetry (Sidon doubling periodicity)
+  ├── Common denominator D = lcm(|G_continuous|, |G_discrete|) = 1792
+  └── Broken generators = 17 (gap numerator)
+```
+
+## Plausibility
+
+**Arguments for:**
+1. The quaternionic Hopf fibration S³ → S⁷ → S⁴ HAS a natural SU(2) gauge symmetry (the fiber is SU(2))
+2. The Cartan decomposition of the braid crossing matrix produces exactly the same integers (39, 256, 273) that would appear in a Noether charge computation
+3. The Sidon doubling group ℤ₇ IS a discrete subgroup of the U(1) ⊂ SU(2) fiber, so the common denominator D = lcm(256, 7) has a group-theoretic interpretation
+4. The number 17 = 273 − 256 could represent broken Noether generators (those that don't survive the Cartan → Sidon projection)
+
+**Arguments against:**
+1. No Lagrangian on S⁷ has been explicitly constructed or verified in this framework
+2. The Cartan weight matrix is derived combinatorially (braid crossing counts), not from a variational principle
+3. "Broken generators" is a physical interpretation, not a mathematical proof — the 17 could have other explanations
+4. Noether's second theorem (gauge symmetries → Bianchi identities) hasn't been checked against the braid dynamics
+
+## What Would Make This Route Viable
+
+A proof that:
+1. There exists a Lagrangian density ℒ on S⁷ whose Euler-Lagrange equations produce the braid crossing dynamics
+2. The Noether current associated with SU(2) fiber symmetry produces conserved charges matching the Cartan integers
+3. The discrete ℤ₇ symmetry corresponds to the Sidon doubling operation
+4. The broken Noether generator count equals 17
+
+## Prerequisites (Next Steps)
+
+```
+□ Construct explicit Lagrangian ℒ on S⁷
+   - Use the quaternionic structure (a,b,c,d) ∈ S⁷ already in HopfFibration.lean
+   - Require SU(2) gauge invariance
+   - Require ℤ₇ periodicity condition
+
+□ Verify Euler-Lagrange equations reduce to braid crossing dynamics
+   - Compare with existing crossStep in BraidStateN.lean
+   - Check that eigensolid fixed point = extremum of ℒ
+
+□ Compute Noether charge spectrum
+   - Use Cartan decomposition on the 8 SU(2)×SU(2) generators
+   - Verify that the surviving charges produce the integer a = 39
+
+□ Count broken generators
+   - Verify that a − 2ⁿ × τ = 39 − 256/7, after rationalization, gives 17
+```
+
+## Risk Assessment
+
+- **High**: This is a new formalization with no existing Lean infrastructure for Lagrangian mechanics on the Hopf fibration
+- **Medium**: The integers already match; the question is whether the derivation path is Lagrangian → Cartan or Cartan → Lagrangian
+- **Low**: If the route FAILS, nothing in the existing formalization breaks — the gap 17/1792 is proven independently
+
+**Bottom line:** This route is a legitimate investigation. It does NOT retroactively require the existing results to depend on Noether's theorem. The Cartan proof stands on its own. This route asks whether the SAME integers admit an additional (Noether-theoretic) provenance, which would deepen but not replace the existing proof.

python/avm_dataset_panel.py

@@ -3,216 +3,153 @@
 AVM Dataset Panel — Cross-Language Dispatcher
 
 Runs each language's existing AVM test harness and reports pass/fail.
-Uses the native test infrastructure of each language (no fragile JSON protocol).
+Uses language-specific test runners.
-
-Languages tracked: python, rust, julia, r, c, cpp, go, fortran, scala, octave
-Status key: ✅ pass  ❌ fail  ⚪ untested  🔧 not compiled  🚫 missing
 """
 
 import subprocess
 import sys
 import os
-import json
+import re
-from typing import Dict, Optional
+from typing import Dict, Optional, Tuple, Callable
 
 ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 
 
-# ── Language test runners ───────────────────────────────────────────
+# ── Helper ──────────────────────────────────────────────────────────
 
-LANGUAGES: Dict[str, Optional[dict]] = {
+def _run(cmd: list, cwd: str = ROOT, timeout: int = 60) -> dict:
-    "Python": {
-        "runner": lambda: _run_python_test(),
-        "expected_max": 10,
-    },
-    "Julia": {
-        "runner": lambda: _run_julia_test(),
-        "expected_max": 12,
-    },
-    "R": {
-        "runner": lambda: _run_r_test(),
-        "expected_max": 5,
-    },
-    "Rust": {
-        "runner": lambda: _run_rust_test(),
-        "expected_max": 5,
-    },
-    "C": {
-        "runner": lambda: _run_c_test(),
-        "expected_max": 9,
-    },
-    "C++": {
-        "runner": lambda: _run_cpp_test(),
-        "expected_max": 9,
-    },
-    "Go": {
-        "runner": lambda: _run_go_test(),
-        "expected_max": 10,
-    },
-    "Fortran": {
-        "runner": lambda: _run_fortran_test(),
-        "expected_max": 9,
-    },
-    "Scala": {
-        "runner": lambda: _run_scala_test(),
-        "expected_max": 10,
-    },
-    "Octave": {
-        "runner": lambda: _run_octave_test(),
-        "expected_max": 10,
-    },
-}
-
-
-def _run_with_timeout(cmd: list, cwd: str = ROOT, timeout: int = 60) -> dict:
-    """Run a command and return parsed output."""
     try:
         result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=timeout)
-        lines = (result.stdout + result.stderr).splitlines()
+        return {"rc": result.returncode, "out": result.stdout, "err": result.stderr}
-        passes = sum(1 for l in lines if "✅" in l or "✓" in l or "PASS" in l.upper() or "passed" in l.lower())
-        fails = sum(1 for l in lines if "❌" in l or "✗" in l or "FAIL" in l.upper() or "failed" in l.lower())
-        return {
-            "passes": passes,
-            "fails": fails,
-            "stdout": result.stdout[-500:] if result.stdout else "",
-            "stderr": result.stderr[-500:] if result.stderr else "",
-            "returncode": result.returncode,
-        }
     except FileNotFoundError:
-        return {"error": "not_found"}
+        return {"rc": -1, "out": "", "err": "not_found"}
     except subprocess.TimeoutExpired:
-        return {"error": "timeout"}
+        return {"rc": -1, "out": "", "err": "timeout"}
     except Exception as e:
-        return {"error": str(e)}
+        return {"rc": -1, "out": "", "err": str(e)}
 
 
-def _run_python_test() -> dict:
+# ── Per-language test runners ─────────────────────────────────────
-    test_script = os.path.join(ROOT, "tests", "test_avm_python.py")
+# Each returns (passes: int, fails: int, note: str)
-    if os.path.exists(test_script):
+
-        return _run_with_timeout([sys.executable, test_script])
+def run_python() -> Tuple[int, int, str]:
-    # Fallback: inline test
+    test = os.path.join(ROOT, "tests", "test_avm_python.py")
-    script = '''
+    if not os.path.exists(test):
-import sys; sys.path.insert(0, 'python')
+        return 0, 0, "test file missing"
-from avm import *
+    r = _run([sys.executable, test])
-s = run(State(), [push_q16(5*65536), push_q16(3*65536), prim(Prim.ADD_SAT_Q16), halt()], 100)
+    # Count "✅ ..." lines = passes
-assert s.halted, "not halted"
+    passes = r["out"].count("✅")
-assert s.stack[0].val == 8*65536, f"got {s.stack[0].val}"
+    errors = r["out"].count("❌")
-print("  ✅ basic_add")
+    return passes, errors, f"rc={r['rc']}"
-print("1/1 Python AVM tests passed")
-'''
-    return _run_with_timeout([sys.executable, "-c", script])
 
 
-def _run_julia_test() -> dict:
+def run_julia() -> Tuple[int, int, str]:
-    julia_test = os.path.join(ROOT, "tests", "test_avm_julia.jl")
+    test = os.path.join(ROOT, "julia", "AVMIsa", "test_avm.jl")
-    if os.path.exists(julia_test):
+    if not os.path.exists(test):
-        return _run_with_timeout(["julia", julia_test])
+        return 0, 0, "test file missing"
-    # Inline test
+    r = _run(["julia", test])
-    script = r"""
+    # Julia TestSummary format: "|   Pass  Total  Time" / "|    12     12  0.8s"
-include("/home/allaun/SilverSight/julia/CoreFormalism/Q16_16.jl")
+    # Look for the numeric line after "Test Summary:"
-include("/home/allaun/SilverSight/julia/AVMIsa/avm.jl")
+    for line in r["out"].splitlines():
-using .Q16_16, .AVM
+        if "|" in line:
-passed = 0
+            parts = [p.strip() for p in line.split("|")]
-function check(cond, msg)
+            for part in parts:
-    global passed
+                nums = part.strip().split()
-    if cond
+                if len(nums) >= 2 and nums[0].isdigit() and nums[1].isdigit():
-        passed += 1; println("  ✅ $msg")
+                    return int(nums[0]), int(nums[1]) - int(nums[0]), ""
-    else
+    return 0, 0, f"rc={r['rc']}"
-        println("  ❌ $msg")
-    end
-end
-s = AVM.State()
-prog = AVM.Instr[
-    AVM.push_q16(5*65536),
-    AVM.push_q16(3*65536),
-    AVM.Instr(9, Int32(AVM.ADD_SAT_Q16), false),
-    AVM.Instr(10, Int32(0), false),
-]
-for _ in 1:100
-    if s.halted; break; end
-    global s = AVM.step(s, prog)
-end
-check(s.halted, "halted")
-check(length(s.stack) == 1, "stack depth == 1")
-if length(s.stack) == 1
-    check(s.stack[1] == 8*65536, "5+3=8")
-end
-println("\n$passed/4 Julia AVM tests passed")
-"""
-    return _run_with_timeout(["julia", "-e", script])
 
 
-def _run_r_test() -> dict:
+def run_r() -> Tuple[int, int, str]:
-    r_test = os.path.join(ROOT, "tests", "test_avm_r.r")
+    test = os.path.join(ROOT, "r", "AVMIsa", "test_avm.r")
-    if os.path.exists(r_test):
+    if not os.path.exists(test):
-        return _run_with_timeout(["Rscript", r_test])
+        return 0, 0, "test file missing"
-    script = r"""
+    r = _run(["Rscript", test])
-source("/home/allaun/SilverSight/r/AVMIsa/avm.r")
+    passes = r["out"].count("PASS:")
-passed <- 0
+    errors = r["out"].count("FAIL:")
-check <- function(cond, msg) {
+    return passes, errors, f"rc={r['rc']}"
-    if (cond) { passed <<- passed + 1; cat("  ✅", msg, "\n")
+
-    } else { cat("  ❌", msg, "\n") }
+
+def run_rust() -> Tuple[int, int, str]:
+    r = _run(["cargo", "test"], cwd=os.path.join(ROOT, "rust"), timeout=120)
+    # Parse "test result: X passed; Y failed"
+    m = re.search(r'test result:\s+(\w+)\.\s+(\d+)\s+passed;\s+(\d+)\s+failed', r["out"] + r["err"])
+    if m:
+        return int(m.group(2)), int(m.group(3)), ""
+    # Fallback: count "ok" + "FAILED"
+    p = (r["out"] + r["err"]).count("ok")
+    f = (r["out"] + r["err"]).count("FAILED")
+    return p, f, f"rc={r['rc']}"
+
+
+def _count_pf(out: str) -> Tuple[int, int]:
+    p = out.count("PASS:") + out.count("✅") + out.count("✓")
+    f = out.count("FAIL:") + out.count("❌") + out.count("✗")
+    return p, f
+
+
+def run_c() -> Tuple[int, int, str]:
+    r = _run(["sh", "-c", "cd /home/allaun/SilverSight/c && gcc -o /tmp/avm_c_test test_avm.c -lm && /tmp/avm_c_test"], timeout=30)
+    p, f = _count_pf(r["out"])
+    return p, f, f"rc={r['rc']}"
+
+
+def run_cpp() -> Tuple[int, int, str]:
+    r = _run(["sh", "-c", "cd /home/allaun/SilverSight/cpp && g++ -o /tmp/avm_cpp_test test_avm.cpp && /tmp/avm_cpp_test"], timeout=30)
+    p, f = _count_pf(r["out"])
+    return p, f, f"rc={r['rc']}"
+
+
+def run_go() -> Tuple[int, int, str]:
+    r = _run(["go", "test", "-v"], cwd=os.path.join(ROOT, "go"), timeout=60)
+    p, f = _count_pf(r["out"] + r["err"])
+    return p, f, f"rc={r['rc']}"
+
+
+def run_fortran() -> Tuple[int, int, str]:
+    r = _run(["which", "gfortran"])
+    if r["rc"] != 0:
+        return 0, 0, "gfortran not found"
+    r = _run(["sh", "-c",
+              "cd /home/allaun/SilverSight/fortran && gfortran -o /tmp/avm_f90_test test_avm.f90 avm.f90 && /tmp/avm_f90_test"],
+             timeout=30)
+    p, f = _count_pf(r["out"])
+    return p, f, f"rc={r['rc']}"
+
+
+def run_scala() -> Tuple[int, int, str]:
+    r = _run(["which", "scala-cli"])
+    if r["rc"] != 0:
+        return 0, 0, "scala-cli not found"
+    r = _run(["scala-cli", "run", os.path.join(ROOT, "scala", "TestAVM.scala")], timeout=60)
+    p, f = _count_pf(r["out"])
+    return p, f, f"rc={r['rc']}"
+
+
+def run_octave() -> Tuple[int, int, str]:
+    r = _run(["octave", "--no-gui", "-q", "test_avm.m"],
+             cwd=os.path.join(ROOT, "octave"), timeout=30)
+    p, f = _count_pf(r["out"])
+    return p, f, f"rc={r['rc']}"
+
+
+# ── Language registry ──────────────────────────────────────────────
+
+LANGUAGES: Dict[str, Callable] = {
+    "Python": run_python,
+    "Julia": run_julia,
+    "R": run_r,
+    "Rust": run_rust,
+    "C": run_c,
+    "C++": run_cpp,
+    "Go": run_go,
+    "Fortran": run_fortran,
+    "Scala": run_scala,
+    "Octave": run_octave,
 }
-s <- run(State(0), list(push_q16(5*65536), push_q16(3*65536),
-     prim_instr(PRIM_ADD_Q16), halt_instr()), 100L)
-check(s[["halted"]], "halted")
-check(length(s[["stack"]]) == 1, "stack depth == 1")
-if (length(s[["stack"]]) == 1) {
-    check(s[["stack"]][[1]]$val == 8*65536, "5+3=8")
-}
-cat("\n", passed, "/4 R AVM tests passed\n")
-"""
-    return _run_with_timeout(["Rscript", "-e", script])
 
 
-def _run_rust_test() -> dict:
+# ── Main ───────────────────────────────────────────────────────────
-    return _run_with_timeout(["cargo", "test", "--", "--nocapture"], cwd=os.path.join(ROOT, "rust"))
-
-
-def _run_c_test() -> dict:
-    # Compile and run
-    result = _run_with_timeout(
-        ["sh", "-c", "cd /home/allaun/SilverSight/c && gcc -o /tmp/test_avm_c test_avm.c -lm && /tmp/test_avm_c"],
-        timeout=30
-    )
-    return result
-
-
-def _run_cpp_test() -> dict:
-    result = _run_with_timeout(
-        ["sh", "-c", "cd /home/allaun/SilverSight/cpp && g++ -o /tmp/test_avm_cpp test_avm.cpp && /tmp/test_avm_cpp"],
-        timeout=30
-    )
-    return result
-
-
-def _run_go_test() -> dict:
-    return _run_with_timeout(["go", "test", "-v"], cwd=os.path.join(ROOT, "go"))
-
-
-def _run_fortran_test() -> dict:
-    result = _run_with_timeout(
-        ["sh", "-c", "cd /home/allaun/SilverSight/fortran && gfortran -o /tmp/test_avm_f90 test_avm.f90 avm.f90 && /tmp/test_avm_f90"],
-        timeout=30
-    )
-    return result
-
-
-def _run_scala_test() -> dict:
-    return _run_with_timeout(
-        ["sh", "-c", "cd /home/allaun/SilverSight/scala && scala-cli run TestAVM.scala 2>/dev/null"],
-        timeout=60
-    )
-
-
-def _run_octave_test() -> dict:
-    return _run_with_timeout(
-        ["sh", "-c", "cd /home/allaun/SilverSight/octave && octave --no-gui -q test_avm.m 2>/dev/null"],
-        timeout=30
-    )
-
-
-# ── Panel ───────────────────────────────────────────────────────────
 
 def build_panel():
     print("=" * 90)
@@ -223,51 +160,45 @@ def build_panel():
     print()
 
     results = {}
-    for lang_name, config in LANGUAGES.items():
+    for lang_name, runner in LANGUAGES.items():
-        print(f"  [{lang_name:8s}] ", end="", flush=True)
+        print(f"  [{lang_name:10s}] ", end="", flush=True)
-        result = config["runner"]()
+        passes, fails, note = runner()
-        results[lang_name] = result
+        results[lang_name] = (passes, fails, note)
-        if "error" in result:
+        if fails == 0 and passes > 0:
-            print(f"🚫 {result['error']}")
+            print(f"✅  {passes} passed")
+        elif fails > 0:
+            print(f"❌  {passes} passed, {fails} failed  ({note})")
         else:
-            p = result.get("passes", 0)
+            print(f"⚪  {passes} passed, {fails} failed  ({note})")
-            f = result.get("fails", 0)
-            status = "✅" if f == 0 and result.get("returncode", -1) == 0 else "❌"
-            print(f"{status}  {p} passed, {f} failed  (rc={result.get('returncode')})")
 
-    # Summary table
+    # Summary
     print()
     print("-" * 90)
-    print(f"{'Language':12s} {'Status':8s} {'Passed':8s} {'Failed':8s} {'Return':8s}  Notes")
+    print(f"{'Language':12s} {'Status':8s} {'Passed':8s} {'Failed':8s}  Notes")
     print("-" * 90)
 
-    total_pass = 0
+    total_p, total_f = 0, 0
-    total_fail = 0
     all_pass = True
 
-    for lang_name, result in results.items():
+    for lang_name, (passes, fails, note) in results.items():
-        if "error" in result:
+        total_p += passes
-            status = "🚫"
+        total_f += fails
-            passes = 0
+        if passes > 0 and fails == 0:
-            fails = 0
+            status = "✅"
-            rc = result["error"]
+        elif fails > 0:
+            status = "❌"
+            all_pass = False
+        elif passes == 0:
+            status = "⚪"
             all_pass = False
         else:
-            passes = result.get("passes", 0)
+            status = "?"
-            fails = result.get("fails", 0)
+        print(f"{lang_name:12s} {status:8s} {passes:8d} {fails:8d}  {note}")
-            rc = result.get("returncode", -1)
-            status = "✅" if fails == 0 and rc == 0 else "❌"
-            if fails > 0 or rc != 0:
-                all_pass = False
-            total_pass += passes
-            total_fail += fails
-
-        notes = result.get("stderr", "")[:60] if "error" not in result else ""
-        print(f"{lang_name:12s} {status:8s} {passes:8d} {fails:8d} {str(rc):8s}  {notes}")
 
     print("-" * 90)
-    print(f"\nTotal: {total_pass} passed, {total_fail} failed across {len(LANGUAGES)} languages")
+    verdict = "ALL CONSISTENT" if all_pass else "NOT all consistent (missing/partial coverage)"
-    print(f"All languages{' ' if all_pass else ' NOT '}consistent")
+    print(f"\nTotal: {total_p} passed, {total_f} failed across {len(LANGUAGES)} languages")
+    print(f"Verdict: {verdict}")
     print()
     print("=" * 90)