#!/usr/bin/env python3
"""Job-owned, local NNsight final-MLP conditional-gradient observation.

Inert until explicit load and host placement confirmation. No generation,
optimizer, remote execution, request Python/source/pickle, or native edits.
The frozen prefix and residual are constants; this is not a gradient through
the preceding recurrent/attention layers. All real forwards are pre-admitted.
"""
import hashlib
import importlib.metadata
import importlib.util
import json
import math
import os
from pathlib import Path
import struct
import sys
import time

sys.dont_write_bytecode = True
VERSION = "omnius.nol.transformers-nnsight.v2"
BASE_SHA = "ea1950abcceda7d76c5fb54c3b10a73d5756cd947149d4b3b6d7be83ae12ebc0"
MODEL_SHA = "ec51c81fe0bd6a94ac364936367a5d2b307ef7482af38232d6e09f47ac989f8a"
WHEEL_SHA = "1f57daf29723f21cc53d563ff188ad218762010c72e9ea2632728e021be7b23e"
NNSIGHT_FILES = {
    "__init__.py": "7343be195826ac47aad028ae51da9245e7cddd2b2bff7263787f3d2044a7719c",
    "intervention/backward.py": "f7df224dbe649bd62b1e19354109daa897d035708d18589159266e408f8a5ce1",
    "intervention/envoy.py": "e435a85b1c4baeb65b8b1d700ee13bff0f5942f0b1944381b13d63d3fefea8d9",
    "tracing/tracer.py": "987483384da06a2cf9b914423b850705dc638d31c63d35064fb3e9b74e72c336",
    "schema/config.py": "125969eeaede7dee2f0ed3eac4018b35800eb937a454daab27512dc3f413be70",
    "_c/backtrace.py": "13492ed926d1b6edb9389de78abc92302e7281c735bfb71028b45fd255777a45",
    "_c/py_mount.cpython-313-x86_64-linux-gnu.so": "609a4cfe97cc1a3d31fe0c422085c04021150874423179e08e201c0cc31a287f",
}
ROOT = Path(__file__).resolve().parent
BASE_PATH = ROOT / "nol-transformers-worker.py"
if BASE_PATH.is_symlink() or hashlib.sha256(BASE_PATH.read_bytes()).hexdigest() != BASE_SHA:
    raise RuntimeError("Frozen Transformers base asset identity changed")
spec = importlib.util.spec_from_file_location("_nol_nnsight_frozen_base", BASE_PATH)
base = importlib.util.module_from_spec(spec)
spec.loader.exec_module(base)
require, fields, integer, number, Rejected = base.require, base.fields, base.integer, base.number, base.Rejected
ORIGINAL_BUILD = base.runtime_info


def source_pin():
    distribution = importlib.metadata.distribution("nnsight")
    require(distribution.version == "0.8.2" and sys.version_info[:2] == (3, 13), "Unreviewed NNsight/Python build", "UNSUPPORTED")
    inventory = {}
    for name, expected in NNSIGHT_FILES.items():
        actual = base.hash_file(Path(distribution.locate_file("nnsight/" + name)), 4194304)
        require(actual["sha256"] == expected, "Reviewed NNsight source changed", "IDENTITY")
        inventory[name] = actual
    return {"version": "0.8.2", "reviewedWheelSha256": WHEEL_SHA, "files": inventory}


def runtime_info(lock_path=None, hash_runtime=False, max_bytes=34359738368):
    info = ORIGINAL_BUILD(lock_path, hash_runtime, max_bytes)
    info.update(schema="omnius.nol.transformers-nnsight-build.v2", workerVersion=VERSION,
                workerSha256=base.hash_file(Path(__file__).resolve())["sha256"],
                baseWorkerSha256=BASE_SHA, reviewedNnsightSource=source_pin())
    return info


base.runtime_info = runtime_info
base.WORKER_VERSION = VERSION
EPSILONS = [0.25, 0.5]


def parse_gradient_input(payload, width=9216, vocabulary=248320):
    fields(payload, ("sourceArtifact", "messages", "objective", "siteId", "coordinates", "epsilons", "seed"))
    ref = payload["sourceArtifact"]
    fields(ref, ("uri", "sha256", "sizeBytes", "mediaType"))
    require(type(ref["sha256"]) is str and base.SHA.fullmatch(ref["sha256"]) and ref["uri"] == "omnius-artifact://sha256/" + ref["sha256"] and
            ref["mediaType"] == "application/json", "Full immutable input artifact required", "IDENTITY")
    integer(ref["sizeBytes"], 1, 65536)
    require(type(payload["siteId"]) is str and 1 <= len(payload["siteId"]) <= 128, "Bounded exact site ID required")
    messages = payload["messages"]
    require(type(messages) is list and 1 <= len(messages) <= 32, "Bounded plain text messages required")
    total = 0
    for message in messages:
        fields(message, ("role", "content"))
        require(message["role"] in ("system", "user", "assistant") and type(message["content"]) is str, "Plain text roles/content required")
        total += len(message["content"].encode("utf8"))
    require(total <= 8192, "Aggregate message byte allowance exceeded", "CAPACITY")
    objective = payload["objective"]
    fields(objective, ("kind", "targetTokenId", "position"))
    require(objective["kind"] in ("target_logit", "target_log_probability") and objective["position"] == "last_prompt_token",
            "Only host-structured last-position scalar objectives are supported", "UNSUPPORTED")
    integer(objective["targetTokenId"], 0, vocabulary - 1)
    coordinates = payload["coordinates"]
    require(type(coordinates) is list and 1 <= len(coordinates) <= 3, "One to three unique coordinates required")
    for coordinate in coordinates: integer(coordinate, 0, width - 1)
    require(len(set(coordinates)) == len(coordinates), "Duplicate coordinates")
    require(base.same_json(payload["epsilons"], EPSILONS), "Only frozen central-difference steps are supported", "UNSUPPORTED")
    integer(payload["seed"], 0, 4294967295)
    return {"schema": "omnius.nol.nnsight-gradient-input.v2", **{key: value for key, value in payload.items() if key != "sourceArtifact"}}


def tensor_hash(tensor, torch):
    require(tensor.is_contiguous(), "Exact hashing requires contiguous observed tensors", "IDENTITY")
    flat = tensor.detach().view(torch.uint8).reshape(-1)
    digest = hashlib.sha256()
    for offset in range(0, flat.numel(), 1048576):
        digest.update(flat[offset:offset + 1048576].cpu().numpy().tobytes())
    return digest.hexdigest()


def parameter_identity(parameter):
    return {"object": id(parameter), "data": parameter.data_ptr(), "version": parameter._version,
            "shape": list(parameter.shape), "dtype": str(parameter.dtype), "device": str(parameter.device)}


def hook_inventory(model):
    return {name: [len(module._forward_pre_hooks), len(module._forward_hooks), len(module._backward_pre_hooks), len(module._backward_hooks)]
            for name, module in model.named_modules()}


def f32_vector(values):
    raw = b"".join(struct.pack("<f", value) for value in values)
    return {"dtype": "f32", "shape": [len(values)], "data": values, "sha256": base.digest_bytes(raw)}


class NoLoadForwards:
    """Fail before any Module forward, including an implicit loader warmup.
    Imported only during the explicit owned load command, never at startup.
    """
    def __enter__(self):
        import torch
        self.torch, self.original, self.attempts = torch, torch.nn.Module._call_impl, 0
        def denied(module, *args, **kwargs):
            self.attempts += 1
            raise Rejected("UNSUPPORTED", "Module forwards/warmups during zero-token load are prohibited", True)
        torch.nn.Module._call_impl = denied
        return self

    def __exit__(self, kind, error, trace):
        self.torch.nn.Module._call_impl = self.original


class GradientEngine:
    """Real local NNsight/autograd math; generic CPU fixtures call this helper
    directly. Runtime.load never admits their synthetic model/device identity.
    """
    def __init__(self, model, target, residual, target_envoy_path, selected_parameters, torch, device, limits, notice=lambda _: None):
        import nnsight
        from nnsight import NNsight
        self.torch, self.model, self.target, self.residual = torch, model, target, residual
        self.device, self.limits, self.notice = device, dict(limits), notice
        self.parameters = dict(model.named_parameters(remove_duplicate=False))
        require(all(not parameter.requires_grad and parameter.grad is None and parameter.dtype == torch.float32 for parameter in self.parameters.values()),
                "Only frozen F32 native parameters without gradients are supported", "IDENTITY")
        self.identities = {name: parameter_identity(parameter) for name, parameter in self.parameters.items()}
        self.selected = selected_parameters
        self.weight_hashes = {name: tensor_hash(parameter, torch) for name, parameter in self.selected.items()}
        self.original_hooks = hook_inventory(model)
        self.active = self.context = None
        self.closed = False
        self.used_forwards = self.used_backwards = self.used_prefill = 0
        self.fake_attempts = self.denied_real_attempts = 0
        self.handles = [model.register_forward_pre_hook(self._before_forward, with_kwargs=True),
                        model.register_forward_hook(self._after_forward), target.register_forward_pre_hook(self._activation_source),
                        residual.register_forward_pre_hook(self._residual_source)]
        self.hooks = hook_inventory(model)
        self.wrapped = NNsight(model)
        envoy = self.wrapped
        for part in target_envoy_path:
            envoy = envoy[part] if type(part) is int else getattr(envoy, part)
        self.target_envoy = envoy
        self.grad_property = torch.Tensor.grad
        self.backward_function = torch.Tensor.backward
        self.grad_enabled, self.inference_enabled = torch.is_grad_enabled(), torch.is_inference_mode_enabled()
        self.saved = nnsight.save

    def _tensors(self, value):
        if isinstance(value, self.torch.Tensor): yield value
        elif type(value) in (tuple, list):
            for child in value: yield from self._tensors(child)
        elif type(value) is dict:
            for child in value.values(): yield from self._tensors(child)

    def _before_forward(self, module, args, kwargs):
        tensors = list(self._tensors((args, kwargs)))
        require(tensors, "Native forward has no bound tensor inputs", "IDENTITY")
        fake_type = self.torch._subclasses.fake_tensor.FakeTensor
        if any(tensor.device.type == "meta" or isinstance(tensor, fake_type) for tensor in tensors):
            self.fake_attempts += 1
            raise Rejected("UNSUPPORTED", "Implicit fake/meta shape scans are disabled")
        if self.active is None or self.context is None or self.context["started"]:
            self.denied_real_attempts += 1
            raise Rejected("CAPACITY", "Real forward/warmup lacks a unique pre-admitted pass")
        require(all(tensor.device == self.torch.device(self.device) for tensor in tensors), "CPU/device fallback is prohibited", "PLACEMENT")
        self.check_deadline()
        self.context["started"] = True
        self.active["startedForwards"] += 1
        self.active["prefillTokens"] += self.active["promptTokens"]
        self.notice({"phase": "forward_started", "label": self.context["label"], "prefillTokens": self.active["promptTokens"]})

    def _after_forward(self, module, args, output):
        require(self.active is not None and self.context is not None and self.context["started"] and not self.context["completed"], "Unexpected native forward completion", "IDENTITY")
        self.context["completed"] = True
        self.active["completedForwards"] += 1

    def _activation_source(self, module, args):
        require(self.context is not None and len(args) == 1 and args[0].dtype == self.torch.float32 and args[0].ndim == 3 and args[0].shape[0] == 1,
                "Unexpected actual MLP input dtype/geometry", "IDENTITY")
        self.context["activationSourceHash"] = tensor_hash(args[0], self.torch)

    def _residual_source(self, module, args):
        require(self.context is not None and len(args) == 1 and args[0].dtype == self.torch.float32, "Unexpected conditional residual source", "IDENTITY")
        self.context["residualSourceHash"] = tensor_hash(args[0], self.torch)

    def check_deadline(self):
        require(self.active is not None and time.monotonic() <= self.active["deadline"], "Gradient duration allowance exhausted", "CAPACITY")

    def _before_backward(self):
        self.check_deadline()
        require(self.context["label"] == "gradient" and self.active["backwards"] == 0, "Backward lacks a unique pre-admitted slot", "CAPACITY")
        self.active["backwards"] += 1
        self.notice({"phase": "backward_started", "label": "gradient"})

    def _metric(self, logits, objective):
        require(logits.dtype == self.torch.float32 and logits.ndim == 1, "Actual objective logits must be native F32", "IDENTITY")
        if objective["kind"] == "target_logit": return logits[objective["targetTokenId"]]
        return self.torch.log_softmax(logits.double(), dim=-1)[objective["targetTokenId"]]

    def _gradient(self, kwargs, objective, coordinates):
        torch, save = self.torch, self.saved
        with torch.enable_grad():
            with self.wrapped.trace(**kwargs):
                leaf = self.target_envoy.input.detach().clone().requires_grad_(True)
                self.target_envoy.input = leaf
                activation = save(leaf[0, -1, coordinates].detach().cpu().clone())
                output = self.wrapped.output
                require(output.past_key_values is None, "Gradient forward retained a cache", "RESET")
                logits = output.logits[0, -1]
                metric = self._metric(logits, objective)
                value = save(metric.detach().double().cpu().clone())
                self._before_backward()
                with metric.backward():
                    gradient = save(leaf.grad[0, -1, coordinates].detach().cpu().clone())
        require(gradient.dtype == torch.float32 and gradient.grad_fn is None and not gradient.requires_grad and activation.grad_fn is None,
                "Saved gradients retained an autograd graph or changed dtype", "RESET")
        require(math.isfinite(float(value)) and all(math.isfinite(item) for item in gradient.tolist() + activation.tolist()), "Nonfinite native objective/gradient")
        return {"objective": float(value), "activation": activation.tolist(), "gradient": gradient.tolist()}

    def _finite(self, kwargs, objective, coordinate, epsilon, direction):
        torch = self.torch
        point = {}
        def intervene(module, args):
            candidate = args[0].detach().clone()
            point["originalValue"] = float(candidate[0, -1, coordinate])
            candidate[0, -1, coordinate] += direction * epsilon
            point["appliedValue"] = float(candidate[0, -1, coordinate])
            require(point["appliedValue"] != point["originalValue"], "F32 perturbation collapsed to zero", "CAPACITY")
            return (candidate,)
        handle = self.target.register_forward_pre_hook(intervene)
        try:
            with torch.no_grad():
                output = self.model(**kwargs)
                require(output.past_key_values is None, "Finite-difference pass retained a cache", "RESET")
                point["objective"] = float(self._metric(output.logits[0, -1], objective))
                del output
            require(all(math.isfinite(value) for value in point.values()), "Nonfinite finite-difference observation")
            return point
        finally: handle.remove()

    def run(self, kwargs, objective, coordinates, epsilons, prompt_tokens):
        require(not self.closed and self.active is None, "Gradient engine is closed or busy", "RESET")
        expected = 1 + 2 * len(coordinates) * len(epsilons)
        require(self.used_forwards + expected <= self.limits["maxForwards"] and self.used_backwards + 1 <= self.limits["maxBackwards"] and
                self.used_prefill + expected * prompt_tokens <= self.limits["maxPrefillTokens"], "Cumulative job forward/backward/token allowance exhausted", "CAPACITY")
        self.used_forwards += expected; self.used_backwards += 1; self.used_prefill += expected * prompt_tokens
        self.notice({"phase": "profile_reserved", "forwards": expected, "backwards": 1, "prefillTokens": expected * prompt_tokens})
        self.active = {"deadline": time.monotonic() + self.limits["maxDurationMs"] / 1000, "promptTokens": prompt_tokens,
                       "startedForwards": 0, "completedForwards": 0, "prefillTokens": 0, "backwards": 0}
        passes, finite = [], []
        try:
            self.context = {"label": "gradient", "started": False, "completed": False}
            gradient = self._gradient(kwargs, objective, coordinates)
            passes.append(dict(self.context))
            for coordinate in coordinates:
                for epsilon in epsilons:
                    row = {"coordinate": coordinate, "epsilon": epsilon}
                    for direction, key in ((-1, "minus"), (1, "plus")):
                        self.context = {"label": f"fd:{coordinate}:{epsilon}:{key}", "started": False, "completed": False}
                        row[key] = self._finite(kwargs, objective, coordinate, epsilon, direction)
                        passes.append(dict(self.context))
                    finite.append(row)
            require(all(item["started"] and item["completed"] for item in passes) and len(passes) == expected and
                    self.active["startedForwards"] == expected and self.active["completedForwards"] == expected and self.active["backwards"] == 1,
                    "Actual trace/warmup/work count differs from admitted work", "IDENTITY")
            require(all(item["activationSourceHash"] == passes[0]["activationSourceHash"] and item["residualSourceHash"] == passes[0]["residualSourceHash"] for item in passes),
                    "Conditional prefix/MLP source changed across differences", "IDENTITY")
            usage = {key: value for key, value in self.active.items() if key not in ("deadline", "promptTokens")}
            usage.update(fakeScanAttempts=self.fake_attempts, deniedRealAttempts=self.denied_real_attempts, sampledTokens=0,
                         reservedForwards=self.used_forwards, reservedBackwards=self.used_backwards, reservedPrefillTokens=self.used_prefill)
            return {"autogradObjective": gradient["objective"], "activationF32": f32_vector(gradient["activation"]), "gradientF32": f32_vector(gradient["gradient"]),
                    "finiteDifferences": finite, "passes": passes, "usage": usage}
        finally:
            self.context = self.active = None

    def reset(self):
        require(self.active is None and self.context is None, "Active graph/context survived the observation", "RESET")
        require(self.torch.Tensor.grad is self.grad_property and self.torch.Tensor.backward is self.backward_function and
                self.torch.is_grad_enabled() == self.grad_enabled and self.torch.is_inference_mode_enabled() == self.inference_enabled,
                "Torch autograd property/context was not restored", "RESET")
        require(hook_inventory(self.model) == self.hooks, "Transient NNsight/intervention hooks survived", "RESET")
        for name, parameter in self.parameters.items():
            require(not parameter.requires_grad and parameter.grad is None and parameter_identity(parameter) == self.identities[name],
                    "Frozen base parameters/gradients/storage versions changed", "RESET")
        observed = {name: tensor_hash(parameter, self.torch) for name, parameter in self.selected.items()}
        require(observed == self.weight_hashes, "Selected full native F32 weight bytes changed", "RESET")
        return {"schema": "omnius.nol.nnsight-reset.v2", "retainedGraph": False, "parameterGradientsNone": True, "gradContextRestored": True,
                "transientHooks": 0, "persistentHostBudgetHooks": 4, "retainedCache": False,
                "selectedWeightHashes": observed, "baseParameterIdentityDigest": base.digest_bytes(base.canonical_simple(self.identities).encode()),
                "baseParameterCount": len(self.identities), "fullBaseMemoryBitwiseHashPerformed": False,
                "weightProofScope": "all_original_storage_version_identities_and_selected_full_native_f32_weight_bytes"}

    def close(self):
        if self.closed: return
        self.reset()
        for handle in self.handles: handle.remove()
        require(hook_inventory(self.model) == self.original_hooks, "Budget hook removal failed", "RESET")
        self.closed = True
        self.wrapped = self.target_envoy = None


class Runtime(base.Runtime):
    def __init__(self):
        super().__init__()
        self.engine = self.gradient_limits = self.work_root = self.journal = None
        self.journal_bytes = 0
        self.poisoned = self.closed = False

    def notice(self, value):
        raw = (base.canonical_simple(value) + "\n").encode()
        require(self.journal is not None and self.journal_bytes + len(raw) <= self.gradient_limits["maxCaptureBytes"], "Progress journal storage allowance exhausted", "CAPACITY")
        offset = 0
        while offset < len(raw):
            wrote = os.write(self.journal, raw[offset:]); require(wrote > 0, "Progress write stalled"); offset += wrote
        os.fsync(self.journal)
        self.journal_bytes += len(raw)

    def load(self, payload):
        fields(payload, ("checkpointRoot", "artifactRoot", "model", "binding", "gpuUuid", "dtype", "identity", "dependencyLockPath", "limits", "gradient"))
        require(not self.loaded and not self.closed and payload["model"]["modelDigest"] == MODEL_SHA and payload["dtype"] == "float32",
                "Only the approved original 4B view with actual full F32 compute is supported", "UNSUPPORTED")
        limits = payload["gradient"]
        fields(limits, ("workRoot", "maxForwards", "maxBackwards", "maxPrefillTokens", "maxCoordinates", "maxPromptTokens", "maxCaptureBytes", "maxDurationMs"))
        for key, maximum in (("maxForwards", 13), ("maxBackwards", 1), ("maxPrefillTokens", 416), ("maxCoordinates", 3), ("maxPromptTokens", 32), ("maxCaptureBytes", 1048576), ("maxDurationMs", 600000)):
            integer(limits[key], 1, maximum)
        require(payload["limits"]["maxInputTokens"] <= limits["maxPromptTokens"] and payload["limits"]["maxWorkingBytes"] >= 2097152,
                "Explicit bounded forward/working admission required", "CAPACITY")
        work = Path(limits["workRoot"])
        require(work.is_absolute() and work.is_dir() and not work.is_symlink() and work.resolve() == work and not list(work.iterdir()) and
                work.stat().st_uid == os.getuid() and work.stat().st_mode & 0o077 == 0, "Empty owned mode700 workRoot required", "IDENTITY")
        for root in (Path(payload["checkpointRoot"]).resolve(), Path(payload["artifactRoot"]).resolve()):
            require(not work.is_relative_to(root) and not root.is_relative_to(work), "Work root overlaps immutable inputs", "IDENTITY")
        self.work_root, self.gradient_limits = work, dict(limits)
        self.journal = os.open(work / "gradient-progress.jsonl", os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600)
        config = work / "nnsight-config.yaml"
        descriptor = os.open(config, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600)
        with os.fdopen(descriptor, "w") as stream:
            stream.write("APP:\n  PYMOUNT: false\n  REMOTE_LOGGING: false\n  DEBUG: false\n  DISABLE_CPP_BACKTRACE: true\nAPI:\n  HOST: disabled://local-only\n  APIKEY: null\n")
            stream.flush(); os.fsync(stream.fileno())
        os.environ["NNSIGHT_CONFIG"] = str(config)
        os.environ.pop("NDIF_API_KEY", None); os.environ.pop("NDIF_HOST", None)
        with NoLoadForwards() as load_guard:
            result = super().load({key: value for key, value in payload.items() if key != "gradient"})
        require(load_guard.attempts == 0, "Unadmitted loader warmup attempted", "IDENTITY")
        for parameter in self.model.parameters(): parameter.requires_grad_(False)
        require(all(parameter.dtype == self.torch.float32 for parameter in self.model.parameters()), "Actual model parameters were not loaded at F32", "IDENTITY")
        self.torch.set_float32_matmul_precision("highest")
        self.torch.backends.cuda.matmul.allow_tf32 = False
        self.torch.backends.cudnn.allow_tf32 = False
        self.site = next((site for site in self.manifest["tensorSites"] if site["kind"] == "mlp_intermediate" and site["layer"] == 31 and site["width"] == 9216), None)
        require(self.site is not None and type(self.layers[31].mlp.down_proj).__name__ == "Linear", "Exact final native MLP site missing", "IDENTITY")
        result.update(implementation=VERSION, baseWorkerSha256=BASE_SHA, supportedRuntimeOperations=[], supportedParameterOperations=[],
                      supportedObservations=["conditional_final_mlp_gradient"], nativeCapabilityAuthority=False, computeDtype="float32",
                      gradientReady=False, optimizerSupported=False, remoteSupported=False, implicitScansSupported=False, moduleForwardsDuringLoad=0,
                      conditionalSite={"siteId": self.site["id"], "layer": 31, "width": 9216, "position": "last_prompt_token"})
        return result

    def confirm(self, payload):
        result = super().confirm(payload)
        require(self.engine is None, "Gradient wrapper cannot be reinitialized", "RESET")
        parameters = dict(self.model.named_parameters(remove_duplicate=False))
        names = ["model.language_model.layers.31.mlp.down_proj.weight", "model.language_model.norm.weight", "lm_head.weight"]
        require(all(name in parameters for name in names), "Reviewed native gradient-tail parameters missing", "IDENTITY")
        self.engine = GradientEngine(self.model, self.layers[31].mlp.down_proj, self.layers[31].post_attention_layernorm,
                                    ["model", "language_model", "layers", 31, "mlp", "down_proj"],
                                    {name: parameters[name] for name in names}, self.torch, "cuda:0", self.gradient_limits, self.notice)
        result.update(gradientReady=True, forwardsBeforeConfirmation=self.engine.used_forwards, backwardsBeforeConfirmation=self.engine.used_backwards)
        return result

    def ready(self):
        require(not self.poisoned and not self.closed and self.engine is not None, "Gradient worker is unloaded/unconfirmed/retired", "RESET")
        super().ready()

    def reset(self):
        try:
            state = self.engine.reset() if self.engine is not None else None
            result = super().reset()
            if state is not None: result["gradient"] = state; self.last_reset = result
            return result
        except BaseException as error:
            self.poisoned = True
            raise Rejected("RESET", "Gradient graph/parameter/context release could not be verified", True) from error

    def profile(self, payload):
        self.ready()
        source_body = parse_gradient_input(payload)
        require(payload["siteId"] == self.site["id"] and len(payload["coordinates"]) <= self.gradient_limits["maxCoordinates"], "Only the bound final MLP coordinates are supported", "UNSUPPORTED")
        ref = payload["sourceArtifact"]
        path = base.safe_path(self.artifact_root, ref["sha256"][:2] + "/" + ref["sha256"])
        require(base.hash_file(path, 65536) == {"sha256": ref["sha256"], "sizeBytes": ref["sizeBytes"]}, "Input artifact changed", "IDENTITY")
        with path.open("rb") as stream: data = stream.read(ref["sizeBytes"] + 1)
        require(len(data) == ref["sizeBytes"] and base.digest_bytes(data) == ref["sha256"] and
                base.same_json(base.parse_json(data.decode("utf8", "strict")), source_body), "Input artifact does not bind the actual structured request", "IDENTITY")
        tokenized = self.tokenize({"messages": payload["messages"]})
        tokens = tokenized["tokenIds"]; count = len(tokens)
        require(1 <= count <= self.gradient_limits["maxPromptTokens"], "Gradient prompt token allowance exceeded", "CAPACITY")
        parameters = sum(parameter.numel() for parameter in self.model.parameters())
        expected = 1 + 2 * len(payload["coordinates"]) * len(payload["epsilons"])
        working = (count * 32 * (9216 * 16 + 2560 * 32) * 4 + ((count + 63) // 64) * 24 * 32 * 128 * 128 * 4 * 8
                   + 8 * 16 * count * count * 4 * 8 + count * (9216 + 2560) * 16 + 248320 * 32 + 512 * 1048576 + 2097152)
        arithmetic = expected * (4 * parameters * count + 24 * count * 32 * 128 * 128 * 32) + 4 * (2560 * 9216 * count + 248320 * 2560)
        require(working <= self.limits["maxWorkingBytes"] and arithmetic <= self.limits["maxMultiplyAdds"], "Native forward/backward compute or working admission failed", "CAPACITY")
        require(self.torch.get_float32_matmul_precision() == "highest" and not self.torch.backends.cuda.matmul.allow_tf32 and not self.torch.backends.cudnn.allow_tf32,
                "Full F32/TF32-disabled numerical policy changed", "IDENTITY")
        self.torch.manual_seed(payload["seed"]); self.torch.cuda.manual_seed_all(payload["seed"])
        before = self.reset()
        self.torch.cuda.reset_peak_memory_stats()
        memory_before = self.torch.cuda.memory_allocated()
        try:
            ids = self.torch.tensor([tokens], device="cuda:0", dtype=self.torch.long)
            kwargs = {"input_ids": ids, "attention_mask": self.torch.ones_like(ids), "use_cache": False, "logits_to_keep": 1}
            observed = self.engine.run(kwargs, payload["objective"], payload["coordinates"], payload["epsilons"], count)
            del kwargs, ids
            after = self.reset()
            self.torch.cuda.synchronize()
            peak_delta = max(0, self.torch.cuda.max_memory_allocated() - memory_before)
            require(peak_delta <= self.limits["maxWorkingBytes"], "Observed CUDA peak exceeded admitted working bytes", "CAPACITY")
            return {"schema": "omnius.nol.nnsight-gradient-observation.v2", "sourceArtifact": ref, "siteId": self.site["id"], "layer": 31,
                    "objective": payload["objective"], "coordinates": payload["coordinates"], "epsilons": payload["epsilons"], "seed": payload["seed"],
                    "promptTokenIds": tokens, "computeDtype": "float32", "logProbabilityReductionDtype": "float64", "conditionalPrefixDetached": True,
                    "gradientOrientation": "d_objective_d_final_mlp_intermediate", **observed,
                    "native": {"binding": self.binding, "implementation": VERSION, "baseWorkerSha256": BASE_SHA, "resetBefore": before, "resetAfter": after,
                               "usesCache": False, "optimizerSteps": 0, "workingBytesBound": working, "arithmeticUnitsBound": arithmetic, "peakAdditionalCudaBytes": peak_delta,
                               "progressJournal": {"name": "gradient-progress.jsonl", **base.hash_file(self.work_root / "gradient-progress.jsonl", self.gradient_limits["maxCaptureBytes"])}}}
        except BaseException as error:
            self.poisoned = True
            try: self.reset()
            except BaseException: pass
            raise Rejected("GRADIENT_FAILED", "Gradient observation failed; reserved work remains charged and worker must retire", True) from error

    def generate(self, payload):
        raise Rejected("UNSUPPORTED", "Gradient workers do not generate tokens or accept runtime/parameter operation recipes")

    def close(self):
        if self.closed: return {"closed": True, "allocationReleaseRequiresHostVerification": True}
        try:
            if self.engine is not None: self.engine.close(); self.engine = None
            result = super().close(); self.closed = True
            return result
        finally:
            if self.journal is not None: os.close(self.journal); self.journal = None


def serve():
    sys.stdout = sys.stderr
    require(0 < base.MAX_FRAME <= 67108864 and all(base.OWNER.values()), "Private ownership and bounded framing required")
    runtime, sequence = Runtime(), 0
    try:
        while True:
            header = base.read_exact(sys.stdin.buffer, 4)
            if header is None: break
            size = struct.unpack(">I", header)[0]; require(0 < size <= base.MAX_FRAME, "Frame bound exceeded", "CAPACITY")
            raw = base.read_exact(sys.stdin.buffer, size); require(raw is not None, "Truncated frame")
            request = base.parse_json(raw.decode("utf8", "strict"))
            fields(request, ("schema", "kind", "sessionId", "jobId", "ownerId", "generation", "id", "action", "payload"))
            require(request["schema"] == base.PROTOCOL and request["kind"] == "request" and all(request[key] == value for key, value in base.OWNER.items()) and request["id"] == sequence + 1,
                    "Owner/generation/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": base.PROTOCOL, "workerVersion": VERSION, "workerSha256": base.hash_file(Path(__file__).resolve())["sha256"],
                        "baseWorkerSha256": BASE_SHA, "pid": os.getpid(), "loaded": runtime.loaded, "torchImported": "torch" in sys.modules, "nnsightImported": "nnsight" in sys.modules,
                        "nativeCapabilityAuthority": False}
                elif action in ("inspect", "load", "tokenize", "profile", "generate"): result = getattr(runtime, action)(payload)
                elif action == "confirm_placement": result = runtime.confirm(payload)
                elif action in ("reset", "close"): fields(payload, ()); result = getattr(runtime, action)(); closing = action == "close"
                else: raise Rejected("UNSUPPORTED", "Unknown NNsight worker action")
                response["result"] = result
            except Rejected as error:
                closing = error.fatal or action in ("load", "confirm_placement", "close") or runtime.poisoned
                response["error"] = {"code": error.code, "message": str(error)[:4096], "fatal": closing}
            except BaseException as error:
                base.private_diagnostic(error); closing = True
                response["error"] = {"code": "RUNTIME_FAILURE", "message": type(error).__name__, "fatal": True}
            encoded = json.dumps(response, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf8")
            require(len(encoded) <= base.MAX_FRAME, "Response frame bound exceeded", "CAPACITY")
            base.WIRE_OUT.write(struct.pack(">I", len(encoded)) + encoded); base.WIRE_OUT.flush()
            if closing: break
    finally: runtime.close()


if __name__ == "__main__":
    try: serve()
    except BaseException as error: base.private_diagnostic(error); sys.exit(1)
