Upload folder using huggingface_hub

Dockerfile

@@ -6,3 +6,5 @@ COPY server.py ./server.py
 COPY index.html ./index.html
 EXPOSE 7860
 CMD ["python", "-u", "server.py"]
+COPY energy.py ./energy.py
+COPY kernel.py ./kernel.py

energy.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+# Signed-off-by: Lutar, Stephen P. <stephenlutar2@gmail.com>
+"""Energy probe. Channel is always LIVE. Joules MEASURED only from RAPL or NVML."""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+POWERCAP = Path("/sys/class/powercap")
+RAPL = Path("/sys/class/powercap/intel-rapl:0/energy_uj")
+
+
+def _rapl_uj() -> int | None:
+    candidates: list[Path] = [RAPL]
+    try:
+        if POWERCAP.is_dir():
+            candidates.extend(sorted(POWERCAP.glob("intel-rapl:*/energy_uj")))
+            candidates.extend(sorted(POWERCAP.glob("intel-rapl:*:*/energy_uj")))
+    except OSError:
+        pass
+    seen: set[Path] = set()
+    for path in candidates:
+        if path in seen:
+            continue
+        seen.add(path)
+        try:
+            if path.is_file():
+                return int(path.read_text().strip())
+        except (OSError, ValueError):
+            continue
+    return None
+
+
+def _nvml_mj() -> float | None:
+    try:
+        import pynvml  # type: ignore
+    except ImportError:
+        return None
+    try:
+        pynvml.nvmlInit()
+        handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+        mj = float(pynvml.nvmlDeviceGetTotalEnergyConsumption(handle))
+        pynvml.nvmlShutdown()
+        return mj
+    except Exception:
+        try:
+            pynvml.nvmlShutdown()
+        except Exception:
+            pass
+        return None
+
+
+def _unavailable(note: str) -> dict[str, Any]:
+    return {
+        "channel": "LIVE",
+        "honesty": "UNAVAILABLE",
+        "source": None,
+        "package_energy_j": None,
+        "sample_delta_j": None,
+        "inference_energy_j": None,
+        "energy_j": None,
+        "note": note,
+    }
+
+
+def probe(*, sample_s: float = 0.05) -> dict[str, Any]:
+    """Return MEASURED package energy if hardware exists, else UNAVAILABLE.
+
+    The probe channel is always LIVE. A RAPL counter is package energy, not
+    tokens/joule. Inference joules are only MEASURED when a kernel run is
+    wrapped in a RAPL/NVML delta. Never a fabricated joule.
+    """
+    a = _rapl_uj()
+    if a is not None:
+        time.sleep(max(0.0, sample_s))
+        b = _rapl_uj()
+        if b is None:
+            b = a
+        delta_j = max(0.0, (b - a) / 1_000_000.0)
+        return {
+            "channel": "LIVE",
+            "honesty": "MEASURED",
+            "source": "intel-rapl",
+            "package_energy_j": b / 1_000_000.0,
+            "sample_delta_j": delta_j,
+            "inference_energy_j": None,
+            "energy_j": None,
+            "note": "RAPL package counter MEASURED. Inference joule still None until a kernel is wrapped.",
+        }
+    mj = _nvml_mj()
+    if mj is not None:
+        return {
+            "channel": "LIVE",
+            "honesty": "MEASURED",
+            "source": "nvml",
+            "package_energy_j": mj / 1000.0,
+            "sample_delta_j": None,
+            "inference_energy_j": None,
+            "energy_j": None,
+            "note": "NVML total energy MEASURED. Inference joule still None until a kernel is wrapped.",
+        }
+    return _unavailable("No RAPL, no NVML. Channel is live. Never a fabricated joule.")
+
+
+def measure_run(fn):
+    """Wrap a kernel. If RAPL/NVML exists, inference_energy_j is MEASURED."""
+    a = _rapl_uj()
+    nv_a = _nvml_mj()
+    t0 = time.perf_counter()
+    result = fn()
+    dt = time.perf_counter() - t0
+    b = _rapl_uj()
+    nv_b = _nvml_mj()
+    energy = probe(sample_s=0.0)
+    energy["channel"] = "LIVE"
+    energy["duration_s"] = dt
+    if a is not None and b is not None:
+        energy["honesty"] = "MEASURED"
+        energy["source"] = "intel-rapl"
+        energy["inference_energy_j"] = max(0.0, (b - a) / 1_000_000.0)
+        energy["energy_j"] = energy["inference_energy_j"]
+        energy["note"] = f"RAPL delta around kernel · {dt:.4f}s"
+    elif nv_a is not None and nv_b is not None:
+        energy["honesty"] = "MEASURED"
+        energy["source"] = "nvml"
+        energy["inference_energy_j"] = max(0.0, (nv_b - nv_a) / 1000.0)
+        energy["energy_j"] = energy["inference_energy_j"]
+        energy["note"] = f"NVML delta around kernel · {dt:.4f}s"
+    return result, energy

kernel.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+# Signed-off-by: Lutar, Stephen P. <stephenlutar2@gmail.com>
+"""Command-lab fail-closed integrity kernel.
+
+Stdlib only. Real SHA-256. Advisory Λ. Energy UNAVAILABLE.
+Locked-proven stays exactly 8. Λ uniqueness is Conjecture 1 OPEN.
+proven_trust is False. Not a-11-oy.com. Not an ATO.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from datetime import datetime, timezone
+from typing import Any, Sequence
+
+LOCKED_EIGHT = ("F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22")
+YUYAY_FLOORS = (0.95, 0.95) + (0.90,) * 11
+ZERO = "0" * 64
+CHAIN_OPS = ("anatomy.brain", "anatomy.heart", "anatomy.skeleton")
+proven_trust = False
+
+
+def _sha256_hex(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def wgm(xs: Sequence[float], ws: Sequence[float]) -> float:
+    if len(xs) != len(ws) or not xs:
+        return 0.0
+    if any((not math.isfinite(x)) or x <= 0.0 for x in xs):
+        return 0.0
+    if any((not math.isfinite(w)) or w < 0.0 for w in ws):
+        return 0.0
+    if abs(sum(ws) - 1.0) >= 1e-9:
+        return 0.0
+    value = math.exp(sum(w * math.log(x) for x, w in zip(xs, ws)))
+    return value if math.isfinite(value) else 0.0
+
+
+def evaluate_lambda(axes: Sequence[float]) -> dict[str, Any]:
+    n = len(axes)
+    weights = tuple(1.0 / n for _ in range(n)) if n else ()
+    value = wgm(axes, weights)
+    blocked = value == 0.0
+    return {
+        "value": float(value),
+        "blocked": bool(blocked),
+        "reason": "zero-routed" if blocked else "advisory pass — Conjecture 1 OPEN",
+    }
+
+
+def yawar_chain(seed: int, tamper: bool) -> dict[str, Any]:
+    hops = []
+    prev = ZERO
+    for seq, op in enumerate(CHAIN_OPS):
+        material = f"{seq}|{op}|{prev}|{int(seed)}"
+        digest = _sha256_hex(material)
+        hops.append({"seq": seq, "op": op, "prev": prev, "digest": digest})
+        prev = digest
+    if tamper and len(hops) > 1:
+        hops[1] = dict(hops[1])
+        hops[1]["prev"] = "deadbeef" + hops[1]["prev"][8:]
+    walk = ZERO
+    ok = True
+    brk = None
+    for hop in hops:
+        expect = _sha256_hex(f"{hop['seq']}|{hop['op']}|{hop['prev']}|{int(seed)}")
+        if hop["prev"] != walk or expect != hop["digest"]:
+            ok = False
+            brk = int(hop["seq"])
+            break
+        walk = hop["digest"]
+    return {"hops": hops, "ok": ok, "head": hops[-1]["digest"] if hops else ZERO, "break_at": brk, "alg": "SHA-256"}
+
+
+def evaluate_anatomy(*, zero_heart: bool = False, tamper_chain: bool = False, fabricate_joule: bool = False, seed: int = 11) -> dict[str, Any]:
+    if proven_trust is True:
+        raise RuntimeError("refusing proven_trust true")
+    axes = list(YUYAY_FLOORS)
+    if zero_heart:
+        axes[0] = 0.0
+    heart = evaluate_lambda(axes)
+    chain = yawar_chain(int(seed), bool(tamper_chain))
+    organs = [
+        {"name": "BRAIN", "status": "LIVE", "honesty": "LIVE"},
+        {"name": "HEART", "status": "DOWN" if heart["blocked"] else "LIVE", "honesty": "ADVISORY"},
+        {"name": "CIRCULATORY", "status": "DOWN" if not chain["ok"] else "LIVE", "honesty": "LIVE"},
+        {"name": "NERVOUS", "status": "DOWN" if fabricate_joule else "LIVE", "honesty": "UNAVAILABLE"},
+        {"name": "SKELETON", "status": "LIVE", "honesty": "ADVISORY"},
+    ]
+    live = sum(1 for o in organs if o["status"] == "LIVE")
+    blocked = any(o["status"] == "DOWN" for o in organs)
+    return {
+        "organs": organs,
+        "live_count": live,
+        "blocked": blocked,
+        "verdict": "BLOCKED" if blocked else "ADVISORY_BODY",
+        "energy": "UNAVAILABLE",
+        "energy_j": None,
+        "conjecture_1": "OPEN",
+        "locked_proven": 8,
+        "locked_ids": list(LOCKED_EIGHT),
+        "proven_trust": False,
+        "chain_head": chain["head"],
+        "reason": (
+            f"organ integrity {live}/5 LIVE · Λ advisory · energy UNAVAILABLE · Conjecture 1 OPEN"
+            if not blocked
+            else "organ integrity FAIL · fail closed"
+        ),
+        "checked_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
+    }
+
+
+def selftest() -> dict[str, Any]:
+    healthy = evaluate_anatomy(seed=11)
+    assert healthy["live_count"] == 5
+    assert healthy["blocked"] is False
+    assert healthy["energy"] == "UNAVAILABLE"
+    assert healthy["proven_trust"] is False
+    z = evaluate_anatomy(zero_heart=True)
+    assert z["blocked"] is True
+    t = evaluate_anatomy(tamper_chain=True)
+    assert t["blocked"] is True
+    j = evaluate_anatomy(fabricate_joule=True)
+    assert j["blocked"] is True
+    return {"ok": True, "cases": 4, "healthy_head": healthy["chain_head"]}
+
+
+if __name__ == "__main__":
+    print(json.dumps(selftest(), indent=2))