#!/usr/bin/env python3
"""Job-owned NOL compute worker. Stdlib-only until an explicit zero-token load.

Transport: uint32 big-endian UTF-8 JSON frames. Stdout is never a log stream.
The host owns GPU leasing, artifact publication, native receipts and grading.
This process reports observed facts; it cannot attest broker custody by itself.
"""
import contextlib
from decimal import Decimal
import gc
import hashlib
import importlib.metadata
import io
import json
import math
import os
from pathlib import Path
import re
import struct
import subprocess
import sys
import tempfile

PROTOCOL = "omnius.nol.worker.v1"
WORKER_VERSION = "omnius.nol.gne.v1"
MAX_FRAME = int(os.environ.get("OMNIUS_NOL_MAX_FRAME_BYTES", "1048576"))
WIRE_OUT = sys.stdout.buffer
OWNER = {"sessionId": os.environ.get("OMNIUS_NOL_WORKER_SESSION", ""),
         "jobId": os.environ.get("OMNIUS_NOL_JOB_ID", ""),
         "ownerId": os.environ.get("OMNIUS_NOL_OWNER_ID", ""),
         "generation": int(os.environ.get("OMNIUS_NOL_GENERATION", "0"))}
UUID = re.compile(r"^GPU-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
SHA = re.compile(r"^[a-f0-9]{64}$")
RUNTIME_OPS = {"NEURON_ADD", "NEURON_GAIN"}
GNE_REVISION = "b1ded91bf1ebd903f7229e4969cc764a418336a8"
NATIVE_CODE = re.compile(r"\.(?:py|pyd|dll|dylib|ptx|cubin)$|\.so(?:\.\d+)*$", re.IGNORECASE)


class Rejected(Exception):
    def __init__(self, code, message, fatal=False):
        super().__init__(message)
        self.code, self.fatal = code, fatal


def require(condition, message, code="INVALID_REQUEST"):
    if not condition:
        raise Rejected(code, message)


def fields(value, required, optional=()):
    require(type(value) is dict and set(required) <= value.keys() and not (value.keys() - set(required) - set(optional)), "Unknown or missing fields")


def integer(value, minimum=0, maximum=9007199254740991):
    require(type(value) is int and minimum <= value <= maximum, "Invalid bounded integer")
    return value


def number(value):
    require(type(value) in (int, float) and math.isfinite(value), "Nonfinite numeric value")
    return value


def unique_object(pairs):
    out = {}
    for key, value in pairs:
        require(key not in out, "Duplicate JSON object property")
        out[key] = value
    return out


def parse_json(raw):
    return json.loads(raw, object_pairs_hook=unique_object,
                      parse_int=lambda text: -0.0 if text == "-0" else int(text),
                      parse_constant=lambda _: (_ for _ in ()).throw(Rejected("INVALID_JSON", "Nonfinite JSON number")))


def canonical_simple(value):
    """Only used for runtime/file inventories containing strings and integers.
    Scientific records arrive with their exact host-canonical identity bodies.
    """
    return json.dumps(value, sort_keys=True, ensure_ascii=False, separators=(",", ":"), allow_nan=False)


def digest_bytes(value):
    return hashlib.sha256(value).hexdigest()


def hash_file(path, maximum=None):
    path = Path(path)
    require(path.is_file() and not path.is_symlink(), "Input must be a regular nonsymlink file")
    before = path.stat()
    require(maximum is None or before.st_size <= maximum, "File byte budget exceeded", "CAPACITY")
    h, size = hashlib.sha256(), 0
    with path.open("rb") as stream:
        opened = os.fstat(stream.fileno())
        require((opened.st_dev, opened.st_ino) == (before.st_dev, before.st_ino), "File identity changed")
        while True:
            block = stream.read(1024 * 1024)
            if not block:
                break
            h.update(block)
            size += len(block)
            require(size <= before.st_size and (maximum is None or size <= maximum), "File grew beyond its frozen byte bound", "CAPACITY")
        after = os.fstat(stream.fileno())
    require((before.st_size, before.st_mtime_ns, before.st_ctime_ns) ==
            (size, after.st_mtime_ns, after.st_ctime_ns), "File changed while hashing")
    return {"sha256": h.hexdigest(), "sizeBytes": size}


def safe_path(root, relative):
    require(type(relative) is str and relative and not relative.startswith("/") and "\\" not in relative and "\0" not in relative,
            "Invalid relative file path")
    require(all(part not in ("", ".", "..") for part in relative.split("/")), "Invalid relative path component")
    root = Path(root).resolve(strict=True)
    current = root
    for part in relative.split("/"):
        current = current / part
        require(not current.is_symlink(), "Symlinks are not accepted in frozen input paths")
    require(current.resolve(strict=True).is_relative_to(root), "Input escaped its frozen root")
    return current


def same_json(left, right):
    if type(left) in (int, float) and type(right) in (int, float):
        return left == right and (left != 0 or math.copysign(1, left) == math.copysign(1, right))
    if type(left) is not type(right):
        return False
    if type(left) is dict:
        return left.keys() == right.keys() and all(same_json(left[key], right[key]) for key in left)
    if type(left) is list:
        return len(left) == len(right) and all(same_json(a, b) for a, b in zip(left, right))
    return left == right


def verify_identity(raw, expected, expected_hash):
    require(type(raw) is str and SHA.fullmatch(expected_hash or ""), "Missing exact identity body")
    require(digest_bytes(raw.encode("utf-8")) == expected_hash and same_json(parse_json(raw), expected), "Frozen identity digest/body mismatch", "IDENTITY")


def runtime_info(lock_path=None, hash_runtime=False, max_bytes=34359738368):
    packages, code = {}, []
    spent = 0
    for distribution in sorted(importlib.metadata.distributions(), key=lambda item: item.metadata.get("Name", "").lower()):
        name = distribution.metadata.get("Name", "")
        if not name:
            continue
        packages[name] = distribution.version
        if hash_runtime:
            entries = []
            for relative in sorted(distribution.files or [], key=str):
                if not NATIVE_CODE.search(str(relative)):
                    continue
                path = Path(distribution.locate_file(relative))
                # Symlinked libraries are rejected rather than silently hashing
                # a different native installation than the isolated runtime.
                actual = hash_file(path, max_bytes - spent)
                spent += actual["sizeBytes"]
                entries.append({"path": str(relative), **actual})
            code.append({"name": name, "digest": digest_bytes(canonical_simple(entries).encode()), "files": len(entries)})
    info = {"schema": "omnius.nol.gne-build.v1", "workerVersion": WORKER_VERSION,
            "workerSha256": hash_file(Path(__file__).resolve())["sha256"], "pythonVersion": sys.version.split()[0],
            "packages": packages, "packageCode": code,
            "pythonExecutableSha256": hash_file(Path(sys.executable).resolve())["sha256"]}
    if lock_path:
        info["dependencyLockDigest"] = hash_file(lock_path, 1048576)["sha256"]
    return info


def placement(uuid):
    rows = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,gpu_uuid,used_memory", "--format=csv,noheader,nounits"],
                          check=True, capture_output=True, timeout=10, text=True)
    require(len(rows.stdout.encode()) <= 1048576, "Placement inventory exceeds its byte bound")
    resident = [row.split(",") for row in rows.stdout.splitlines() if row.split(",")[0].strip() == str(os.getpid())]
    require(resident and all(row[1].strip() == uuid and float(row[2].strip()) > 0 for row in resident), "Actual CUDA residency differs from the reserved UUID", "PLACEMENT")
    stat = Path(f"/proc/{os.getpid()}/stat").read_text()
    return {"pid": os.getpid(), "gpuUuid": uuid, "startIdentity": stat[stat.rfind(")") + 2:].split()[19]}



def canonical_gguf(value):
    """Canonical JSON of GGUF tokenizer metadata, including float32 scores.
    Numeric formatting follows the host's finite binary64 JSON convention;
    scientific record identities still use exact host-canonical bodies.
    """
    if value is None:
        return "null"
    if type(value) is bool:
        return "true" if value else "false"
    if type(value) is str:
        return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
    if type(value) in (int, float):
        number(value)
        if value == 0:
            return "-0" if math.copysign(1, value) < 0 else "0"
        if type(value) is int:
            require(abs(value) < 1e21 and int(float(value)) == value, "GGUF integer cannot be represented exactly by the host JSON identity", "IDENTITY")
            return str(value)
        text = repr(value).lower()
        if 0.000001 <= abs(value) < 1e21:
            return format(Decimal(text), "f").rstrip("0").rstrip(".") if "." in format(Decimal(text), "f") else format(Decimal(text), "f")
        mantissa, exponent = text.split("e") if "e" in text else (text, "0")
        mantissa = mantissa.rstrip("0").rstrip(".") if "." in mantissa else mantissa
        exponent = int(exponent)
        return mantissa + "e" + ("+" if exponent >= 0 else "-") + str(abs(exponent))
    if type(value) is list:
        return "[" + ",".join(canonical_gguf(item) for item in value) + "]"
    require(type(value) is dict, "Unsupported GGUF metadata value")
    keys = sorted(value, key=lambda key: key.encode("utf-16-be", "surrogatepass"))
    return "{" + ",".join(canonical_gguf(key) + ":" + canonical_gguf(value[key]) for key in keys) + "}"


def gguf_metadata(path):
    """Read bounded metadata only. No GNE import, mmap, CUDA or generation."""
    budget = 64 * 1024 * 1024
    with Path(path).open("rb") as stream:
        def take(count):
            require(0 <= count <= budget and stream.tell() + count <= budget, "GGUF metadata byte bound exceeded", "CAPACITY")
            data = stream.read(count)
            require(len(data) == count, "Truncated GGUF metadata", "IDENTITY")
            return data
        def unpack(fmt):
            return struct.unpack("<" + fmt, take(struct.calcsize("<" + fmt)))[0]
        def string():
            return take(unpack("Q")).decode("utf-8", "strict")
        def value(kind, depth=0):
            formats = {0: "B", 1: "b", 2: "H", 3: "h", 4: "I", 5: "i", 6: "f", 7: "?", 10: "Q", 11: "q", 12: "d"}
            if kind == 8:
                return string()
            if kind == 9:
                require(depth < 2, "Nested GGUF metadata exceeds bound")
                item_kind, count = unpack("I"), unpack("Q")
                integer(count, 0, 2000000)
                return [value(item_kind, depth + 1) for _ in range(count)]
            require(kind in formats, "Unknown GGUF metadata type")
            result = unpack(formats[kind])
            if type(result) in (int, float):
                number(result)
            return result
        require(take(4) == b"GGUF" and unpack("I") in (2, 3), "Unsupported GGUF header", "IDENTITY")
        tensors, count = unpack("Q"), unpack("Q")
        integer(tensors, 1, 1000000)
        integer(count, 1, 1000000)
        metadata = {}
        for _ in range(count):
            key = string()
            require(key not in metadata, "Duplicate GGUF metadata field")
            metadata[key] = value(unpack("I"))
        dense, reserved = {}, set()
        for _ in range(tensors):
            name, dimensions = string(), unpack("I")
            require(name and dimensions <= 4, "Invalid GGUF tensor descriptor", "IDENTITY")
            for _ in range(dimensions): integer(unpack("Q"), 1)
            unpack("I"); unpack("Q")
            match = re.fullmatch(r"blk\.(\d+)\.(ffn_gate|ffn_up|ffn_down)\.weight", name)
            if match: dense.setdefault(int(match[1]), set()).add(match[2])
            match = re.match(r"blk\.(\d+)\.nextn\.", name)
            if match: reserved.add(int(match[1]))
    arch = metadata.get("general.architecture")
    require(type(arch) is str and arch, "GGUF architecture missing", "IDENTITY")
    tokenizer = {key: item for key, item in metadata.items() if key.startswith("tokenizer.") and not key.startswith("tokenizer.chat_template")}
    require(tokenizer and type(metadata.get("tokenizer.chat_template")) is str, "GGUF tokenizer/template metadata missing", "IDENTITY")
    layers = integer(metadata.get(arch + ".block_count"), 1)
    editable = sorted(layer for layer, names in dense.items() if names == {"ffn_gate", "ffn_up", "ffn_down"} and layer not in reserved)
    return {"metadata": metadata, "tokenizer": tokenizer, "template": metadata["tokenizer.chat_template"], "architecture": arch,
            "denseMlpLayers": editable, "unsupportedLayers": sorted(set(range(layers)) - set(editable)), "reservedLayers": sorted(reserved)}


def gguf_column_norms(path, requested, limits, expected_file, metadata):
    """Explicit CPU-only dequantization. Never import GNE, llama_cpp or torch."""
    fields(limits, ("maxWorkingBytes", "maxTensorBytes", "maxMultiplyAdds"))
    bounds = {key: integer(value, 1) for key, value in limits.items()}
    fields(expected_file, ("sha256", "sizeBytes"))
    require(SHA.fullmatch(expected_file["sha256"]), "Full checkpoint identity required", "IDENTITY")
    integer(expected_file["sizeBytes"], 1)
    require(type(requested) is list and 0 < len(requested) <= 64, "CPU column inventory exceeds its explicit bound", "CAPACITY")
    before = Path(path).stat()
    require(hash_file(path) == expected_file, "CPU column checkpoint differs from its complete frozen file identity", "IDENTITY")
    native_before = {name for name in sys.modules if name.split(".")[0] in ("gne", "llama_cpp", "torch")}
    import numpy as np
    from gguf import GGUFReader, GGMLQuantizationType
    from gguf import quants
    require({name for name in sys.modules if name.split(".")[0] in ("gne", "llama_cpp", "torch")} == native_before,
            "CPU column reader imported a native/model runtime", "IDENTITY")
    reader = GGUFReader(str(path), "r")
    tensors = {tensor.name: tensor for tensor in reader.tensors}
    require(len(tensors) == len(reader.tensors), "Duplicate GGUF tensor names", "IDENTITY")
    coordinates, planned, capture_bytes, arithmetic = set(), {}, 0, 0
    for item in requested:
        fields(item, ("layer", "neuron"))
        layer = integer(item["layer"])
        require(layer in metadata["denseMlpLayers"], "CPU column is not a supported dense normal decoder layer", "UNSUPPORTED")
        tensor = tensors.get(f"blk.{layer}.ffn_down.weight")
        require(tensor is not None and len(tensor.shape) == 2, "CPU down matrix is missing or not rank two", "IDENTITY")
        width, hidden = [integer(int(value), 1) for value in tensor.shape]
        neuron = integer(item["neuron"], 0, width - 1)
        require((layer, neuron) not in coordinates, "Duplicate CPU column coordinate")
        coordinates.add((layer, neuron))
        matrix_bytes = width * hidden * 4
        require(matrix_bytes * 4 + len(requested) * hidden * 16 <= bounds["maxWorkingBytes"], "CPU full down-matrix dequantization exceeds working-memory admission", "CAPACITY")
        capture_bytes += hidden * 8
        if layer not in planned: arithmetic += width * hidden * 4
        planned.setdefault(layer, {"tensor": tensor, "width": width, "hidden": hidden, "neurons": []})["neurons"].append(neuron)
    require(capture_bytes <= bounds["maxTensorBytes"] and arithmetic <= bounds["maxMultiplyAdds"], "CPU column capture/arithmetic exceeds admission", "CAPACITY")
    def decode(tensor):
        qtype = tensor.tensor_type
        if qtype == GGMLQuantizationType.F32:
            return np.asarray(tensor.data, dtype=np.float32)
        if qtype == GGMLQuantizationType.F16:
            return np.asarray(tensor.data).astype(np.float32)
        require(qtype in quants._type_traits, "GGUF column quantization is unsupported by the pinned pure CPU reader", "UNSUPPORTED")
        return quants.dequantize(tensor.data, qtype).astype(np.float32, copy=False)
    columns = []
    for layer, plan in planned.items():
        matrix = decode(plan["tensor"])
        require(tuple(matrix.shape) == (plan["hidden"], plan["width"]), "GGUF dequantized matrix orientation/shape differs from frozen descriptor", "IDENTITY")
        scale_tensor = tensors.get(f"blk.{layer}.ffn_down.scale")
        if scale_tensor is None:
            scale = 1.0
        else:
            require(math.prod(int(value) for value in scale_tensor.shape) == 1 and int(scale_tensor.data.nbytes) <= 1024,
                    "Down scaling tensor must contain one bounded scalar", "IDENTITY")
            scale = number(float(decode(scale_tensor).reshape(-1)[0]))
        require(scale != 0, "Zero down scale cannot define a norm-matched intervention", "UNSUPPORTED")
        for neuron in plan["neurons"]:
            values = [number(float(matrix[row, neuron])) for row in range(plan["hidden"])]
            norm = math.sqrt(math.fsum(value * value for value in values))
            require(math.isfinite(norm) and norm > 0, "Zero/nonfinite CPU down column cannot define norm matching", "UNSUPPORTED")
            columns.append({"layer": layer, "neuron": neuron, "columnL2": norm, "ffnDownScale": scale,
                            "effectiveColumnL2": abs(scale) * norm, "shape": [plan["hidden"], plan["width"]],
                            "quantization": plan["tensor"].tensor_type.name})
        del matrix
    after = Path(path).stat()
    require((before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns) ==
            (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns), "Checkpoint changed during CPU column inspection", "IDENTITY")
    return {"schema": "omnius.nol.gguf-column-norms.v1", "file": expected_file, "columns": columns,
            "normSpace": "float64_l2_of_float32_dequantized_ffn_down_column_times_native_down_scale",
            "modelLoaded": False, "sampledTokens": 0, "nativeRuntimeImported": False}


def pinned_source(root):
    root = Path(root).resolve(strict=True)
    def git(*args):
        return subprocess.run(["git", "-C", str(root), *args], check=True, capture_output=True, timeout=10).stdout
    require(git("rev-parse", "HEAD").decode().strip() == GNE_REVISION, "GNE revision differs from the pinned implementation", "IDENTITY")
    require(not git("status", "--porcelain", "--untracked-files=all", "--", "gne", "configs", "pyproject.toml").strip(), "GNE implementation/configuration is modified", "IDENTITY")
    entries = []
    for raw in git("ls-files", "-z", "--", "gne", "configs", "pyproject.toml").split(b"\0"):
        if raw:
            relative = raw.decode("utf-8", "strict")
            entries.append({"path": relative, **hash_file(safe_path(root, relative), 67108864)})
    require(any(row["path"] == "gne/api.py" for row in entries), "Pinned GNE source is incomplete", "IDENTITY")
    # This pinned tree has no template YAML overrides. An external GNE_CONFIGS
    # directory must never silently change the renderer chosen by the binding.
    require(not list((root / "configs" / "templates").glob("*.yaml")), "Renderer overrides need a separately frozen implementation", "UNSUPPORTED")
    return {"revision": GNE_REVISION, "sourceDigest": digest_bytes(canonical_simple(entries).encode()), "files": len(entries)}


def renderer_facts(metadata):
    digest = digest_bytes(metadata["template"].encode("utf-8"))
    return {"metadataChatTemplateDigest": digest, "effectiveChatTemplateDigest": digest, "overridden": False,
            "thinking": False, "addGenerationPrompt": True}


def gne_build(root, lock_path, hash_runtime, metadata=None, max_bytes=34359738368):
    result = runtime_info(lock_path, hash_runtime, max_bytes)
    result["gne"] = pinned_source(root)
    if metadata is not None:
        result["renderer"] = renderer_facts(metadata)
    return result


def isolate_gne_imports(root, scratch):
    require(not any(name == "gne" or name.startswith("gne.") for name in sys.modules), "GNE was imported before the pinned load boundary", "IDENTITY")
    cache = Path(scratch) / "private-bytecode"
    cache.mkdir(mode=0o700)
    # Ignored repository/package .pyc files are not covered by source hashes.
    # Import from an empty private cache namespace and execute the pinned .py.
    sys.pycache_prefix = str(cache)
    sys.dont_write_bytecode = True
    os.environ["GNE_CONFIGS"] = str(Path(root) / "configs")
    sys.path.insert(0, str(root))


def verify_gguf(root, model, identity):
    require(model.get("schema") == "omnius.nol.model.v1" and model.get("format") == "gguf", "Only a frozen GGUF model is supported", "UNSUPPORTED")
    verify_identity(identity["modelJson"], {key: value for key, value in model.items() if key not in ("id", "modelDigest")}, model["modelDigest"])
    verify_identity(identity["tensorSitesJson"], model["tensorSites"], model["architectureMapDigest"])
    require(len(model["files"]) == 1 and model["files"][0]["role"] == "weights", "Split GGUF and external model files require a separate lowering", "UNSUPPORTED")
    part = model["files"][0]
    fields(part, ("path", "role", "artifact"))
    path = safe_path(root, part["path"])
    require(hash_file(path) == {"sha256": part["artifact"]["sha256"], "sizeBytes": part["artifact"]["sizeBytes"]}, "Complete GGUF file digest mismatch", "IDENTITY")
    metadata = gguf_metadata(path)
    require(metadata["metadata"].get("split.count", 1) == 1, "Split GGUF shards require a complete separately verified loader", "UNSUPPORTED")
    verify_identity(identity["tokenizerJson"], metadata["tokenizer"], model["tokenizerDigest"])
    aliases = {"pad": "padding", "unk": "unknown", "sep": "seperator"}
    vocabulary = metadata["tokenizer"].get("tokenizer.ggml.tokens", [])
    for name, token_id in model["specialTokens"].items():
        actual = metadata["tokenizer"].get("tokenizer.ggml." + aliases.get(name, name) + "_token_id")
        if actual is None and name in vocabulary and vocabulary.count(name) == 1: actual = vocabulary.index(name)
        require(actual == token_id, "Special-token mapping differs from complete GGUF metadata", "IDENTITY")
    require(digest_bytes(metadata["template"].encode()) == model["chatTemplateDigest"], "GGUF metadata template differs from frozen effective template", "IDENTITY")
    arch = metadata["architecture"]
    require(metadata["metadata"].get(arch + ".block_count") == model["architecture"]["layers"] and metadata["metadata"].get(arch + ".embedding_length") == model["architecture"]["hiddenSize"], "GGUF dimensions differ from frozen architecture", "IDENTITY")
    return path, metadata


class Runtime:
    def __init__(self):
        self.session = None
        self.loaded = self.confirmed = False
        self.manifest = self.binding = self.limits = self.sites = None
        self.gpu_uuid = self.artifact_root = None
        self.temp = None
        self.reset_epoch = 0
        self.last_reset = None
        self.created_loras = []
        self.profile_sequence = 0
        self.profile_output_bytes = 0
        self.validated_cells = {}
        self.runtime_build = None

    def inspect(self, payload):
        fields(payload, ("gneRoot",), ("checkpointPath", "dependencyLockPath", "hashRuntime", "maxRuntimeBytes", "tensorSites", "columns", "columnLimits", "expectedFile"))
        metadata = gguf_metadata(payload["checkpointPath"]) if "checkpointPath" in payload else None
        result = {"runtime": gne_build(payload["gneRoot"], payload.get("dependencyLockPath"), payload.get("hashRuntime") is True, metadata,
                                       integer(payload.get("maxRuntimeBytes", 34359738368), 1))}
        if metadata is not None:
            tokenizer_json = canonical_gguf(metadata["tokenizer"])
            result["checkpoint"] = {"file": hash_file(payload["checkpointPath"]), "architecture": metadata["architecture"],
                                    "metadata": {key: value for key, value in metadata["metadata"].items() if not key.startswith("tokenizer.")},
                                    "tokenizerJson": tokenizer_json, "tokenizerDigest": digest_bytes(tokenizer_json.encode()),
                                    "chatTemplate": metadata["template"], "denseMlpLayers": metadata["denseMlpLayers"],
                                    "unsupportedLayers": metadata["unsupportedLayers"], "reservedLayers": metadata["reservedLayers"],
                                    "unsupportedSiteIds": [site["id"] for site in payload.get("tensorSites", []) if site.get("kind") == "mlp_intermediate" and site.get("layer") not in metadata["denseMlpLayers"]], **renderer_facts(metadata)}
        if any(key in payload for key in ("columns", "columnLimits", "expectedFile")):
            require(not self.loaded and metadata is not None and all(key in payload for key in ("columns", "columnLimits", "expectedFile")),
                    "Explicit CPU columns require an unloaded worker, full checkpoint and all admission bounds")
            result["columnNorms"] = gguf_column_norms(payload["checkpointPath"], payload["columns"], payload["columnLimits"], payload["expectedFile"], metadata)
        return result

    def load(self, payload):
        fields(payload, ("checkpointRoot", "artifactRoot", "workRoot", "gneRoot", "model", "binding", "gpuUuid", "identity", "dependencyLockPath", "limits"))
        require(not self.loaded, "Worker already loaded")
        self.validated_cells.clear()
        uuid = payload["gpuUuid"]
        require(type(uuid) is str and UUID.fullmatch(uuid) and os.environ.get("CUDA_VISIBLE_DEVICES") == uuid, "Explicit exact single-GPU CUDA scope is required", "PLACEMENT")
        fields(payload["limits"], ("maxInputTokens", "maxOutputTokens", "maxTensorBytes", "maxWorkingBytes", "maxMultiplyAdds"))
        limits = {key: integer(value, 1) for key, value in payload["limits"].items()}
        identity = payload["identity"]
        fields(identity, ("modelJson", "tensorSitesJson", "tokenizerJson", "runtimeBuildJson"))
        root, gne_root = Path(payload["checkpointRoot"]).resolve(strict=True), Path(payload["gneRoot"]).resolve(strict=True)
        path, metadata = verify_gguf(root, payload["model"], identity)
        build = gne_build(gne_root, payload["dependencyLockPath"], True, metadata)
        verify_identity(identity["runtimeBuildJson"], build, payload["binding"]["runtimeBuildDigest"])
        binding, manifest = payload["binding"], payload["model"]
        require(binding["schema"] == "omnius.nol.runtime.v1" and binding["backend"] == "gne" and
                all(binding[key] == manifest[key] for key in ("modelDigest", "architectureMapDigest", "tokenizerDigest", "chatTemplateDigest")) and
                build["dependencyLockDigest"] == binding["dependencyLockDigest"], "GNE runtime/model binding mismatch", "IDENTITY")
        require(limits["maxInputTokens"] + limits["maxOutputTokens"] <= binding["contextLimit"] <= manifest["contextLength"], "Context budget mismatch", "CAPACITY")
        work_root = Path(payload["workRoot"]).resolve(strict=True)
        artifact_root = Path(payload["artifactRoot"]).resolve(strict=True)
        require(work_root.is_dir() and not work_root.is_relative_to(root) and not work_root.is_relative_to(artifact_root), "GNE working files require a separate host-owned scratch directory")
        # Only this explicit, fully verified load boundary imports GNE/native code.
        self.temp = tempfile.TemporaryDirectory(prefix="omnius-gne-", dir=work_root)
        isolate_gne_imports(gne_root, self.temp.name)
        from gne.api import Session
        from gne.steer import Recipe, Unit, recipe_vectors
        from gne.engine import Sampling
        from gne.gain import export_gain_lora
        import resource
        import gne.api
        require(Path(gne.api.__file__).resolve() == gne_root / "gne" / "api.py", "Imported GNE escaped the pinned source", "IDENTITY")
        # Native adapter files are transient scratch, never published artifacts.
        # Bound even a partially failed upstream writer before its first byte.
        soft, hard = resource.getrlimit(resource.RLIMIT_FSIZE)
        maximum = limits["maxTensorBytes"]
        if soft != resource.RLIM_INFINITY: maximum = min(maximum, soft)
        if hard != resource.RLIM_INFINITY: maximum = min(maximum, hard)
        resource.setrlimit(resource.RLIMIT_FSIZE, (maximum, hard))
        self.Recipe, self.Unit, self.recipe_vectors, self.Sampling, self.export_gain_lora = Recipe, Unit, recipe_vectors, Sampling, export_gain_lora
        try:
            self.session = Session(path, root=self.temp.name, n_gpu_layers=-1, n_ctx=binding["contextLimit"], n_seq_max=1, seed=0, verbose=False)
            engine = self.session.engine
            require(digest_bytes(engine.chat_template.encode()) == manifest["chatTemplateDigest"] and engine.n_embd == manifest["architecture"]["hiddenSize"], "Effective GNE renderer/architecture differs from frozen identity", "IDENTITY")
            # Create the complete fixed-size generation context without decoding
            # any token; host placement must be confirmed before native prefill.
            engine.steer_ctx()
            self.manifest, self.binding, self.limits, self.runtime_build = manifest, binding, limits, build
            self.gpu_uuid, self.artifact_root = uuid, artifact_root
            self.sites = {}
            for site in manifest["tensorSites"]:
                if site["kind"] == "mlp_intermediate":
                    require(site["id"] not in self.sites and site["layer"] in metadata["denseMlpLayers"] and 0 <= site["layer"] < engine.n_layer and site["width"] == self.session.meta.n_ff_at(site["layer"]), "Native MLP site differs from frozen architecture or addresses an unsupported/MTP layer", "IDENTITY")
                    self.sites[site["id"]] = site
            self.loaded = True
            supported = sorted(RUNTIME_OPS) if self.session.meta.arch in ("llama", "qwen2", "qwen3", "qwen3next", "qwen35") else []
            if self.session.meta.has_post_ffn_norm and "NEURON_ADD" in supported: supported.remove("NEURON_ADD")
            return {"loaded": True, "zeroTokensGenerated": True, "pid": os.getpid(), "binding": binding,
                    "runtime": build, "renderer": renderer_facts(metadata), "placement": placement(uuid), "confirmed": False,
                    "implementation": WORKER_VERSION, "supportedRuntimeOperations": supported, "supportedParameterOperations": [], "siteIds": sorted(self.sites),
                    "operationRestrictions": {"tokenScope": "all_only", "units": ["raw", "residual_norm_with_frozen_statistics"], "overlappingOperations": "unsupported", "neuronAddLayer0": "unsupported", "gain": "dense_separate_swiglu_up_lora"},
                    "tokenScopeBasis": "edited_computation_positions", "firstGeneratedTokenUsesPromptComputation": True,
                    "usesCache": True, "cacheScope": "within_trial_only",
                    "native": {"architecture": self.session.meta.arch, "layers": engine.n_layer, "hiddenSize": engine.n_embd, "llamaCppVersion": engine.llama_cpp_version()}}
        except BaseException:
            self.close()
            raise

    def confirm(self, payload):
        fields(payload, ("pid", "gpuUuid", "startIdentity"))
        require(self.loaded and same_json(payload, placement(self.gpu_uuid)), "Host placement confirmation differs from actual CUDA worker", "PLACEMENT")
        self.confirmed = True
        return {"confirmed": True, "binding": self.binding, "placement": payload}

    def ready(self):
        require(self.loaded and self.confirmed, "Model requires actual host-confirmed CUDA placement", "PLACEMENT")

    def tokenize(self, payload):
        self.ready()
        fields(payload, ("messages",))
        messages = payload["messages"]
        require(type(messages) is list and 0 < len(messages) <= 1000, "Invalid message inventory")
        for message in messages:
            fields(message, ("role", "content"))
            require(message["role"] in ("system", "user", "assistant") and type(message["content"]) is str, "Only plain text chat is supported", "UNSUPPORTED")
        engine = self.session.engine
        text = engine.render_chat(messages, enable_thinking=False, add_generation_prompt=True)
        ids = engine.tokenize_prompt(text)
        require(0 < len(ids) <= self.limits["maxInputTokens"], "Native prompt budget exceeded", "CAPACITY")
        return {"tokenIds": ids, "promptTokens": len(ids), "renderedPrompt": text, "chatTemplateDigest": digest_bytes(engine.chat_template.encode())}

    def reset(self):
        if self.session is not None and self.session._engine is not None:
            engine = self.session.engine
            for ctx in (engine._steer, engine._probe, engine._attn_probe):
                if ctx is not None:
                    engine.set_cvec(ctx, None)
                    engine.set_lora(ctx, None)
                    engine.clear_memory(ctx)
            for path in self.created_loras:
                engine.drop_lora(path)
                Path(path).unlink(missing_ok=True)
            self.created_loras = []
            self.session.weights._cache.clear()
        self.reset_epoch += 1
        self.last_reset = {"epoch": self.reset_epoch, "controlVectors": 0, "activeAdapters": [], "kvCleared": True, "clean": True, "modelDigest": self.manifest["modelDigest"] if self.manifest else None}
        return self.last_reset

    def calibration(self, recipe, operation, layer):
        calibration = next((value for value in recipe["calibrations"] if value["id"] == operation.get("calibrationId")), None)
        require(calibration is not None and calibration["units"] == "residual_norm" and calibration["modelDigest"] == self.manifest["modelDigest"] and calibration["architectureMapDigest"] == self.manifest["architectureMapDigest"], "Explicit residual calibration must bind the exact model/site map", "IDENTITY")
        artifact = calibration.get("statistics")
        require(type(artifact) is dict and artifact.get("uri") == "omnius-artifact://sha256/" + str(artifact.get("sha256")) and SHA.fullmatch(artifact.get("sha256", "")), "Measured residual statistics artifact required", "UNSUPPORTED")
        path = safe_path(self.artifact_root, artifact["sha256"][:2] + "/" + artifact["sha256"])
        require(hash_file(path, self.limits["maxTensorBytes"]) == {"sha256": artifact["sha256"], "sizeBytes": artifact["sizeBytes"]}, "Residual statistics bytes differ from frozen calibration", "IDENTITY")
        from gne.stats import ResidStats
        stats = ResidStats.load(path)
        corpus_digest, positions_digest = calibration.get("corpusDigest"), calibration.get("tokenPositionsDigest")
        require(SHA.fullmatch(corpus_digest or "") and SHA.fullmatch(positions_digest or ""), "Full corpus and position identities are required", "IDENTITY")
        for digest in (corpus_digest, positions_digest):
            source = safe_path(self.artifact_root, digest[:2] + "/" + digest)
            require(hash_file(source, self.limits["maxTensorBytes"])["sha256"] == digest, "Calibration source bytes differ from their full frozen identity", "IDENTITY")
        corpus = safe_path(self.artifact_root, corpus_digest[:2] + "/" + corpus_digest)
        # Upstream hashes decoded/universal-newline text, then truncates its
        # corpus tag to 16 hex characters. Full CAS bytes remain authoritative.
        text_digest = digest_bytes(corpus.read_text(encoding="utf-8").encode("utf-8"))
        scale = next((item["scale"] for item in calibration["siteScales"] if item["siteId"] == operation["siteId"]), None)
        require(stats.n_tokens > 0 and stats.corpus_sha in (corpus_digest, text_digest, text_digest[:16]) and scale is not None and number(scale) > 0 and stats.rho(layer) == scale, "Measured residual median/corpus differs from the explicit calibration", "IDENTITY")
        return stats

    def profile(self, payload):
        require(type(payload) is dict, "Profile payload must be an object")
        if payload.get("mode") == "neuron_add_conformance":
            return self.conformance(payload)
        if payload.get("mode") == "accept_neuron_add_conformance":
            return self.accept_conformance(payload)
        self.ready()
        fields(payload, ("corpusArtifact", "layers", "chunkTokens", "maxTokens"), ("neurons",))
        require(self.last_reset is not None and not self.created_loras, "Residual profile requires an explicit clean host reset", "RESET")
        artifact = payload["corpusArtifact"]
        fields(artifact, ("uri", "sha256", "sizeBytes", "mediaType"))
        require(SHA.fullmatch(artifact["sha256"]) and artifact["uri"] == "omnius-artifact://sha256/" + artifact["sha256"] and artifact["mediaType"] in ("text/plain", "text/plain; charset=utf-8"), "Explicit UTF-8 corpus artifact required", "IDENTITY")
        source = safe_path(self.artifact_root, artifact["sha256"][:2] + "/" + artifact["sha256"])
        source_bound = min(self.limits["maxTensorBytes"], self.limits["maxWorkingBytes"] // 256)
        require(hash_file(source, source_bound) == {"sha256": artifact["sha256"], "sizeBytes": artifact["sizeBytes"]}, "Corpus bytes differ from the full frozen identity", "IDENTITY")
        layers = payload["layers"]
        engine = self.session.engine
        require(type(layers) is list and 0 < len(layers) <= engine.n_layer and len(set(layers)) == len(layers), "Explicit unique residual layers required")
        for layer in layers: integer(layer, 1, engine.n_layer - 1)
        require(all(any(site["layer"] == layer for site in self.sites.values()) for layer in layers), "Calibration layer is not an editable dense native site", "UNSUPPORTED")
        neurons = payload.get("neurons", [])
        require(type(neurons) is list and len(neurons) <= 64, "Column measurement inventory exceeds its bound", "CAPACITY")
        coordinates = set()
        matrix_bytes = 0
        column_arithmetic = 0
        for neuron in neurons:
            fields(neuron, ("layer", "neuron"))
            layer = integer(neuron["layer"], 1, engine.n_layer - 1)
            require(layer in layers, "Column measurement layer must be included in the residual profile")
            index = integer(neuron["neuron"], 0, self.session.meta.n_ff_at(layer) - 1)
            require((layer, index) not in coordinates, "Duplicate column measurement coordinate")
            coordinates.add((layer, index))
            matrix_bytes = max(matrix_bytes, engine.n_embd * self.session.meta.n_ff_at(layer) * 4)
            column_arithmetic += engine.n_embd * self.session.meta.n_ff_at(layer) * 4
        chunk = integer(payload["chunkTokens"], 2, min(self.limits["maxInputTokens"], self.binding["contextLimit"]))
        maximum = integer(payload["maxTokens"], chunk, self.limits["maxInputTokens"])
        require(maximum % chunk == 0, "Profile maxTokens must be a multiple of chunkTokens to prevent upstream ceiling overshoot", "CAPACITY")
        include_last = engine.n_layer - 1 in layers
        capture_bytes = len(layers) * chunk * engine.n_embd * 4
        working = capture_bytes * 4 + maximum * len(layers) * 16 + artifact["sizeBytes"] * 128
        working += matrix_bytes * 4 + len(neurons) * engine.n_embd * 8
        if include_last: working += chunk * engine.n_vocab * 4
        require(capture_bytes <= self.limits["maxTensorBytes"] and working <= self.limits["maxWorkingBytes"] and maximum * len(layers) * engine.n_embd * 2 + column_arithmetic <= self.limits["maxMultiplyAdds"], "Residual profile exceeds frozen capture/working/arithmetic bounds", "CAPACITY")
        from gne.stats import Corpus, corpus_chunks, residual_norms
        text = source.read_text(encoding="utf-8")
        corpus = Corpus(text, artifact["sha256"], str(source))
        planned = corpus_chunks(engine, corpus, chunk_tokens=chunk, max_tokens=maximum)
        require(type(planned) is list and planned and sum(len(tokens) for tokens in planned) <= maximum and all(2 <= len(tokens) <= chunk for tokens in planned), "Actual upstream chunks exceed the declared token bound", "CAPACITY")
        before = self.last_reset
        original_prefill, original_decode = engine.prefill, engine._decode
        chunks, current = [], {"tokens": [], "positions": []}
        def decode(ctx, items):
            require(ctx is engine._probe and all(item[2] == 0 for item in items), "Profile decoded outside its owned single-sequence probe", "IDENTITY")
            result = original_decode(ctx, items)
            current["tokens"].extend(item[0] for item in items)
            current["positions"].extend(item[1] for item in items)
            return result
        def prefill(ctx, sequences, **kwargs):
            index = len(chunks)
            require(index < len(planned) and len(sequences) == 1 and sequences[0] == planned[index], "Actual residual profile tokens differ from the bounded plan", "IDENTITY")
            current["tokens"], current["positions"] = [], []
            result = original_prefill(ctx, sequences, **kwargs)
            require(current["tokens"] == planned[index] and current["positions"] == list(range(len(planned[index]))), "Native residual decode positions differ from the profile plan", "IDENTITY")
            chunks.append({"chunkIndex": index, "tokenIds": list(current["tokens"]), "decodedPositions": list(current["positions"]), "measuredPositions": list(range(1, len(planned[index])))})
            return result
        def free_probe():
            probe = engine._probe
            if probe is not None:
                engine.set_cvec(probe, None)
                engine.set_lora(probe, None)
                engine.clear_memory(probe)
                probe.free()
                engine._probe = None
                engine._probe_logits_all = False
        def save(name, data, media_type):
            require(self.profile_output_bytes + len(data) <= self.limits["maxTensorBytes"], "Cumulative profile scratch output byte bound exceeded", "CAPACITY")
            path = Path(self.temp.name) / name
            # Failed/partial writes remain conservatively charged as scratch.
            self.profile_output_bytes += len(data)
            descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
            with os.fdopen(descriptor, "wb") as target: target.write(data)
            return {"path": str(path), "sha256": digest_bytes(data), "sizeBytes": len(data), "mediaType": media_type}
        try:
            free_probe()
            column_norms = []
            try:
                for neuron in neurons:
                    weights = self.session.weights
                    weights._cache.clear()
                    column = weights.down_column(neuron["layer"], neuron["neuron"])
                    require(len(column) == engine.n_embd and all(math.isfinite(float(value)) for value in column), "Native down-column shape/values differ from the model binding", "IDENTITY")
                    norm = math.sqrt(math.fsum(float(value) ** 2 for value in column))
                    scale = number((getattr(self.session.meta, "ffn_down_scale", None) or {}).get(neuron["layer"], 1.0))
                    require(norm > 0 and scale != 0, "Zero down-column or scale cannot define a residual dose", "UNSUPPORTED")
                    column_norms.append({**neuron, "columnL2": norm, "ffnDownScale": scale, "effectiveColumnL2": abs(scale) * norm})
            finally:
                self.session.weights._cache.clear()
            engine.prefill, engine._decode = prefill, decode
            stats = residual_norms(engine, corpus, layers=list(layers), chunk_tokens=chunk, include_last_layer=include_last, max_tokens=maximum)
            require(len(chunks) == len(planned) and stats.n_tokens == sum(len(item["measuredPositions"]) for item in chunks) and list(int(layer) for layer in stats.layers) == list(layers), "Native profile statistics/positions inventory mismatch", "IDENTITY")
            require(stats.corpus_sha == artifact["sha256"] and stats.exclude_pos0 is True, "Residual statistics lost full corpus/position identity", "IDENTITY")
            summaries = stats.to_dict()
            require(all(math.isfinite(float(value)) for key in ("p10", "p50", "p90", "mean") for value in summaries[key]) and all(stats.rho(layer) > 0 for layer in layers), "Residual calibration has nonfinite or zero medians")
            for column in column_norms:
                column["rho"] = stats.rho(column["layer"])
                column["rawUnitsPerDose"] = column["rho"] / (column["ffnDownScale"] * column["columnL2"])
                number(column["effectiveColumnL2"]); number(column["rawUnitsPerDose"])
            definition = {"schema": "omnius.nol.residual-definition.v1", "implementation": WORKER_VERSION, "gneRevision": GNE_REVISION,
                          "algorithm": "gne.stats.residual_norms", "measure": "median_l2_l_out", "positionBasis": "chunk_local_excluding_zero",
                          "layerNumbering": "gguf_blk_zero_based", "sourceText": "utf8_universal_newlines", "sampledTokens": 0,
                          "columnNorm": "float64_l2_dequantized_ffn_down_column", "rawUnitsPerDose": "rho/(ffn_down.scale*column_l2)"}
            definition_digest = digest_bytes(canonical_simple(definition).encode())
            positions = {"schema": "omnius.nol.residual-positions.v1", "modelDigest": self.manifest["modelDigest"], "architectureMapDigest": self.manifest["architectureMapDigest"],
                         "corpusDigest": artifact["sha256"], "corpusTextDigest": digest_bytes(text.encode()), "tokenizerDigest": self.manifest["tokenizerDigest"],
                         "definitionDigest": definition_digest, "layers": layers, "chunkTokens": chunk, "maxTokens": maximum, "chunks": chunks}
            positions_bytes = canonical_simple(positions).encode()
            require(65536 + len(layers) * 128 + len(positions_bytes) + self.profile_output_bytes <= self.limits["maxTensorBytes"], "Profile serialization exceeds its reserved scratch byte bound", "CAPACITY")
            buffer = io.BytesIO()
            stats.save(buffer)
            statistics_bytes = buffer.getvalue()
            require(len(statistics_bytes) + len(positions_bytes) + self.profile_output_bytes <= self.limits["maxTensorBytes"], "Profile artifacts exceed the cumulative byte bound", "CAPACITY")
            self.profile_sequence += 1
            statistics_file = save(f"residual-{self.profile_sequence}.npz", statistics_bytes, "application/x-npz")
            positions_file = save(f"residual-{self.profile_sequence}.positions.json", positions_bytes, "application/json")
            engine.prefill, engine._decode = original_prefill, original_decode
            free_probe()
            after = self.reset()
            return {"sampledTokens": 0, "corpusDigest": artifact["sha256"], "definition": definition, "definitionDigest": definition_digest,
                    "layers": layers, "chunkTokens": chunk, "inputTokens": sum(len(tokens) for tokens in planned), "statistics": summaries,
                    "statisticsFile": statistics_file, "positionsFile": positions_file,
                    "columns": column_norms,
                    "siteScales": [{"siteId": site["id"], "scale": stats.rho(site["layer"])} for site in self.sites.values() if site["layer"] in layers],
                    "native": {"binding": self.binding, "implementation": WORKER_VERSION, "resetBefore": before, "resetAfter": after,
                               "probeFreed": True, "usesCache": True, "cacheScope": "profile_only_cleared", "sourceArtifact": artifact}}
        except BaseException:
            engine.prefill, engine._decode = original_prefill, original_decode
            try:
                free_probe()
                self.reset()
            except BaseException as error: raise Rejected("RESET", "Residual profile could not release its probe state", True) from error
            raise

    def cell_key(self, operation):
        return canonical_gguf({key: operation.get(key) for key in ("siteId", "neuron", "amount", "units", "tokenScope", "calibrationId")})

    def conformance(self, payload):
        """Explicit bounded native measurements; no sampled/generated token."""
        self.ready()
        fields(payload, ("mode", "messages", "operations", "maxTokens", "absoluteTolerance", "relativeTolerance"))
        require(self.last_reset is not None and not self.created_loras, "Conformance requires an explicit clean reset", "RESET")
        operations = payload["operations"]
        require(type(operations) is list and 0 < len(operations) <= 8, "Conformance cell inventory exceeds its bound", "CAPACITY")
        absolute, relative = number(payload["absoluteTolerance"]), number(payload["relativeTolerance"])
        require(0 < absolute <= 0.01 and 0 < relative <= 0.01, "Explicit bounded FP tolerances required")
        engine = self.session.engine
        tokens = self.tokenize({"messages": payload["messages"]})["tokenIds"]
        maximum = integer(payload["maxTokens"], 1, self.limits["maxInputTokens"] * 24)
        require(len(tokens) * 3 * len(operations) <= maximum, "Conformance three-prefill token budget exceeded", "CAPACITY")
        keys, matrix_bytes = set(), 0
        for operation in operations:
            fields(operation, ("id", "operation", "siteId", "tokenScope", "neuron", "amount", "units"))
            require(operation["operation"] == "NEURON_ADD" and operation["units"] == "raw" and operation["tokenScope"] == {"kind": "all"},
                    "Conformance supports raw all-token neuron-add cells only", "UNSUPPORTED")
            require(number(operation["amount"]) != 0 and self.cell_key(operation) not in keys, "Conformance requires distinct nonzero cells")
            keys.add(self.cell_key(operation))
            site = self.sites.get(operation["siteId"])
            require(site is not None and 0 < site["layer"] < engine.n_layer and not self.session.meta.has_post_ffn_norm,
                    "Conformance cannot validate this layer or post-FFN normalized architecture", "UNSUPPORTED")
            integer(operation["neuron"], 0, site["width"] - 1)
            matrix_bytes = max(matrix_bytes, engine.n_embd * site["width"] * 4)
        for key in keys: self.validated_cells.pop(key, None)
        capture_bytes = len(operations) * (6 * len(tokens) + 1) * engine.n_embd * 4
        require(capture_bytes + self.profile_output_bytes + 65536 <= self.limits["maxTensorBytes"] and
                matrix_bytes * 4 + capture_bytes * 16 <= self.limits["maxWorkingBytes"] and
                maximum * engine.n_embd * 4 <= self.limits["maxMultiplyAdds"], "Conformance capture/dequantization/working budget exceeded", "CAPACITY")
        from gne.capture import Capture
        import numpy as np
        before, original_decode = self.last_reset, engine._decode
        captures, cells, decoded = {}, [], []
        def decode(ctx, items):
            require(ctx is engine._probe and all(item[2] == 0 for item in items), "Conformance escaped its owned single-sequence probe", "IDENTITY")
            result = original_decode(ctx, items)
            decoded.extend((item[0], item[1]) for item in items)
            return result
        def free_probe():
            if engine._probe is not None:
                engine.set_cvec(engine._probe, None); engine.set_lora(engine._probe, None); engine.clear_memory(engine._probe)
                engine._probe.free(); engine._probe = None
        try:
            free_probe()
            engine._decode = decode
            for index, operation in enumerate(operations):
                site, layer = self.sites[operation["siteId"]], self.sites[operation["siteId"]]["layer"]
                names = (f"l_out-{layer - 1}", f"l_out-{layer}")
                capture = Capture(lambda name: name in names)
                ctx = engine.probe_ctx(capture, logits_all=layer == engine.n_layer - 1, need=len(tokens))
                recipe = {"schema": "omnius.nol.recipe.v1", "modelDigest": self.manifest["modelDigest"],
                          "architectureMapDigest": self.manifest["architectureMapDigest"], "operations": [operation], "calibrations": []}
                vectors, lora, actual = self.install(recipe, validating=True)
                require(lora is None and set(vectors) == {layer}, "Conformance installed an unexpected adapter/layer", "IDENTITY")
                vector = [number(float(value)) for value in vectors[layer]]
                norm = math.sqrt(math.fsum(value * value for value in vector))
                require(len(vector) == engine.n_embd and norm > 0, "Conformance lowering has no finite nonzero vector", "IDENTITY")
                observed = {}
                for phase, applied in (("baseline", None), ("steered", vectors), ("restored", None)):
                    decoded.clear(); capture.reset()
                    engine.set_lora(ctx, None); engine.set_cvec(ctx, applied); engine.clear_memory(ctx)
                    engine.prefill(ctx, [tokens], logits_all=layer == engine.n_layer - 1)
                    require(decoded == list(zip(tokens, range(len(tokens)))), "Actual conformance tokens/positions differ from its plan", "IDENTITY")
                    values = capture.take()
                    require(set(values) == set(names) and not capture.skipped, "Native residual capture is missing or skipped", "UNSUPPORTED")
                    observed[phase] = {}
                    for name in names:
                        array = values[name]
                        require(tuple(array.shape) == (len(tokens), engine.n_embd) and str(array.dtype) == "float32", "Native residual shape/dtype differs from admission", "IDENTITY")
                        rows = array.tolist()
                        require(all(math.isfinite(value) for row in rows for value in row), "Nonfinite native residual observation")
                        observed[phase][name] = rows
                        captures[f"cell_{index}_{phase}_{'prior' if name == names[0] else 'target'}"] = array
                base, steered, restored = observed["baseline"], observed["steered"], observed["restored"]
                prior_error = max(abs(a - b) for left, right in zip(base[names[0]], steered[names[0]]) for a, b in zip(left, right))
                restoration = max(abs(a - b) for name in names for left, right in zip(base[name], restored[name]) for a, b in zip(left, right))
                errors = [[actual_value - original - expected for actual_value, original, expected in zip(left, right, vector)]
                          for left, right in zip(steered[names[1]], base[names[1]])]
                maximum_error = max(abs(value) for row in errors for value in row)
                relative_error = max(math.sqrt(math.fsum(value * value for value in row)) / norm for row in errors)
                coordinate_pass = all(abs(value) <= absolute + relative * abs(expected) for row in errors for value, expected in zip(row, vector))
                passed = prior_error <= absolute and restoration <= absolute and coordinate_pass
                vector_array = np.asarray(vector, dtype=np.float32)
                captures[f"cell_{index}_vector"] = vector_array
                cells.append({"operation": operation, "layer": layer, "tokenIds": list(tokens), "decodedPositions": list(range(len(tokens))),
                              "priorTensor": names[0], "targetTensor": names[1], "vectorNorm": norm,
                              "vectorSha256": digest_bytes(vector_array.tobytes()), "priorMaxAbsError": prior_error, "restorationMaxAbsError": restoration,
                              "deltaMaxAbsError": maximum_error, "deltaMaxRelativeL2Error": relative_error, "coordinateTolerancePassed": coordinate_pass,
                              "validationPassed": passed})
                free_probe()
            output = io.BytesIO(); np.savez(output, **captures); content = output.getvalue()
            require(len(content) + self.profile_output_bytes <= self.limits["maxTensorBytes"], "Conformance proof exceeds its cumulative scratch reservation", "CAPACITY")
            self.profile_sequence += 1
            target = Path(self.temp.name) / f"conformance-{self.profile_sequence}.npz"
            with target.open("xb") as stream: stream.write(content)
            self.profile_output_bytes += len(content)
            engine._decode = original_decode
            after = self.reset()
            report = {"schema": "omnius.nol.gne-add-conformance.v1", "binding": self.binding, "workerSha256": hash_file(Path(__file__).resolve())["sha256"],
                      "gneRevision": GNE_REVISION, "implementation": WORKER_VERSION, "procedure": "baseline_steered_restored_prior_and_target_residual_f32",
                      "positionBasis": "edited_computation_positions", "tokenScope": "all", "sampledTokens": 0, "inputTokens": len(tokens) * 3 * len(operations),
                      "absoluteTolerance": absolute, "relativeTolerance": relative, "cells": cells, "validationPassed": all(cell["validationPassed"] for cell in cells),
                      "capture": {"sha256": digest_bytes(content), "sizeBytes": len(content), "mediaType": "application/x-npz"},
                      "limitations": ["bounded_exact_cells_and_token_positions_only", "floating_point_validated_equivalent_not_exact", "no_efficacy_claim"]}
            validation_id = digest_bytes(canonical_gguf(report).encode())
            if report["validationPassed"]:
                for operation in operations: self.validated_cells[self.cell_key(operation)] = validation_id
            return {**report, "validationId": validation_id, "captureFile": {"path": str(target), **report["capture"]},
                    "native": {"binding": self.binding, "resetBefore": before, "resetAfter": after, "probeFreed": True, "cacheScope": "conformance_only_cleared"}}
        except BaseException:
            engine._decode = original_decode
            try: free_probe(); self.reset()
            except BaseException as error: raise Rejected("RESET", "Conformance probe state could not be released", True) from error
            raise

    def accept_conformance(self, payload):
        """Zero-token import over the private host channel; the host must first
        verify its immutable issued journal record, not arbitrary caller JSON."""
        self.ready()
        fields(payload, ("mode", "evidenceArtifact"))
        reference = payload["evidenceArtifact"]
        fields(reference, ("uri", "sha256", "sizeBytes", "mediaType"))
        require(SHA.fullmatch(reference["sha256"]) and reference["uri"] == "omnius-artifact://sha256/" + reference["sha256"] and reference["mediaType"] == "application/json", "Frozen conformance evidence artifact required", "IDENTITY")
        path = safe_path(self.artifact_root, reference["sha256"][:2] + "/" + reference["sha256"])
        require(hash_file(path, min(self.limits["maxTensorBytes"], 1048576)) == {"sha256": reference["sha256"], "sizeBytes": reference["sizeBytes"]}, "Conformance evidence bytes changed", "IDENTITY")
        evidence = parse_json(path.read_text(encoding="utf-8"))
        require(evidence.get("schema") == "omnius.nol.gne-conformance-evidence.v1", "Unsupported conformance evidence document")
        report, capture = evidence.get("nativeReport"), evidence.get("captureArtifact")
        require(type(report) is dict and type(capture) is dict and report.get("validationPassed") is True and same_json(report.get("binding"), self.binding) and
                report.get("workerSha256") == hash_file(Path(__file__).resolve())["sha256"] and report.get("gneRevision") == GNE_REVISION and
                report.get("procedure") == "baseline_steered_restored_prior_and_target_residual_f32" and report.get("tokenScope") == "all" and report.get("sampledTokens") == 0,
                "Conformance proof is not validated for the exact native runtime/model", "IDENTITY")
        body = {key: value for key, value in report.items() if key not in ("validationId", "captureFile", "native")}
        require(report.get("validationId") == digest_bytes(canonical_gguf(body).encode()), "Conformance report identity changed", "IDENTITY")
        require(capture.get("sha256") == report["capture"]["sha256"] and capture.get("sizeBytes") == report["capture"]["sizeBytes"] and capture.get("uri") == "omnius-artifact://sha256/" + capture["sha256"], "Capture artifact differs from observed proof", "IDENTITY")
        source = safe_path(self.artifact_root, capture["sha256"][:2] + "/" + capture["sha256"])
        require(hash_file(source, self.limits["maxTensorBytes"]) == {"sha256": capture["sha256"], "sizeBytes": capture["sizeBytes"]}, "Native capture proof bytes changed", "IDENTITY")
        require(type(report.get("cells")) is list and 0 < len(report["cells"]) <= 8, "Invalid conformance cell inventory")
        absolute, relative = number(report.get("absoluteTolerance")), number(report.get("relativeTolerance"))
        require(0 < absolute <= 0.01 and 0 < relative <= 0.01, "Conformance tolerance is not admitted")
        for cell in report["cells"]:
            operation = cell.get("operation", {})
            require(operation.get("operation") == "NEURON_ADD" and operation.get("units") == "raw" and operation.get("tokenScope") == {"kind": "all"} and
                    operation.get("siteId") in self.sites and self.sites[operation["siteId"]]["layer"] == cell.get("layer") and
                    cell.get("validationPassed") is True and cell.get("coordinateTolerancePassed") is True and
                    number(cell.get("priorMaxAbsError")) <= absolute and number(cell.get("restorationMaxAbsError")) <= absolute,
                    "Conformance cell is unvalidated or outside the loaded tensor map", "IDENTITY")
            integer(operation.get("neuron"), 0, self.sites[operation["siteId"]]["width"] - 1)
            require(type(cell.get("tokenIds")) is list and 0 < len(cell["tokenIds"]) <= self.limits["maxInputTokens"], "Conformance cell token count is invalid", "IDENTITY")
            for token in cell["tokenIds"]: integer(token, 0, 4294967295)
            require(number(operation.get("amount")) != 0 and number(cell.get("vectorNorm")) > 0 and
                    0 <= number(cell.get("deltaMaxAbsError")) and 0 <= number(cell.get("deltaMaxRelativeL2Error")) and
                    cell.get("decodedPositions") == list(range(len(cell["tokenIds"]))), "Conformance cell lacks actual position coverage", "IDENTITY")
        require(integer(report.get("inputTokens"), 1) == 3 * sum(len(cell["tokenIds"]) for cell in report["cells"]), "Conformance prefill accounting differs from observed positions", "IDENTITY")
        for cell in report["cells"]: self.validated_cells[self.cell_key(cell["operation"])] = report["validationId"]
        return {"accepted": True, "validationId": report["validationId"], "evidenceDigest": reference["sha256"], "cells": len(report["cells"]), "sampledTokens": 0}

    def install(self, recipe, validating=False):
        if recipe is None:
            return {}, None, []
        require(recipe.get("schema") == "omnius.nol.recipe.v1" and recipe["modelDigest"] == self.manifest["modelDigest"] and recipe["architectureMapDigest"] == self.manifest["architectureMapDigest"], "Recipe differs from resident model", "IDENTITY")
        engine, weights = self.session.engine, self.session.weights
        require(self.session.meta.arch in ("llama", "qwen2", "qwen3", "qwen3next", "qwen35"), "GNE neuron lowering is unverified for this architecture", "UNSUPPORTED")
        require(type(recipe["operations"]) is list and 0 < len(recipe["operations"]) <= 1000, "Invalid operation inventory")
        vectors, gains, actual, occupied, identifiers = {}, [], [], set(), set()
        working, arithmetic, gain_bytes = 0, 0, 0
        for op in recipe["operations"]:
            kind = op.get("operation")
            fields(op, ("id", "operation", "siteId", "tokenScope", "neuron", "amount", "units") if kind == "NEURON_ADD" else ("id", "operation", "siteId", "tokenScope", "neuron", "factor"), ("calibrationId",) if kind == "NEURON_ADD" else ())
            require(kind in RUNTIME_OPS and op["tokenScope"] == {"kind": "all"}, "Only all-token dense neuron add/gain is supported", "UNSUPPORTED")
            site = self.sites.get(op["siteId"])
            require(site is not None and op["id"] not in identifiers, "Unknown site or duplicate operation identity")
            layer, neuron = site["layer"], integer(op["neuron"], 0, site["width"] - 1)
            require((layer, neuron) not in occupied, "Overlapping ordered operations require a separate exact lowering", "UNSUPPORTED")
            occupied.add((layer, neuron)); identifiers.add(op["id"])
            require(not weights.is_moe(layer) and weights.has_tensor(f"blk.{layer}.ffn_gate.weight") and weights.has_tensor(f"blk.{layer}.ffn_up.weight") and weights.has_tensor(f"blk.{layer}.ffn_down.weight"), "Only verified separate dense SwiGLU tensors are supported", "UNSUPPORTED")
            matrix = engine.n_embd * site["width"] * 4
            working = max(working, matrix * 4 + gain_bytes + (len(vectors) + 2) * engine.n_embd * 4)
            arithmetic += engine.n_embd * site["width"]
            require(working <= self.limits["maxWorkingBytes"] and arithmetic <= self.limits["maxMultiplyAdds"], "Native dequantization working/arithmetic budget exceeded", "CAPACITY")
            weights._cache.clear()
            if kind == "NEURON_ADD":
                require(validating or self.cell_key(op) in self.validated_cells, "Raw neuron-add cell requires explicit native conformance proof before generation", "UNSUPPORTED")
                require(layer > 0 and not self.session.meta.has_post_ffn_norm, "Control-vector lowering cannot implement layer0 or post-FFN normalized neuron add exactly", "UNSUPPORTED")
                require(op["units"] in ("raw", "residual_norm"), "Activation-standard-deviation calibration is not implemented", "UNSUPPORTED")
                stats = self.calibration(recipe, op, layer) if op["units"] == "residual_norm" else None
                require(stats is not None or "calibrationId" not in op, "Raw operands must not carry a non-applied calibration", "UNSUPPORTED")
                unit = self.Unit(layer, neuron, number(op["amount"]))
                native = self.Recipe([unit], self.session.meta.model_id, "rel" if stats else "raw", when="all")
                # No Session.vectors()/stats_view(auto=True): never synthesize
                # calibration from the upstream default corpus during a trial.
                vector = self.recipe_vectors(weights, stats, native)[layer]
                require(all(math.isfinite(float(value)) for value in vector), "Nonfinite native vector")
                vectors[layer] = vectors[layer] + vector if layer in vectors else vector
                implementation = "gne:residual-control-vector"
                detail = {"vectorNorm": math.sqrt(sum(float(value) ** 2 for value in vector)), "units": op["units"]}
            else:
                factor = number(op["factor"])
                gains.append(self.Unit(layer, neuron, 0.0, mode="gain", k=factor))
                gain_bytes += 4 * (engine.n_embd + site["width"])
                require(gain_bytes + 65536 <= self.limits["maxTensorBytes"], "Native gain adapter exceeds the tensor byte bound", "CAPACITY")
                implementation, detail = "gne:ffn-up-lora", {"factor": factor, "target": f"blk.{layer}.ffn_up.weight"}
            validation_id = self.validated_cells.get(self.cell_key(op)) if kind == "NEURON_ADD" else None
            actual.append({"operationId": op["id"], "operation": kind, "siteId": op["siteId"], "tokenScope": op["tokenScope"], "implementation": implementation,
                           "equivalence": "validated_equivalent" if validation_id else "unvalidated", **({"nativeValidationId": validation_id} if validation_id else {}), **detail})
        lora = None
        if gains:
            require(working + gain_bytes <= self.limits["maxWorkingBytes"], "Native gain construction exceeds the working byte bound", "CAPACITY")
            path = Path(self.temp.name) / "trial-gain.lora.gguf"
            self.created_loras.append(str(path))
            self.export_gain_lora(weights, self.Recipe(gains, self.session.meta.model_id, "raw", when="all"), path)
            actual_file = hash_file(path, self.limits["maxTensorBytes"])
            for item in actual:
                if item["operation"] == "NEURON_GAIN": item["adapter"] = actual_file
            lora = [(str(path), 1.0)]
        weights._cache.clear()
        return vectors, lora, actual

    def generate(self, payload):
        self.ready()
        fields(payload, ("messages", "recipe", "recipeIdentityJson", "cacheKeyDigest", "seed", "maxTokens", "decoding"))
        maximum = integer(payload["maxTokens"], 1, self.limits["maxOutputTokens"])
        seed = integer(payload["seed"], 0, 4294967295)
        require(SHA.fullmatch(payload["cacheKeyDigest"]), "Invalid cold cache identity")
        decoding = payload["decoding"]
        fields(decoding, ("temperature", "topP", "topK", "constrainedDecoding"))
        temperature, top_p, top_k = number(decoding["temperature"]), number(decoding["topP"]), integer(decoding["topK"])
        require(0 <= temperature <= 5 and 0 < top_p <= 1 and decoding["constrainedDecoding"] == "none", "Unsupported decoding configuration", "UNSUPPORTED")
        prompt = self.tokenize({"messages": payload["messages"]})["tokenIds"]
        require(len(prompt) + maximum <= self.binding["contextLimit"], "Physical context limit exceeded", "CAPACITY")
        if payload["recipe"] is not None:
            recipe = payload["recipe"]
            verify_identity(payload["recipeIdentityJson"], {key: value for key, value in recipe.items() if key != "recipeDigest"}, recipe["recipeDigest"])
        else:
            require(payload["recipeIdentityJson"] is None, "Baseline cannot carry a recipe identity")
        require(self.last_reset is not None and not self.created_loras, "Explicit host reset required before native generation", "RESET")
        before, engine = self.last_reset, self.session.engine
        ctx = engine.steer_ctx()
        observed, original_decode = set(), engine._decode
        def decode(context, items):
            result = original_decode(context, items)
            observed.update(item[1] for item in items if item[2] == 0)
            return result
        try:
            vectors, lora, actual = self.install(payload["recipe"])
            engine.set_lora(ctx, lora)
            engine.set_cvec(ctx, vectors or None)
            engine._decode = decode
            prefilled = engine.prefill(ctx, [prompt])
            sampling = self.Sampling(temperature=temperature, top_p=top_p, top_k=top_k, min_p=0, presence_penalty=0, seed=seed, dry_multiplier=0)
            rollout = engine.generate_greedy(ctx, [prompt], max_tokens=maximum, top_k=min(5, engine.n_vocab), prefilled=prefilled, sampling=sampling)[0]
            require(len(rollout.token_ids) <= maximum and len(rollout.text.encode()) < MAX_FRAME // 2, "Native output exceeds its bound", "CAPACITY")
            positions = {item["operationId"]: sorted(observed) for item in actual}
            engine._decode = original_decode
            reset = self.reset()
            return {"text": rollout.text, "promptTokenIds": prompt, "tokenIds": rollout.token_ids,
                    "usage": {"promptTokens": len(prompt), "completionTokens": len(rollout.token_ids)}, "finishReason": "stop" if rollout.finish == "eog" else "length",
                    "native": {"binding": self.binding, "implementation": WORKER_VERSION, "operations": actual, "editedPositions": positions,
                               "cacheKeyDigest": payload["cacheKeyDigest"], "resetBefore": before, "resetAfter": reset, "usesCache": True, "cacheScope": "within_trial_only",
                               "recipeDigest": payload["recipe"]["recipeDigest"] if payload["recipe"] else None}}
        except BaseException:
            engine._decode = original_decode
            try: self.reset()
            except BaseException as error: raise Rejected("RESET", "Native GNE state could not be restored", True) from error
            raise

    def close(self):
        try:
            if self.session is not None:
                self.reset()
                self.session.close()
        finally:
            self.session = None
            self.loaded = self.confirmed = False
            self.validated_cells.clear()
            self.runtime_build = None
            if self.temp is not None:
                self.temp.cleanup()
                self.temp = None
        return {"closed": True, "pid": os.getpid(), "allocationReleaseRequiresHostVerification": True}

def read_exact(stream, count):
    data = bytearray()
    while len(data) < count:
        part = stream.read(count - len(data))
        if not part:
            require(not data, "Truncated worker frame")
            return None
        data.extend(part)
    return bytes(data)


def serve():
    sys.stdout = sys.stderr  # Native libraries and warnings cannot corrupt framing.
    require(0 < MAX_FRAME <= 67108864 and all(OWNER[key] for key in OWNER) and type(OWNER["generation"]) is int,
            "Missing private worker ownership environment")
    runtime, sequence = Runtime(), 0
    while True:
        header = read_exact(sys.stdin.buffer, 4)
        if header is None:
            break
        size = struct.unpack(">I", header)[0]
        require(0 < size <= MAX_FRAME, "Worker input frame exceeds byte limit", "CAPACITY")
        raw = read_exact(sys.stdin.buffer, size)
        require(raw is not None, "Truncated worker request")
        request = parse_json(raw.decode("utf-8", "strict"))
        fields(request, ("schema", "kind", "sessionId", "jobId", "ownerId", "generation", "id", "action", "payload"))
        require(request["schema"] == PROTOCOL and request["kind"] == "request" and
                all(request[key] == value for key, value in OWNER.items()) and request["id"] == sequence + 1,
                "Worker request ownership/sequence mismatch", "IDENTITY")
        sequence += 1
        response = {key: request[key] for key in ("schema", "sessionId", "jobId", "ownerId", "generation", "id", "action")}
        response["kind"] = "response"
        closing = False
        try:
            action, payload = request["action"], request["payload"]
            if action == "hello":
                fields(payload, ())
                result = {"protocol": PROTOCOL, "workerVersion": WORKER_VERSION, "pid": os.getpid(), "workerSha256": hash_file(Path(__file__).resolve())["sha256"],
                          "pythonVersion": sys.version.split()[0], "loaded": runtime.loaded}
            elif action == "inspect":
                result = runtime.inspect(payload)
            elif action == "load":
                result = runtime.load(payload)
            elif action == "confirm_placement":
                result = runtime.confirm(payload)
            elif action == "tokenize":
                result = runtime.tokenize(payload)
            elif action == "reset":
                fields(payload, ())
                result = runtime.reset()
            elif action == "generate":
                result = runtime.generate(payload)
            elif action == "profile":
                result = runtime.profile(payload)
            elif action == "close":
                fields(payload, ())
                result, closing = runtime.close(), True
            else:
                raise Rejected("UNSUPPORTED", "Unknown worker command")
            response["result"] = result
        except Rejected as error:
            response["error"] = {"code": error.code, "message": str(error)[:4096], "fatal": error.fatal}
            closing = error.fatal
        except BaseException as error:
            # No model text, arbitrary traceback or local paths enter protocol errors.
            response["error"] = {"code": "RUNTIME_FAILURE", "message": type(error).__name__, "fatal": True}
            closing = True
        body = json.dumps(response, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")
        require(len(body) <= MAX_FRAME, "Worker response frame exceeds byte limit", "CAPACITY")
        WIRE_OUT.write(struct.pack(">I", len(body)) + body)
        WIRE_OUT.flush()
        if closing:
            break
    runtime.close()


if __name__ == "__main__":
    try:
        serve()
    except BaseException as error:
        sys.stderr.write("NOL worker retired: " + type(error).__name__ + "\n")
        sys.exit(1)
