"""Phase 4AJ graded-APL output-timing adapter of the sealed Phase 4AG oracle.

Brian has no Torch dependency.  A separate, pinned science-Python process
executes the unchanged legacy float32 APL operations from Brian's own spikes.
This is independent LIF/scheduling validation with a shared APL numerical
component, NOT an all-components-independent CPU oracle.  Only generated h
transport is changed: h[t-D] is written at end(t), D in {0,18}.  The original
Brian equations, anatomical delay, refractory policy and queue proxy stay as
in the sealed source.  No future brain or APL generation ticks are run.
"""
from __future__ import annotations

import csv
import hashlib
import importlib.metadata
import json
import math
import os
import platform
import queue
import struct
import subprocess
import sys
import threading
import time
import types
from contextlib import ExitStack
from pathlib import Path

import numpy as np


BLOCK_BYTES = 8 << 20
BASE_ORACLE_PATH = Path("/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/oracle_apl.py")
BASE_ORACLE_SHA256 = "357a7d3debb5abc34a8714c0233b456547a154d9d5855d28661b4f01019a80ea"
LEGACY_WORKER_PATH = Path("/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py")
LEGACY_WORKER_SHA256 = "21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291"
PROTOCOL = "phase4ag-apl-v1"
AUTHOR_PATH = Path("/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py")
AUTHOR_SHA256 = "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e"
AE_PATH = Path("/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1/oracle_stress.py")
AE_SHA256 = "32eb1c42383068ce52701d2139a376ce155ad7072cde019949f8ca2d55492409"
AF_PATH = Path("/data/digital-drosophila/models/male-cns-lif/author-fullgraph-lab-v1/oracle_full.py")
AF_SHA256 = "d72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961"
EVENT_DTYPE = np.dtype([("step", "<i4"), ("neuron_idx", "<i4")])
BUNDLE_FILES = ("input_matrix.npy", "output_matrix.npy", "kc_globals.npy", "apl_globals.npy")
_PROCESS_USED = False


def _check(condition, message):
    if not condition:
        raise ValueError(message)


def _save(path, value):
    with Path(path).open("x", encoding="utf-8") as handle:
        json.dump(value, handle, indent=2, sort_keys=True, allow_nan=False)
        handle.write("\n")


def _digest(path):
    result = hashlib.sha256()
    with Path(path).open("rb") as handle:
        for block in iter(lambda: handle.read(BLOCK_BYTES), b""):
            result.update(block)
    return result.hexdigest()


def _array_hash(array, dtype):
    return hashlib.sha256(np.ascontiguousarray(array, dtype=dtype).tobytes()).hexdigest()


def _load_checked(path, expected, name):
    data = Path(path).read_bytes()
    _check(hashlib.sha256(data).hexdigest() == expected, f"Pinned source hash mismatch: {path}")
    module = types.ModuleType(name)
    module.__file__ = str(path)
    exec(compile(data, str(path), "exec"), module.__dict__)
    return module


def _python_entry(path):
    """A venv is selected by its invocation path, not the resolved ELF target."""
    entry = Path(path).absolute()
    _check(entry.is_file(), f"Missing declared Python entry: {entry}")
    return entry


def _new_memmap(path, dtype, shape):
    _check(not Path(path).exists(), f"Refusing to overwrite output: {path}")
    return np.lib.format.open_memmap(path, mode="w+", dtype=dtype, shape=shape)


def _budget(root, limit, reserve=0):
    total = 0
    for directory, _, filenames in os.walk(root, followlinks=False):
        for filename in filenames:
            total += (Path(directory) / filename).stat(follow_symlinks=False).st_size
    _check(total + int(reserve) <= limit,
           f"Output budget exceeded: {total}+{reserve}>{limit}; inputs and duration were not adjusted")
    return total


class _APLDelayFIFO:
    """Independent list transport; no Brian/Torch import, arithmetic, or feedback.

    Start with D distinct positive-zero vectors.  On tick t, append a copy of
    generated h[t], then pop the oldest vector.  The remaining D vectors are
    pending applications at ticks T..T+D-1 after T steps, NOT new future output.
    """

    def __init__(self, delay_steps):
        _check(type(delay_steps) is int and delay_steps in (0, 18),
               "apl_delay_steps must be an explicit integer 0 or 18")
        self.delay_steps = delay_steps
        self.tick = 0
        self.finished = False
        self.queue = [np.zeros(4064, dtype=np.float32) for _ in range(delay_steps)]

    def step(self, tick, generated):
        _check(not self.finished and type(tick) is int and tick == self.tick,
               "APL FIFO ticks must be consecutive and cannot follow finish")
        value = np.asarray(generated)
        _check(value.dtype == np.dtype("float32") and value.shape == (4064,) and
               np.isfinite(value).all() and np.all(value >= 0),
               "APL FIFO requires one finite nonnegative float32 full-KC vector")
        self.queue.append(value.copy())
        applied = self.queue.pop(0)
        _check(len(self.queue) == self.delay_steps, "APL FIFO length changed")
        self.tick += 1
        return applied

    def finish(self, steps):
        _check(not self.finished and type(steps) is int and steps == self.tick,
               "APL FIFO did not cover every requested tick")
        self.finished = True
        if not self.queue:
            return np.empty((0, 4064), dtype=np.float32)
        return np.stack(self.queue).astype(np.float32, copy=False)


class _PipeReader:
    """One bounded reader thread, with timeout/EOF checks for every frame."""

    def __init__(self, pipe, timeout):
        self.pipe, self.timeout = pipe, float(timeout)
        self.chunks = queue.Queue(maxsize=8)
        self.buffer = bytearray()
        self.thread = threading.Thread(target=self._pump, daemon=True)
        self.thread.start()

    def _pump(self):
        try:
            while True:
                chunk = os.read(self.pipe.fileno(), 65536)
                self.chunks.put(chunk)
                if not chunk:
                    return
        except BaseException as error:
            self.chunks.put(error)

    def _fill(self, deadline):
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise TimeoutError("APL sidecar response timed out")
        try:
            chunk = self.chunks.get(timeout=remaining)
        except queue.Empty as error:
            raise TimeoutError("APL sidecar response timed out") from error
        if isinstance(chunk, BaseException):
            raise RuntimeError("APL sidecar stdout reader failed") from chunk
        if not chunk:
            raise EOFError("APL sidecar ended before a complete response")
        self.buffer.extend(chunk)

    def read(self, size):
        deadline = time.monotonic() + self.timeout
        while len(self.buffer) < size:
            self._fill(deadline)
        result = bytes(self.buffer[:size])
        del self.buffer[:size]
        return result

    def line(self):
        deadline = time.monotonic() + self.timeout
        while b"\n" not in self.buffer:
            _check(len(self.buffer) < 1 << 20, "APL sidecar handshake exceeds 1 MiB")
            self._fill(deadline)
        end = self.buffer.index(b"\n") + 1
        result = bytes(self.buffer[:end])
        del self.buffer[:end]
        return result


class _APLWorker:
    def __init__(self, python, script, bundle_dir, stderr, timeout=180):
        self.command = [str(python), "-B", str(script), "--bundle-dir", str(bundle_dir), "--dt-ms", "0.1"]
        self.process = subprocess.Popen(self.command, stdin=subprocess.PIPE,
            stdout=subprocess.PIPE, stderr=stderr, bufsize=0, shell=False)
        self.reader = _PipeReader(self.process.stdout, timeout)
        self.tick = 0
        try:
            self.hello = json.loads(self.reader.line().decode("utf-8"))
            _check(self.hello.get("ok") is True, "APL sidecar did not acknowledge initialization")
            _check(self.hello.get("protocol") == PROTOCOL, "Unexpected APL sidecar protocol")
            for key, value in (("n_neurons", 166700), ("n_apl", 2), ("n_kc", 4064)):
                _check(self.hello.get(key) == value, f"APL sidecar changed {key}")
            _check(self.hello.get("dt_ms") == .1, "APL sidecar changed dt")
            expected_decay = f"{int(np.float32(math.exp(-.1 / 20.)).view(np.uint32)):08x}"
            expected_gain = f"{int(np.float32(.01).view(np.uint32)):08x}"
            _check(self.hello.get("decay_f32_bits") == expected_decay and self.hello.get("gain_f32_bits") == expected_gain,
                   "APL sidecar decay/gain differs from the frozen float32 scalars")
            _check(self.hello.get("files_sha256") == {name: _digest(bundle_dir / name) for name in BUNDLE_FILES},
                   "APL sidecar bundle hashes differ from the independently read bundle")
        except BaseException:
            self.abort()
            raise

    def step(self, tick, global_spikes):
        _check(tick == self.tick, "APL sidecar request ticks must be consecutive")
        nodes = np.asarray(global_spikes)
        _check(nodes.ndim == 1 and nodes.dtype == np.dtype("int32"), "APL input spikes must be int32 globals")
        _check(not len(nodes) or (nodes[0] >= 0 and nodes[-1] < 166700 and np.all(np.diff(nodes) > 0)),
               "APL input spikes must be sorted, unique, and in the frozen global range")
        packet = struct.pack("<qQ", int(tick), len(nodes)) + np.ascontiguousarray(nodes, dtype="<i4").tobytes()
        view = memoryview(packet)
        while view:
            written = self.process.stdin.write(view)
            if not written:
                raise BrokenPipeError("APL sidecar stdin failed")
            view = view[written:]
        self.process.stdin.flush()
        response_tick, byte_count = struct.unpack("<qQ", self.reader.read(16))
        _check(response_tick == tick and byte_count == (2 + 2 + 4064) * 4,
               "APL sidecar frame tick/length mismatch")
        values = np.frombuffer(self.reader.read(byte_count), dtype="<f4")
        _check(np.isfinite(values).all() and np.all(values >= 0), "APL sidecar returned invalid nonnegative f32 states")
        self.tick += 1
        return values[:2], values[2:4], values[4:]

    def finish(self, steps):
        _check(self.tick == steps, "APL sidecar did not process every tick")
        self.process.stdin.close()
        status = self.process.wait(timeout=30)
        _check(status == 0, f"APL sidecar exited unsuccessfully: {status}")
        self.reader.thread.join(timeout=5)
        _check(not self.reader.thread.is_alive(), "APL stdout did not reach EOF")
        extra = bytes(self.reader.buffer)
        while not self.reader.chunks.empty():
            chunk = self.reader.chunks.get_nowait()
            _check(not isinstance(chunk, BaseException), "APL stdout reader failed after the last frame")
            extra += chunk
        _check(not extra, "APL sidecar emitted unrequested trailing stdout bytes")
        self.process.stdout.close()
        return status

    def abort(self):
        if self.process.poll() is None:
            self.process.terminate()
            try:
                self.process.wait(timeout=5)
            except subprocess.TimeoutExpired:
                self.process.kill()
                self.process.wait(timeout=5)
        for handle in (self.process.stdin, self.process.stdout):
            if handle is not None and not handle.closed:
                handle.close()


def _graph_inputs(directory):
    arrays = {}
    definitions = {"nodes": "int32", "edge_id": "int64", "src": "int32",
                   "dst": "int32", "signed_raw": "int64", "ptr": "int64", "weights": "float64"}
    for name, dtype in definitions.items():
        value = np.load(directory / (name + ".npy"), mmap_mode="r", allow_pickle=False)
        _check(value.ndim == 1 and value.dtype == np.dtype(dtype), f"Invalid graph array {name}")
        arrays[name] = value
    nodes, edge_ids = arrays["nodes"], arrays["edge_id"]
    n, edges = len(nodes), len(edge_ids)
    _check(0 < n <= 166700 and edges > 0, "A case needs real global nodes and explicit nonempty connectivity")
    _check(nodes[0] >= 0 and nodes[-1] < 166700 and np.all(np.diff(nodes) > 0), "Invalid global node order")
    for name in ("src", "dst", "signed_raw", "weights"):
        _check(arrays[name].shape == (edges,), f"Graph array {name} has the wrong shape")
    pointer = arrays["ptr"]
    _check(pointer.shape == (n + 1,) and pointer[0] == 0 and pointer[-1] == edges and
           np.all(np.diff(pointer) >= 0), "Invalid graph CSR pointer")
    source_counts = np.zeros(n, np.int64)
    identity_edges = True
    previous_source, previous_edge = -1, -1
    width = BLOCK_BYTES // 8
    for begin in range(0, edges, width):
        stop = min(edges, begin + width)
        source, target, ids = arrays["src"][begin:stop], arrays["dst"][begin:stop], edge_ids[begin:stop]
        _check(np.all((source >= 0) & (source < n)) and np.all((target >= 0) & (target < n)),
               "Graph edge endpoint is outside the local node array")
        _check(np.all(ids >= 0), "Graph edge IDs must be nonnegative")
        _check(source[0] > previous_source or (source[0] == previous_source and ids[0] > previous_edge),
               "Graph edge blocks are not in canonical source/edge order")
        _check(np.all((source[1:] > source[:-1]) |
                      ((source[1:] == source[:-1]) & (ids[1:] > ids[:-1]))),
               "Graph edges are not in canonical source/edge order")
        previous_source, previous_edge = int(source[-1]), int(ids[-1])
        identity_edges &= np.array_equal(ids, np.arange(begin, stop, dtype=np.int64))
        source_counts += np.bincount(source, minlength=n)
        _check(np.isfinite(arrays["weights"][begin:stop]).all(), "Nonfinite graph weights")
    _check(np.array_equal(source_counts, np.diff(pointer)), "CSR pointer and source rows disagree")
    if not identity_edges:
        _check(len(np.unique(edge_ids)) == edges, "Original edge IDs must be unique")
    for name in ("completeness.csv", "connectivity.parquet"):
        _check((directory / name).is_file(), f"Missing unchanged author input: {name}")
    if n == 166700:
        _check(edges == 25582938 and identity_edges and np.array_equal(nodes, np.arange(n, dtype=np.int32)),
               "A full probe must use the unchanged complete canonical graph")
    return arrays, identity_edges


def _requests(case_dir, nodes, steps):
    with np.load(case_dir / "requests.npz", allow_pickle=False) as archive:
        _check(set(archive.files) == {"tick", "neuron_idx"}, "Unexpected sparse request schema")
        ticks, requested = archive["tick"].copy(), archive["neuron_idx"].copy()
    _check(ticks.dtype == requested.dtype == np.dtype("int32") and ticks.ndim == requested.ndim == 1 and
           ticks.shape == requested.shape, "Requests must be equal-length int32 vectors")
    _check(np.all((ticks >= 0) & (ticks < steps)), "Request time outside the case")
    _check(not len(ticks) or np.all((ticks[1:] > ticks[:-1]) |
           ((ticks[1:] == ticks[:-1]) & (requested[1:] > requested[:-1]))),
           "Requests must be sorted and unique by tick/global node")
    local = np.searchsorted(nodes, requested)
    _check(np.all(local < len(nodes)) and np.array_equal(nodes[local], requested),
           "Request references a global neuron absent from this case")
    counts = np.bincount(ticks, minlength=steps).astype(np.int32)
    pointer = np.concatenate((np.zeros(1, np.int64), np.cumsum(counts, dtype=np.int64)))
    return requested, local.astype(np.int32), pointer, counts


class _QueueProxy:
    def __init__(self, original, get_tick, available, arrays, identity_edges,
                 due_counts, spike_ring, delay_steps, handle, records, summarize):
        self._original_queue, self._get_tick = original, get_tick
        self._available, self._arrays, self._identity_edges = available, arrays, identity_edges
        self._due_counts, self._spike_ring, self._delay_steps = due_counts, spike_ring, delay_steps
        self._handle, self._records, self._summarize = handle, records, summarize

    def peek(self, *args, **kwargs):
        original = self._original_queue.peek(*args, **kwargs)
        local_edges = np.asarray(original)
        tick = self._get_tick()
        _check(tick == len(self._records["rows"]), "Queue peek ticks must be consecutive")
        _check(local_edges.ndim == 1 and np.all((local_edges >= 0) & (local_edges < len(self._arrays["edge_id"]))),
               "Original queue contains an invalid local edge index")
        _check(len(local_edges) == self._due_counts[tick % len(self._due_counts)],
               "Queue arrivals differ from the fixed-delay outgoing degree of actual spikes")
        fired_then = np.zeros(len(self._arrays["nodes"]), dtype=bool)
        if tick >= self._delay_steps:
            fired_then[self._spike_ring[(tick - self._delay_steps) % len(self._spike_ring)]] = True

        def accepted(begin, stop):
            part = local_edges[begin:stop]
            _check(np.all(fired_then[self._arrays["src"][part]]), "Arrival lacks a presynaptic spike at author delay")
            return self._available[self._arrays["dst"][part]]

        # Only the observed ID view changes; the queue is returned verbatim.
        edge_ids = local_edges if self._identity_edges else self._arrays["edge_id"][local_edges]
        summary = self._summarize(tick, edge_ids, accepted)
        self._handle.write(json.dumps(summary, sort_keys=True) + "\n")
        self._records["rows"].append(summary)
        self._records["peek_calls"] += 1
        return original

    def advance(self, *args, **kwargs):
        self._records["advance_calls"] += 1
        return self._original_queue.advance(*args, **kwargs)

    def __getattr__(self, name):
        return getattr(self._original_queue, name)


def run_case(case_dir: Path, out_dir: Path) -> dict:
    """Run one continuous case, with exclusive outputs and no candidate trace input.

    Graph inputs are the AF array/author-table schema plus original weights.npy.
    requests.npz contains sparse tick/neuron_idx int32 vectors.  Optional
    arrays.npz contains initial_v_mv/initial_g_mv float64 vectors only.
    Full probes write state hashes, sparse events and APL traces, not dense
    whole-brain histories.  Each case requires a fresh process.
    """
    global _PROCESS_USED
    _check(not _PROCESS_USED, "Every oracle case requires a fresh process")
    _PROCESS_USED = True
    case_dir, out_dir = Path(case_dir).resolve(strict=True), Path(out_dir).resolve()
    spec = json.loads((case_dir / "spec.json").read_text(encoding="utf-8"))
    graph_dir = Path(spec["graph_dir"]).resolve(strict=True)
    bundle_dir = Path(spec["apl_bundle_dir"]).resolve(strict=True)
    worker_path = Path(spec["legacy_apl_worker"]).resolve(strict=True)
    _check(worker_path == LEGACY_WORKER_PATH.resolve(strict=True),
           "The APL worker must remain the sealed Phase4AG-v2 worker")
    _check(_digest(worker_path) == LEGACY_WORKER_SHA256, "Frozen Phase4AG-v2 APL worker changed")
    _check(_digest(BASE_ORACLE_PATH) == BASE_ORACLE_SHA256, "Sealed oracle source baseline changed")
    science_python = _python_entry(spec["science_python"])
    author_path = Path(spec.get("author_path", AUTHOR_PATH)).resolve(strict=True)
    ae_path = Path(spec.get("ae_oracle_path", AE_PATH)).resolve(strict=True)
    af_path = Path(spec.get("af_oracle_path", AF_PATH)).resolve(strict=True)
    coefficients_path = Path(spec["coefficients_path"]).resolve(strict=True)
    steps = int(spec["steps"])
    apl_delay_steps = spec["apl_delay_steps"]
    _check(type(apl_delay_steps) is int and apl_delay_steps in (0, 18),
           "apl_delay_steps must be an explicit integer 0 or 18")
    _check(steps == spec["steps"] and 0 < steps <= np.iinfo(np.int32).max, "Invalid number of steps")
    _check(float(spec["dt_ms"]) == .1 and np.isclose(float(spec["duration_ms"]), steps * .1, rtol=0, atol=1e-12),
           "The frozen APL protocol requires dt_ms=0.1 and a matching duration")
    _check(spec.get("precision", "float64") == "float64", "Author state must be float64")
    _check(spec.get("training", False) is False and spec.get("poi_used", False) is False,
           "Training and original poi are outside this gate")
    _check(spec["apl"] == {"tau_ms": 20, "gain": .01, "normalization": 1}, "Frozen APL parameters changed")
    record_history = spec["record_history"]
    _check(isinstance(record_history, bool), "record_history must be a boolean")
    budget_root = Path(spec.get("budget_root", out_dir.parent)).resolve()
    budget_limit = int(spec.get("output_budget_bytes", 15 * 1024 ** 3))
    _check(budget_limit > 0 and out_dir.is_relative_to(budget_root), "Invalid output budget/root")
    out_dir.mkdir(parents=True, exist_ok=False)
    mapped_files = []
    saved_preferences, old_dt, worker = None, None, None
    last_complete_tick = -1
    try:
        arrays, identity_edges = _graph_inputs(graph_dir)
        nodes, n, edges = arrays["nodes"], len(arrays["nodes"]), len(arrays["edge_id"])
        _check(n < 166700 or not record_history, "Full probes must not save dense V/g/ref histories")
        bundle = {name: np.load(bundle_dir / (name + ".npy"), mmap_mode="r", allow_pickle=False)
                  for name in ("input_matrix", "output_matrix", "kc_globals", "apl_globals")}
        for name, shape in (("input_matrix", (2, 166700)), ("output_matrix", (2, 4064))):
            value = bundle[name]
            _check(value.dtype == np.dtype("float32") and value.shape == shape and value.flags.c_contiguous,
                   f"Frozen APL {name} shape/dtype/layout changed")
            _check(np.isfinite(value).all() and np.all(value >= 0), f"Invalid positive raw-normalized APL {name}")
        for name, count in (("kc_globals", 4064), ("apl_globals", 2)):
            value = bundle[name]
            _check(value.dtype == np.dtype("int32") and value.shape == (count,) and value[0] >= 0 and
                   value[-1] < 166700 and np.all(np.diff(value) > 0), f"Frozen APL identity {name} changed")
        _check(not np.intersect1d(bundle["kc_globals"], bundle["apl_globals"]).size, "APL and KC identities overlap")
        kc_positions = np.searchsorted(nodes, bundle["kc_globals"])
        present = kc_positions < n
        present[present] &= nodes[kc_positions[present]] == bundle["kc_globals"][present]
        kc_local, kc_in_bundle = kc_positions[present], np.flatnonzero(present)
        requested_globals, request_local, request_ptr, request_count = _requests(case_dir, nodes, steps)
        initial = None
        if (case_dir / "arrays.npz").exists():
            with np.load(case_dir / "arrays.npz", allow_pickle=False) as archive:
                _check(set(archive.files) == {"initial_v_mv", "initial_g_mv"}, "Unexpected initial-state schema")
                initial = {name: archive[name].copy() for name in archive.files}
            for name, value in initial.items():
                _check(value.dtype == np.dtype("float64") and value.shape == (n,) and np.isfinite(value).all(),
                       f"Invalid diagnostic initial state: {name}")
        history_bytes = steps * n * 40 if record_history else 0
        _budget(budget_root, budget_limit, history_bytes + steps * (2 + 2 + 4064 + 4064) * 4 +
                apl_delay_steps * 4064 * 4 + edges * 8 + (64 << 20))
        versions = {name: importlib.metadata.version(name) for name in
                    ("brian2", "numpy", "pandas", "pyarrow", "sympy", "scipy", "cython")}
        _save(out_dir / "environment.json", {"python": sys.version, "platform": platform.platform(),
              "packages": versions, "codegen": "numpy", "author_precision": "float64",
              "APL_precision": "float32 in separate science-Python process", "Torch_imported_into_Brian": False})
        for name, required in (("brian2", "2.5.1"), ("numpy", "1.22.3"), ("sympy", "1.12")):
            _check(versions[name] == required, f"{name} must remain pinned to {required}")
        import brian2 as b2
        import pandas as pd
        from brian2.core.base import BrianObject

        ae = _load_checked(ae_path, AE_SHA256, "phase4ag_sealed_ae_helpers")
        af = _load_checked(af_path, AF_SHA256, "phase4ag_sealed_af_helpers")
        author = _load_checked(author_path, AUTHOR_SHA256, "phase4ag_unchanged_author")
        _check("torch" not in sys.modules, "Torch must not be imported into the pinned Brian process")
        comp = pd.read_csv(graph_dir / "completeness.csv", index_col=0)
        _check(np.array_equal(comp.index.to_numpy(), nodes) and
               np.array_equal(comp["local_index"].to_numpy(), np.arange(n)), "Author CSV neuron identity differs")
        del comp
        graph_hashes = {name: _digest(graph_dir / name) for name in
            tuple(key + ".npy" for key in arrays) + ("completeness.csv", "connectivity.parquet")}
        bundle_hashes = {name: _digest(bundle_dir / name) for name in BUNDLE_FILES}
        case_hashes = {name: _digest(case_dir / name) for name in ("spec.json", "requests.npz")}
        if initial is not None:
            case_hashes["arrays.npz"] = _digest(case_dir / "arrays.npz")
        worker_hash = _digest(worker_path)
        coefficient_hash = _digest(coefficients_path)
        baseline_coefficients = json.loads(coefficients_path.read_text(encoding="utf-8"))
        if "legacy_apl_worker_sha256" in spec:
            _check(worker_hash == spec["legacy_apl_worker_sha256"], "APL worker differs from preregistered source")
        _save(out_dir / "input-audit.json", {"spec": spec, "case_hashes": case_hashes,
              "graph_hashes": graph_hashes, "bundle_hashes": bundle_hashes,
              "author_sha256": AUTHOR_SHA256, "ae_sha256": AE_SHA256, "af_sha256": AF_SHA256,
              "legacy_apl_worker_sha256": worker_hash, "coefficients_sha256": coefficient_hash,
              "copied_oracle_source": str(BASE_ORACLE_PATH), "copied_oracle_sha256": BASE_ORACLE_SHA256,
              "apl_delay_steps": apl_delay_steps, "only_scientific_change": "transport generated graded-APL h before the unchanged end write",
              "candidate_trace_used_as_input": False,
              "scope": "shared-APL-component closed-loop oracle, not all-components-independent CPU equivalence"})
        saved_preferences = {key: b2.prefs[key] for key in
            ("codegen.target", "core.default_float_dtype", "legacy.refractory_timing")}
        old_dt = b2.defaultclock.dt
        b2.start_scope()
        b2.prefs["codegen.target"] = "numpy"
        b2.prefs["core.default_float_dtype"] = np.float64
        b2.prefs["legacy.refractory_timing"] = False
        b2.defaultclock.dt = .1 * b2.ms
        parameters = dict(author.default_params)
        _save(out_dir / "parameter-checks.json", ae._parameters_match(parameters, spec["model"], b2))
        neu, syn, spikes = author.create_model(graph_dir / "completeness.csv", graph_dir / "connectivity.parquet", parameters)
        _check(len(neu) == n and len(syn) == edges, "Author loaded an unexpected graph size")
        _check(all(np.dtype(neu.variables[key].dtype) == np.float64 for key in ("v", "g")) and
               np.dtype(syn.variables["w"].dtype) == np.float64, "Author states/weights are not float64")
        effective = _new_memmap(out_dir / "weights.npy", "<f8", (edges,))
        mapped_files.append(effective)
        width, w_unit, mask_count = BLOCK_BYTES // 8, float(parameters["w_syn"] / b2.volt), 0
        mask_hasher = hashlib.sha256()
        base_hasher = hashlib.sha256()
        effective_hasher = hashlib.sha256()
        for begin in range(0, edges, width):
            stop = min(edges, begin + width)
            np.testing.assert_array_equal(np.asarray(syn.i[begin:stop]), arrays["src"][begin:stop])
            np.testing.assert_array_equal(np.asarray(syn.j[begin:stop]), arrays["dst"][begin:stop])
            original = np.asarray(syn.w_[begin:stop], dtype=np.float64).copy()
            raw_expected = arrays["signed_raw"][begin:stop] * w_unit
            _check(np.array_equal(original.view(np.uint64), raw_expected.view(np.uint64)) and
                   np.array_equal(original.view(np.uint64), arrays["weights"][begin:stop].view(np.uint64)),
                   "Actual original Brian weights differ from unchanged signed raw or AF base weights")
            base_hasher.update(np.ascontiguousarray(original, dtype="<f8").tobytes())
            mask = np.isin(nodes[arrays["src"][begin:stop]], bundle["apl_globals"])
            mask_count += int(mask.sum())
            mask_hasher.update(np.ascontiguousarray(arrays["edge_id"][begin:stop][mask], dtype="<i8").tobytes())
            original[mask] = np.float64(0.0)
            effective_hasher.update(np.ascontiguousarray(original, dtype="<f8").tobytes())
            effective[begin:stop] = original
            syn.w_[begin:stop] = original
        if n == 166700:
            _check(mask_count == 5845, "Full legacy APL fast-edge mask must contain exactly 5845 existing edges")
        effective.flush()
        _save(out_dir / "apl-mask-audit.json", {"count": mask_count, "ordered_original_edge_id_sha256": mask_hasher.hexdigest(),
              "base_weight_raw_bytes_sha256": base_hasher.hexdigest(), "effective_weights_file_sha256": _digest(out_dir / "weights.npy"),
              "effective_weights_raw_sha256": effective_hasher.hexdigest(),
              "rule": "zero +0 all existing fast edges whose source GLOBAL neuron is in apl_globals; no graph edge removal",
              "graded_targets": "only KC identities present in this LIF case", "KC_targets_in_case": len(kc_local),
              "base_graph_files_modified": False, "fullgraph_required_mask_count": 5845})
        if initial is not None:
            neu.v = initial["initial_v_mv"] * b2.mV
            neu.g = initial["initial_g_mv"] * b2.mV
        v_raw = neu.variables["v"].get_value()
        g_raw = neu.variables["g"].get_value()
        last_raw = neu.variables["lastspike"].get_value()
        available_raw = neu.variables["not_refractory"].get_value()
        histories = {}
        pre_apl_histories = {}
        if record_history:
            for name, dtype in (("v", "float64"), ("g", "float64"), ("ref", "int32")):
                histories[name] = _new_memmap(out_dir / f"{name}-history.{dtype}.npy", np.dtype(dtype), (steps, n))
                mapped_files.append(histories[name])
                pre_apl_histories[name] = _new_memmap(out_dir / f"preAPL-{name}.{dtype}.npy", np.dtype(dtype), (steps, n))
                mapped_files.append(pre_apl_histories[name])
        apl_history = {}
        for name, count in (("drive", 2), ("state", 2), ("inhibition", 4064)):
            apl_history[name] = _new_memmap(out_dir / f"apl-{name}.float32.npy", "<f4", (steps, count))
            mapped_files.append(apl_history[name])
        applied_history = _new_memmap(out_dir / "apl-applied.float32.npy", "<f4", (steps, 4064))
        mapped_files.append(applied_history)
        apl_fifo = _APLDelayFIFO(apl_delay_steps)
        _save(out_dir / "output-schema.json", {"history_recorded": record_history, "history_shape": [steps, n],
              "state_hash_file": "tick-state-hashes.jsonl", "state_hash_encoding": "SHA256 of contiguous little-endian raw f64 V/g and i32 ref",
              "APL_dtype": "float32", "APL_h_units": "mV; gain already applied in float32",
              "APL_SI_conversion": "h.astype(float64) * float64(0.001), then separate float64 g subtraction",
              "APL_write_schedule": "end, order=0, after original reset, unconditional raw g write; recorder end/order=1",
              "APL_input": "Brian's own actual global spikes, never candidate spikes or candidate inhibition",
              "APL_shapes": {"drive": [steps, 2], "state": [steps, 2], "inhibition": [steps, 4064],
                             "applied": [steps, 4064], "pending_tail": [apl_delay_steps, 4064]},
              "apl_delay_steps": apl_delay_steps,
              "APL_transport": "applied[t]=generated_h[t-D] for t>=D, positive zero otherwise; separate independent list FIFO",
              "APL_inhibition_file_means": "generated h at the actual closed-loop Brian spike tick, not the delayed applied value",
              "APL_pending_file": "apl-pending-tail.float32.npy",
              "APL_pending_scope": "next D scheduled applications from recorded h plus unconsumed initial zero slots; not future generated decay",
              "APL_pending_initial_zero_prefix": max(apl_delay_steps - steps, 0),
              "APL_pending_generated_count": min(steps, apl_delay_steps),
              "request_columns": ["tick", "neuron_idx", "attempted", "accepted", "rejected"],
              "queue_protocol": "sealed Phase4AF queue_summary; original global edge IDs, including zero-weight/ref-rejected arrivals",
              "state_npz": ["step", "neuron_idx", "counts", "v", "g", "ref"],
              "complete_marker": "summary.json complete=true only after worker exit and all checks"})
        delay_steps = int(round(float(parameters["t_dly"] / b2.ms) / .1))
        ref_steps = int(round(float(parameters["t_rfc"] / b2.ms) / .1))
        _check(delay_steps == 18 and ref_steps == 22, "Author delay/refractory changed")
        queue_len = delay_steps + 1
        due_counts = np.zeros(queue_len, np.int64)
        spike_ring = [np.empty(0, np.int32) for _ in range(queue_len)]
        outdegree = np.diff(arrays["ptr"])
        request_seen = np.zeros(steps, np.uint8)
        apl_seen = np.zeros(steps, np.uint8)
        applicable_count = np.zeros(steps, np.int32)
        rejected_count = np.zeros(steps, np.int32)
        spike_count = np.zeros(steps, np.int32)
        total_counts = np.zeros(n, np.int32)
        records = {"rows": [], "peek_calls": 0, "advance_calls": 0, "installations": []}
        last_ticks = np.zeros(n, np.int64)
        final_ref = np.zeros(n, np.int32)
        permitted = np.empty(0, np.int32)
        total_events = 0

        def tick_now():
            return int(round(float(neu.clock.t / b2.second) / .0001))

        def current_ref(tick):
            seen = np.isfinite(last_raw) & (last_raw >= 0)
            last_ticks.fill(0)
            last_ticks[seen] = np.rint(last_raw[seen] / .0001).astype(np.int64)
            result = np.where(seen, np.maximum(ref_steps - (tick - last_ticks), 0), 0).astype(np.int32)
            _check(np.array_equal(result == 0, available_raw), "Ref history disagrees with author not_refractory")
            return result

        with ExitStack() as stack:
            stderr = stack.enter_context((out_dir / "apl-worker.stderr.log").open("xb"))
            worker = _APLWorker(science_python, worker_path, bundle_dir, stderr, float(spec.get("worker_timeout_seconds", 180)))
            _save(out_dir / "apl-worker-handshake.json", {"command": worker.command, "handshake": worker.hello})
            queue_file = stack.enter_context((out_dir / "queue.jsonl").open("x", encoding="utf-8"))
            event_file = stack.enter_context((out_dir / "events.bin").open("xb"))
            hash_file = stack.enter_context((out_dir / "tick-state-hashes.jsonl").open("x", encoding="utf-8"))
            tick_file = stack.enter_context((out_dir / "ticks.jsonl").open("x", encoding="utf-8"))
            requests_file = stack.enter_context((out_dir / "requests.csv").open("x", encoding="utf-8", newline=""))
            request_writer = csv.DictWriter(requests_file, fieldnames=["tick", "neuron_idx", "attempted", "accepted", "rejected"])
            request_writer.writeheader()

            def request_operation():
                nonlocal permitted
                tick = tick_now()
                _check(0 <= tick < steps and not request_seen[tick], "Invalid/duplicate common request tick")
                request_seen[tick] = 1
                begin, stop = request_ptr[tick:tick + 2]
                local = request_local[begin:stop]
                available = available_raw[local].copy()
                permitted = local[available]
                applicable_count[tick] = len(permitted)
                rejected_count[tick] = len(local) - len(permitted)
                for node, accepted in zip(requested_globals[begin:stop], available):
                    request_writer.writerow({"tick": tick, "neuron_idx": int(node), "attempted": 1,
                                             "accepted": int(accepted), "rejected": int(not accepted)})
                if len(permitted):
                    neu.v[permitted] = parameters["v_th"] + 1 * b2.mV

            def apl_operation():
                tick = tick_now()
                _check(0 <= tick < steps and not apl_seen[tick] and request_seen[tick], "Invalid/duplicate APL tick")
                active = np.asarray(neu.spikes, dtype=np.int32)
                _check(not len(active) or np.all(np.diff(active) > 0), "Brian actual spikes are not canonical/unique")
                _check(np.all(g_raw[active] == 0.0), "APL ran before the original author g reset")
                if record_history:
                    pre_apl_histories["v"][tick] = v_raw
                    pre_apl_histories["g"][tick] = g_raw
                    pre_apl_histories["ref"][tick] = current_ref(tick)
                drive, state, inhibition = worker.step(tick, np.asarray(nodes[active], dtype=np.int32))
                apl_history["drive"][tick] = drive
                apl_history["state"][tick] = state
                apl_history["inhibition"][tick] = inhibition
                applied = apl_fifo.step(tick, inhibition)
                applied_history[tick] = applied
                # These are separate array operations.  Only h transport is new.
                # Do not fuse conversion/subtraction or add a refractory guard.
                delta_si = applied[kc_in_bundle].astype(np.float64) * np.float64(.001)
                g_raw[kc_local] = g_raw[kc_local] - delta_si
                apl_seen[tick] = 1

            def record_end():
                nonlocal last_complete_tick, total_events, final_ref
                tick = tick_now()
                _check(tick == last_complete_tick + 1 and tick < steps and apl_seen[tick], "End tick is incomplete/out of order")
                _check(len(records["rows"]) == tick + 1, "End state lacks queue observation")
                _check(np.isfinite(v_raw).all() and np.isfinite(g_raw).all(), "Nonfinite author/APL state")
                final_ref = current_ref(tick)
                if record_history:
                    histories["v"][tick], histories["g"][tick], histories["ref"][tick] = v_raw, g_raw, final_ref
                active = np.asarray(neu.spikes, dtype=np.int32)
                _check(np.isin(permitted, active).all(), "An applicable request did not produce a real spike")
                spike_count[tick] = len(active)
                total_counts[active] += 1
                if len(active):
                    events = np.empty(len(active), EVENT_DTYPE)
                    events["step"], events["neuron_idx"] = tick, nodes[active]
                    event_file.write(memoryview(events).cast("B"))
                total_events += len(active)
                spike_ring[tick % queue_len] = active.copy()
                due_counts[(tick + delay_steps) % queue_len] = int(outdegree[active].sum(dtype=np.int64))
                hash_file.write(json.dumps({"tick": tick, "v_sha256": _array_hash(v_raw, "<f8"),
                    "g_sha256": _array_hash(g_raw, "<f8"), "ref_sha256": _array_hash(final_ref, "<i4")}, sort_keys=True) + "\n")
                tick_file.write(json.dumps({"tick": tick, "spikes": len(active), "requests": int(request_count[tick]),
                    "applicable_requests": int(applicable_count[tick]), "ref_rejected_requests": int(rejected_count[tick]),
                    "event_sha256": _array_hash(nodes[active], "<i4"),
                    "due_arrivals": records["rows"][tick]["count"], "accepted_arrivals": records["rows"][tick]["accepted_count"],
                    "APL_drive_sha256": _array_hash(apl_history["drive"][tick], "<f4"),
                    "APL_state_sha256": _array_hash(apl_history["state"][tick], "<f4"),
                    "APL_inhibition_sha256": _array_hash(apl_history["inhibition"][tick], "<f4"),
                    "APL_applied_sha256": _array_hash(applied_history[tick], "<f4"),
                    "APL_applied_generated_tick": tick - apl_delay_steps if tick >= apl_delay_steps else None}, sort_keys=True) + "\n")
                _budget(budget_root, budget_limit, reserve=1 << 20)
                last_complete_tick = tick
                if (tick + 1) % 100 == 0 or tick + 1 == steps:
                    for mapped in mapped_files:
                        mapped.flush()
                    for handle in (queue_file, event_file, hash_file, tick_file, requests_file):
                        handle.flush()
                    print(json.dumps({"oracle": spec["name"], "completed_ticks": tick + 1,
                                      "spikes": total_events, "APL_worker_ticks": worker.tick}), flush=True)

            class QueueInstaller(BrianObject):
                def __init__(self):
                    super().__init__(clock=neu.clock, when="end", order=1_000_000, name="zz_apl_queue_installer")

                def before_run(self, run_namespace):
                    installed = []
                    for code in syn.pre.code_objects:
                        if "_queue" not in code.namespace or "_queue.peek()" not in str(code.code):
                            continue
                        original = code.namespace["_queue"]
                        if isinstance(original, _QueueProxy):
                            original = original._original_queue
                        code.namespace["_queue"] = _QueueProxy(original, tick_now, available_raw, arrays, identity_edges,
                            due_counts, spike_ring, delay_steps, queue_file, records, af.queue_summary)
                        installed.append(code.name)
                    _check(len(installed) == 1, "Expected one original anatomical queue consumer")
                    records["installations"].append(installed[0])

            objects = [neu, syn, spikes,
                b2.NetworkOperation(request_operation, clock=neu.clock, when="before_thresholds", order=0, name="oracle_common_requests"),
                b2.NetworkOperation(apl_operation, clock=neu.clock, when="end", order=0, name="oracle_legacy_apl_unconditional"),
                b2.NetworkOperation(record_end, clock=neu.clock, when="end", order=1, name="oracle_after_apl_record"), QueueInstaller()]
            network = b2.Network(*objects)
            _save(out_dir / "schedule.json", {"schedule": list(network.schedule), "summary": str(network.scheduling_summary())})
            network.run(0 * b2.ms, namespace={})
            _save(out_dir / "compiled-code.json", ae._code_records(network))
            compiled_coefficients = ae._coefficients(neu, parameters, b2, .0001)
            coefficient_keys = ("gd", "c0", "cg", "cv", "threshold", "reset", "seed_volt")
            _check(all(float(compiled_coefficients[key]).hex() == float(baseline_coefficients[key]).hex()
                       for key in coefficient_keys), "Compiled Brian coefficients differ from sealed AF")
            _check(last_complete_tick == -1 and worker.tick == 0 and not records["rows"] and not request_seen.any(),
                   "Zero-duration compilation unexpectedly advanced state")
            network.run(steps * .1 * b2.ms, namespace={})
            _save(out_dir / "generated-code.json", ae._code_records(network))
            worker_status = worker.finish(steps)
            worker = None

        _check(last_complete_tick == steps - 1 and np.all(request_seen == 1) and np.all(apl_seen == 1), "Incomplete trial")
        pending_tail = apl_fifo.finish(steps)
        warmup = min(steps, apl_delay_steps)
        consumed = max(steps - apl_delay_steps, 0)
        initial_zero_prefix = max(apl_delay_steps - steps, 0)
        _check(np.all(applied_history[:warmup].view(np.uint32) == 0),
               "Delayed APL warmup must contain positive zeros")
        _check(np.array_equal(applied_history[warmup:].view(np.uint32),
                              apl_history["inhibition"][:consumed].view(np.uint32)),
               "Applied h is not the exact delayed generated float32 sequence")
        _check(pending_tail.shape == (apl_delay_steps, 4064) and pending_tail.dtype == np.float32,
               "Pending APL tail shape/dtype changed")
        _check(np.all(pending_tail[:initial_zero_prefix].view(np.uint32) == 0),
               "Short-window pending prefix must contain unconsumed initial positive zeros")
        _check(np.array_equal(pending_tail[initial_zero_prefix:].view(np.uint32),
                              apl_history["inhibition"][consumed:].view(np.uint32)),
               "Pending tail does not exactly partition the finite generated h sequence")
        with (out_dir / "apl-pending-tail.float32.npy").open("xb") as handle:
            np.save(handle, pending_tail, allow_pickle=False)
        _save(out_dir / "apl-timing-audit.json", {
            "apl_delay_steps": apl_delay_steps, "steps": steps,
            "generated_rows": steps, "applied_generated_rows": consumed,
            "pending_generated_count": min(steps, apl_delay_steps),
            "initial_zero_prefix": initial_zero_prefix,
            "pending_initial_zero_prefix": initial_zero_prefix,
            "pending_shape": [apl_delay_steps, 4064],
            "pending_application_tick_start": steps,
            "pending_application_tick_stop_exclusive": steps + apl_delay_steps,
            "pending_generated_tick_start": consumed,
            "pending_generated_tick_stop_exclusive": steps,
            "positive_zero_warmup_exact": True, "transport_shift_exact": True,
            "finite_generated_sequence_partition_exact": True,
            "pending_raw_sha256": _array_hash(pending_tail, "<f4"),
            "pending_file_sha256": _digest(out_dir / "apl-pending-tail.float32.npy"),
            "brain_steps_after_window": 0, "APL_generation_steps_after_window": 0,
            "brain_tail_advanced": False,
            "final_apl_state_float32": np.asarray(apl_history["state"][-1], dtype=np.float32).tolist(),
            "final_apl_state_u32_bits": np.asarray(apl_history["state"][-1], dtype=np.float32).view(np.uint32).tolist(),
            "final_apl_state_nonzero": bool(np.any(apl_history["state"][-1] != 0)),
            "future_generated_decay_tail_included": False,
            "future_apl_decay_or_feedback_generated": False,
            "closed_loop_branch_integrals_claimed_equal": False,
            "delay_implementation": "independent list FIFO; no candidate or timing_queue imports",
            "meaning": "Tail contains only already generated h and any remaining initial-zero padding; never a complete future closed-loop or decay tail",
        })
        _check(records["peek_calls"] == records["advance_calls"] == steps, "Incomplete queue audit")
        _check(total_events == int(spikes.num_spikes) and np.array_equal(total_counts, np.asarray(spikes.count[:])),
               "Sparse events disagree with original SpikeMonitor")
        _check(np.array_equal(request_count, applicable_count + rejected_count), "Incomplete request accounting")
        _check(np.all(np.asarray(neu.rfc[:] / b2.ms) == float(parameters["t_rfc"] / b2.ms)), "Author refractory duration changed")
        for begin in range(0, edges, width):
            stop = min(edges, begin + width)
            _check(np.array_equal(np.asarray(syn.w_[begin:stop]).view(np.uint64), effective[begin:stop].view(np.uint64)),
                   "Effective synaptic weights changed during the trial")
        event_values = np.memmap(out_dir / "events.bin", dtype=EVENT_DTYPE, mode="r", shape=(total_events,)) if total_events else np.empty(0, EVENT_DTYPE)
        _check((out_dir / "events.bin").stat().st_size == total_events * 8, "Sparse event byte count mismatch")
        for begin in range(0, total_events, width):
            stop = min(total_events, begin + width)
            spike_local = np.asarray(spikes.i[begin:stop], dtype=np.int32)
            np.testing.assert_array_equal(event_values["neuron_idx"][begin:stop], nodes[spike_local])
            times = np.rint(np.asarray(spikes.t[begin:stop] / b2.second) / .0001).astype(np.int32)
            np.testing.assert_array_equal(event_values["step"][begin:stop], times)
        _budget(budget_root, budget_limit, total_events * 8 + n * 24 + (8 << 20))
        with (out_dir / "state.npz").open("xb") as handle:
            np.savez_compressed(handle, step=event_values["step"], neuron_idx=event_values["neuron_idx"],
                                counts=total_counts, v=v_raw, g=g_raw, ref=final_ref)
        with (out_dir / "tick-summary.npz").open("xb") as handle:
            np.savez_compressed(handle, request_count=request_count, applicable_count=applicable_count,
                rejected_count=rejected_count, spike_count=spike_count,
                arrival_count=np.asarray([row["count"] for row in records["rows"]], np.int64),
                accepted_arrival_count=np.asarray([row["accepted_count"] for row in records["rows"]], np.int64))
        coefficients = ae._coefficients(neu, parameters, b2, .0001)
        keys = ("gd", "c0", "cg", "cv", "threshold", "reset", "seed_volt")
        _check(all(float(coefficients[key]).hex() == float(baseline_coefficients[key]).hex() for key in keys),
               "Actual Brian coefficients differ from sealed AF coefficients")
        _save(out_dir / "coefficients.json", coefficients)
        _save(out_dir / "queue-audit.json", {"peek_calls": records["peek_calls"], "advance_calls": records["advance_calls"],
              "installations": records["installations"], "same_peek_object_returned": True,
              "original_edge_ids_not_sorted_or_filtered": True, "zero_weight_and_refractory_rejected_edges_retained": True,
              "post_threshold_pre_synaptic_guard_observed": True, "forwarding_contract": "sealed AE/AF design",
              "new_unwrapped_repeat_performed": False, "limit": "Current wrapper was not independently rerun without the queue proxy"})
        for path, expected in ((author_path, AUTHOR_SHA256), (ae_path, AE_SHA256), (af_path, AF_SHA256),
                               (worker_path, worker_hash), (BASE_ORACLE_PATH, BASE_ORACLE_SHA256)):
            _check(_digest(path) == expected, f"Source changed during the run: {path}")
        _check(_digest(coefficients_path) == coefficient_hash, "Sealed coefficient reference changed during the run")
        for directory, hashes in ((graph_dir, graph_hashes), (bundle_dir, bundle_hashes), (case_dir, case_hashes)):
            for name, expected in hashes.items():
                _check(_digest(directory / name) == expected, f"Read-only input changed during the run: {name}")
        for mapped in mapped_files:
            mapped.flush()
        _check("torch" not in sys.modules, "Pinned Brian process unexpectedly imported Torch")
        output_bytes = _budget(budget_root, budget_limit, 1 << 20)
        summary = {"name": spec["name"], "complete": True, "precision": "float64", "APL_precision": "float32",
            "backend": "shared-APL-component closed-loop Brian2 oracle", "steps": steps, "completed_ticks": last_complete_tick + 1,
            "nodes": n, "edges": edges, "spikes": total_events, "requests": int(request_count.sum()),
            "applicable_requests": int(applicable_count.sum()), "ref_rejected_requests": int(rejected_count.sum()),
            "APL_fast_edges_zeroed": mask_count, "APL_worker_exit_status": worker_status, "APL_worker_ticks": steps,
            "apl_fast_edges_zeroed": mask_count, "effective_weights_raw_sha256": effective_hasher.hexdigest(),
            "kc_targets_present": len(kc_local), "apl_delay_steps": apl_delay_steps,
            "APL_transport_shift_exact": True, "APL_finite_sequence_partition_exact": True,
            "pending_generated_count": min(steps, apl_delay_steps),
            "initial_zero_prefix": max(apl_delay_steps - steps, 0),
            "pending_initial_zero_prefix": max(apl_delay_steps - steps, 0),
            "pending_tail_shape": [apl_delay_steps, 4064], "future_generated_decay_tail_included": False,
            "APL_applied_sha256": _digest(out_dir / "apl-applied.float32.npy"),
            "APL_pending_tail_sha256": _digest(out_dir / "apl-pending-tail.float32.npy"),
            "APL_timing_audit_sha256": _digest(out_dir / "apl-timing-audit.json"),
            "candidate_trace_used_as_input": False, "independent_CPU_all_components_claim": False,
            "history_recorded": record_history, "single_continuous_run": True, "no_training": True, "no_poi": True,
            "source_and_inputs_unchanged": True, "pass_all": True,
            "pass_all_scope": "Oracle construction, protocol and internal self-checks only; candidate comparison is a separate gate",
            "scope": "Only this fixed trajectory; legacy Torch APL is a shared numerical component, not an independent CPU APL implementation",
            "output_budget_bytes": budget_limit, "output_bytes_before_summary": output_bytes,
            "state_hashes_sha256": _digest(out_dir / "tick-state-hashes.jsonl"), "queue_sha256": _digest(out_dir / "queue.jsonl"),
            "events_sha256": _digest(out_dir / "events.bin"), "weights_sha256": _digest(out_dir / "weights.npy")}
        _save(out_dir / "summary.json", summary)
        return summary
    except Exception as error:
        for mapped in mapped_files:
            mapped.flush()
        _save(out_dir / "error.json", {"complete": False, "last_complete_tick": last_complete_tick,
              "type": type(error).__name__, "message": str(error), "partial_files_preserved": True,
              "inputs_or_duration_adjusted": False})
        raise
    finally:
        if worker is not None:
            worker.abort()
        if saved_preferences is not None:
            for key, value in saved_preferences.items():
                b2.prefs[key] = value
            b2.defaultclock.dt = old_dt


def run_oracle(case_dir: Path, out_dir: Path) -> dict:
    """Public timing-adapter alias; preserves the sealed run_case call shape."""
    return run_case(case_dir, out_dir)


def main():
    import argparse
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("case_dir", type=Path)
    parser.add_argument("out_dir", type=Path)
    args = parser.parse_args()
    result = run_oracle(args.case_dir, args.out_dir)
    print(json.dumps(result, sort_keys=True, allow_nan=False), flush=True)
    if not result.get("complete") or not result.get("pass_all"):
        raise SystemExit(1)


if __name__ == "__main__":
    main()