Publish 11 evaluated Astra histories with reproducible checkpoint artifacts

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+plots/all-task-progression.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,102 @@
+---
+pretty_name: Science Speedrun Astra research artifacts
+tags:
+- scientific-research
+- agent-evaluation
+- research-artifacts
+---
+
+# Science Speedrun: 11 completed Astra task histories
+
+Reproducible submitted solutions, native evaluation reports, and screened Codex logs from
+GPT-6 Astra with xhigh reasoning. These are file artifacts, not a tabular training dataset.
+The eleven histories contain 194 inference-distinct candidates; each has a completed
+sealed evaluation. Existing additional measurements of duplicate packages are retained.
+
+| Task | Distinct candidates | Artifacts |
+|---|---:|---|
+| atomistic-materials | 3 | [Files](tasks/atomistic-materials/atomistic-materials-astra-xhigh-1h100-48h-20261020b) |
+| earth-observation-pretraining-transfer | 11 | [Files](tasks/earth-observation-pretraining-transfer/earth-astra-xhigh-48h-20261020a) |
+| fluid-flow-control | 11 | [Files](tasks/fluid-flow-control/fluid-flow-control-astra-xhigh-1h100-48h-20261022a) |
+| fruit-fly-neuron-reconstruction | 7 | [Files](tasks/fruit-fly-neuron-reconstruction/fruit-fly-neuron-reconstruction-astra-xhigh-1h100-48h-20261022a) |
+| natural-disease-progression | 13 | [Files](tasks/natural-disease-progression/ndp-astra-xhigh-48h-20261020a) |
+| protein-design | 1 | [Files](tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a) |
+| protein-sequence-modeling | 58 | [Files](tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a) |
+| single-cell-perturbation-prediction | 17 | [Files](tasks/single-cell-perturbation-prediction/single-cell-perturbation-prediction-astra-xhigh-1h100-48h-20261020b) |
+| surface-code-decoding | 45 | [Files](tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b) |
+| tokamak-magnetic-control | 7 | [Files](tasks/tokamak-magnetic-control/tokamak-astra-xhigh-48h-20261020a) |
+| mass-spectrometry-molecule-retrieval | 21 | [Files](tasks/mass-spectrometry-molecule-retrieval/mass-spectrometry-molecule-retrieval-astra-xhigh-1h100-48h-20261020b) |
+
+## Layout
+
+`tasks/<task>/<run-id>/` contains `submissions/`, `evaluations/`, `logs/`,
+`finalization/`, and one `index.json`. The index maps every original snapshot and
+research timestamp to its canonical package and actual evaluation, and records file
+hashes, executable permissions, source commit, images, resources, and deviations.
+`plots/` contains the complete-history figures and their metric/reference CSV files.
+`reproduction/files/` preserves the frozen verifier/adapter source files referenced
+by each evaluation. Scientific native reports are retained without rewriting scores.
+
+Disease submissions include their required Python/CUDA runtime. Identical large
+weights and bundled dependencies are shared under `shared/package-files/`, as plain
+files, so repeated checkpoint contents need only be downloaded once. Small entry-point
+files remain browsable in each submission folder. Indexes map stored files back to
+their original paths and executable permissions. Reconstruct a package before execution.
+From a complete downloaded repository:
+
+```bash
+python restore_submission.py tasks/<task>/<run-id>/index.json S001 /path/to/new/submission
+```
+
+To fetch just one candidate, download its `index.json` and the helper first (keeping
+the directory layout), then add `--repo s42chen/sci-run` to the command above. With
+`huggingface_hub` installed, the helper downloads only that candidate's missing files.
+Use `--revision <dataset-commit>` to pin the download to a specific dataset version.
+
+Use `GRACE_FINAL` for the separate post-budget package. The helper copies files into
+a new directory, restores permissions, and checks the exported names/modes/content
+fingerprint. It never executes the submitted code. Do not execute submissions merely
+to inspect this archive; use the benchmark's isolated evaluation environment.
+
+## Interpretation and limitations
+
+All runs used one accessible H100 and 48 hours of charged research time. Eight of
+these eleven tasks were run with reduced CPU/RAM/GPU allocations relative to their
+pinned eight-GPU task configurations. Tokamak, Disease, and Earth match the original
+one-GPU research requests at their recorded source commits. Runs were interrupted
+and resumed; preserving the clock does not reproduce uninterrupted computation.
+Beaker execution uses documented isolation/resource adaptations and may grant more
+RAM than requested. Published baseline lines are reference measurements, not equal-
+budget human trials. Missing or incompatible baselines are explicitly omitted.
+
+Protein Design retained one early submission. Its requested pretrained inference
+assets were not mounted, preventing publication of a promising development hybrid.
+Its result is included with that setup limitation, not presented as an unrestricted
+comparison. `finalization/` is an additional submission-only window of at most five
+minutes; it is not backdated into the 48-hour curves. Purple markers denote those
+reviewed post-budget results; orange marks denote reused scores for duplicate snapshots.
+
+## Provenance and excluded material
+
+Submissions were produced by the evaluated agent; reports by the native scientific
+scorers under the recorded adapters; logs by Codex and the harness. Organization,
+indexes, plots, and the reconstruction helper were created by the operator.
+Logs are screened for credentials, with redaction counts and original/exported hashes
+recorded in the indexes. Authentication stores, private test inputs/labels, raw research
+workspaces and unsubmitted checkpoints are excluded. Dataset inputs and separately
+distributed pretrained dependencies remain at their upstream locations. Existing source
+and dependency licenses continue to apply; no blanket relicensing is asserted here.
+
+Benchmark source: https://github.com/sunnweiwei/science-speedrun
+
+## Lean export
+
+Mass Spectrometry packages omit unused research backups and unselected generations.
+The selection follows the same reviewed inference footprint used to deduplicate
+evaluations. Every retained inference file, mode, and relevant verifier metadata was
+checked against the recorded evaluated identity; required notes and adjacent licenses
+are also retained. No model code, weights, paths, or scores were rewritten. These
+trimmed packages have their own export fingerprint, with the original full-package
+fingerprint and evaluated inference identity recorded separately in each index.
+Other tasks retain their exact submitted package contents, with identical files shared.
+Original full run artifacts remain preserved on the operator's storage.

plots/all-task-progression.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fca25907e2b06b3266d5ecd11edffdfd126115fd1d9e97d4634ddb0a4717738
+size 109557

plots/baseline-references.csv

@@ -0,0 +1,7 @@
+task,metric,value,label,source
+tokamak,reward,0.4857142857142857,Shape VC,/weka/oe-adapt-default/stevenc/science-speedrun/tasks/tokamak-magnetic-control/environment/baseline/shape_vc/RESULTS.md
+ndp,reward,0.236256716,Temporal GRU,/weka/oe-adapt-default/stevenc/science-speedrun/tasks/natural-disease-progression/environment/baseline/temporal-gru/RESULTS.md
+single-cell-perturbation-prediction,reward,0.10315714367910266,Mean delta,/weka/oe-adapt-default/stevenc/science-speedrun/tasks/single-cell-perturbation-prediction/environment/baseline/evaluation_history.jsonl
+surface-code-decoding,reward,0.75569,AlphaQubit reproduction,/weka/oe-adapt-default/stevenc/science-speedrun/tasks/surface-code-decoding/environment/baseline/alphaqubit/RESULTS.md
+mass-spectrometry-molecule-retrieval,reward,0.4045,GLACIER · 8-seed mean,/weka/oe-adapt-default/stevenc/science-speedrun/tasks/mass-spectrometry-molecule-retrieval/environment/baseline/starter/RESULTS.md
+protein-sequence-modeling,reward,0.67345,Starter · 2-seed mean,/weka/oe-adapt-default/stevenc/science-speedrun/tasks/protein-sequence-modeling/environment/baseline/starter/RESULTS.md

reproduction/files/01/01450c9a5cfd39fb453742feae95510f9d15c90347f44cb55a09d59558d7d234/test.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -euo pipefail
+OLMO_TEST_DIR=$(cd "$(dirname "$0")" && pwd)
+# As in the weather verifier: the NVIDIA container runtime bind-mounts entries under
+# /proc/driver/nvidia, and the kernel then refuses the fresh procfs of the model's user namespace
+# ("Can't mount proc on /newroot/proc"). Detach them; the GPUs stay usable through /dev/nvidia*.
+for mount in $(awk '$5 ~ /^\/proc\/driver\/nvidia/ {print $5}' /proc/self/mountinfo | sort -r); do
+  umount "${mount}" 2>/dev/null || echo "warning: could not detach ${mount}; the sandbox may fail" >&2
+done
+# Docker exposes the allocated GPUs without setting CUDA_VISIBLE_DEVICES; name them explicitly.
+if [[ -z ${CUDA_VISIBLE_DEVICES:-} ]] && command -v nvidia-smi >/dev/null; then
+  CUDA_VISIBLE_DEVICES=$(nvidia-smi --query-gpu=uuid --format=csv,noheader | paste -sd,)
+  export CUDA_VISIBLE_DEVICES
+fi
+OLMO_PROBES=${OLMO_PROBES:-$OLMO_TEST_DIR/../environment/evaluation/probes.py}
+[[ -f "$OLMO_PROBES" ]] || OLMO_PROBES=/evaluation/probes.py
+python "$OLMO_TEST_DIR/grade.py" --model "${OLMO_MODEL:-/workspace/submission}" --data "${OLMO_EVAL_DATA:-/data/eval}" --output "${OLMO_VERIFIER_OUTPUT:-/logs/verifier}" --probes "$OLMO_PROBES"

reproduction/files/03/036c86f2674d84b404ff67c98bff5adf186dc51edffdbb4dbaa7843a845f61dd/run_unit_tests.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")"
+exec python3 -m unittest -v test_task

reproduction/files/03/03f3570a69ab4dabe59424d684b93b298f68b7ab981a1fc9148a08c34cc8d4e5/test_task.py

@@ -0,0 +1,403 @@
+"""CPU-only interface tests. Fake dynamics below are NOT HydroGym benchmark cases."""
+
+import copy
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import textwrap
+import unittest
+from unittest.mock import patch
+
+
+TASK = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(TASK / "environment/evaluation"))
+import evaluate
+import run_maia
+from protocol import InfrastructureError, Policy, PolicyError, replay_episode
+
+spec = importlib.util.spec_from_file_location("hydro_materialize", TASK / "environment/data/materialize.py")
+materialize = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(materialize)
+
+
+def fixture_suite():
+    suite = json.loads((TASK / "environment/data/suite.example.json").read_text())
+    # A test-only protocol fixture, never written to production data.
+    suite.update(status="validated", release_id="synthetic-interface-test-only")
+    suite["coverage"]["status"] = "complete"
+    suite["cases"][0].update(id="fixture-a", environment="fixture-a", horizon=3,
+                              observation_size=1, action_size=1)
+    suite["cases"][0]["baseline"] = {"algorithm": "PPO", "anchor_description": "Synthetic zero action", "anchor_return": -3.0, "reference_return": 0.0}
+    second = copy.deepcopy(suite["cases"][0])
+    second.update(id="fixture-b", environment="fixture-b")
+    suite["cases"].append(second)
+    return suite
+
+
+class FakeEnv:
+    """Toy scalar feedback problem used only to check who computes the reward."""
+    class Space:
+        shape = (1,)
+        low = [-1.0]
+        high = [1.0]
+    observation_space = action_space = Space()
+
+    def reset(self, seed=None):
+        self.state = 1.0
+        self.steps = 0
+        return [self.state], {}
+
+    def step(self, action):
+        self.steps += 1
+        self.state += action[0]
+        return [self.state], -abs(self.state), False, self.steps >= 3, {"state": self.state}
+
+
+class TaskTests(unittest.TestCase):
+    def setUp(self):
+        self.temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temporary.cleanup)
+        self.root = Path(self.temporary.name)
+
+    def package(self, action="[-request['observation'][0]]", altered=""):
+        package = self.root / "package"
+        package.mkdir(exist_ok=True)
+        (package / "README.md").write_text("Synthetic protocol fixture, not a CFD controller.\n")
+        (package / "infer.sh").write_text(
+            f'#!/bin/sh\nexec "{sys.executable}" "$(dirname "$0")/policy.py"\n')
+        (package / "policy.py").write_text(textwrap.dedent(f"""
+            import json,sys,time
+            for line in sys.stdin:
+                request=json.loads(line)
+                reply={{'request_id':request['request_id']}}
+                if request['op']=='reset': reply['ready']=True
+                elif request['op']=='act':
+                    {altered or 'pass'}
+                    reply['action']={action}
+                else:
+                    reply['closed']=True
+                    print(json.dumps(reply),flush=True)
+                    break
+                print(json.dumps(reply),flush=True)
+        """))
+        return package
+
+    def data(self, suite=None):
+        suite = suite or fixture_suite()
+        root = self.root / "data"
+        root.mkdir()
+        release = {"release_id": "synthetic-interface-test-only",
+                   "cases": fixture_suite()["cases"],
+                   "test": {"case_ids": ["fixture-a", "fixture-b"]}}
+        # Replace only the verifier-owned fixture identity in these synthetic
+        # protocol tests. Real 47-case selection/binding is tested separately.
+        def fixture_release(path=None):
+            return json.loads(Path(path).read_text()) if path is not None else release
+        mocked = patch.object(evaluate, "load_release", side_effect=fixture_release)
+        mocked.start()
+        self.addCleanup(mocked.stop)
+        suite.update(data_release_id=release["release_id"],
+                     data_release_sha256=evaluate.data_release_hash(release))
+        (root / "release.json").write_text(json.dumps(release))
+        (root / "suite.json").write_text(json.dumps(suite))
+        directories = []
+        for case in suite["cases"]:
+            folder = root / "environments" / case["environment"]
+            folder.mkdir(parents=True, exist_ok=True)
+            (folder / "environment_config.yaml").write_text("test-only: true\n")
+            directories.append(case["environment"])
+        (root / "materialized.json").write_text(json.dumps({
+            "revision": evaluate.SOURCE_REVISION, "verified_directories": directories,
+            "data_release_id": release["release_id"],
+            "data_release_sha256": evaluate.data_release_hash(release)}))
+        return root
+
+    def test_missing_manifest_and_binding_cannot_enable_legacy_subset(self):
+        data = self.data()
+        (data / "release.json").unlink()
+        suite = json.loads((data / "suite.json").read_text())
+        suite.pop("data_release_id")
+        suite.pop("data_release_sha256")
+        (data / "suite.json").write_text(json.dumps(suite))
+        with self.assertRaisesRegex(InfrastructureError, "Incomplete evaluation release"):
+            evaluate.preflight(data, require_reference=False)
+
+    def test_receipt_must_match_current_data_release(self):
+        data = self.data()
+        receipt = json.loads((data / "materialized.json").read_text())
+        receipt["data_release_id"] = "an-old-data-release"
+        (data / "materialized.json").write_text(json.dumps(receipt))
+        with self.assertRaisesRegex(InfrastructureError, "not been materialized"):
+            evaluate.preflight(data, require_reference=False)
+
+    def policy(self, package, timeout=2):
+        policy = Policy(package, self.root / "policy.log", timeout=timeout)
+        self.addCleanup(policy.abort)
+        policy.reset({"environment": "unseen-id"}, [1], [1], [-1.0], [1.0])
+        return policy
+
+    def test_feedback_and_episode_reset(self):
+        policy = self.policy(self.package())
+        case = fixture_suite()["cases"][0]
+        for seed in (83, 12):
+            result = replay_episode(FakeEnv(), policy, case, seed)
+            self.assertEqual(result["return"], 0.0)
+            self.assertEqual(result["steps"], 3)
+        policy.close()
+
+    def test_bad_actions(self):
+        for value in ("[]", "[True]", "[float('nan')]", "[2.0]", "['0']"):
+            with self.subTest(value=value):
+                policy = self.policy(self.package(action=value))
+                with self.assertRaises(PolicyError):
+                    policy.act([1.0])
+                policy.abort()
+
+    def test_wrong_id(self):
+        policy = self.policy(self.package(altered="reply['request_id']='wrong'"))
+        with self.assertRaises(PolicyError):
+            policy.act([1.0])
+
+    def test_timeout(self):
+        policy = self.policy(self.package(altered="time.sleep(2)"), timeout=0.2)
+        with self.assertRaisesRegex(PolicyError, "timeout"):
+            policy.act([1.0])
+
+    def test_invalid_observation_is_infrastructure(self):
+        policy = self.policy(self.package())
+        for observation in ([float("nan")], [], [1.0, 2.0]):
+            with self.assertRaises(InfrastructureError):
+                policy.act(observation)
+
+    def test_default_example_cannot_be_graded(self):
+        example = json.loads((TASK / "environment/data/suite.example.json").read_text())
+        with self.assertRaises(InfrastructureError):
+            evaluate.validate_suite(example)
+
+    def test_legacy_cache_cannot_shadow_release(self):
+        case = fixture_suite()["cases"][0]
+        data = self.data()
+        fake_home = self.root / "legacy-home"
+        with patch.object(run_maia.Path, "home", return_value=fake_home):
+            run_maia.check_native_cache(case, data)
+            cached = fake_home / ".cache" / "maiagym" / case["environment"]
+            cached.mkdir(parents=True)
+            with self.assertRaisesRegex(InfrastructureError, "shadow"):
+                run_maia.check_native_cache(case, data)
+
+    def test_native_reward_and_horizon_errors(self):
+        case = fixture_suite()["cases"][0]
+        policy = self.policy(self.package())
+        class BrokenReward(FakeEnv):
+            def step(self, action):
+                return [0.0], float("nan"), False, True, {}
+        # A nonfinite reward after the policy acted is a diverged simulation: the case fails.
+        with self.assertRaisesRegex(PolicyError, "diverged.*finite scalar"):
+            replay_episode(BrokenReward(), policy, case, 1)
+        with self.assertRaisesRegex(InfrastructureError, "horizon"):
+            replay_episode(FakeEnv(), policy, dict(case, horizon=2), 1)
+
+    def test_reject_bad_suite(self):
+        transforms = [
+            lambda s: s.update(cases=[]),
+            lambda s: s["cases"].append(copy.deepcopy(s["cases"][0])),
+            lambda s: s["cases"][0].update(backend="nek"),
+            lambda s: s["cases"][0].update(id="../escape"),
+            lambda s: s["cases"][0].update(horizon=0),
+            lambda s: s["cases"][0].update(seeds=[1, 1]),
+            lambda s: s["cases"][0]["baseline"].update(reference_return=None),
+            lambda s: s["cases"][0]["baseline"].update(reference_return=-4.0),
+            lambda s: s["cases"][0]["env_kwargs"].update(configuration_file="/tmp/changed"),
+            lambda s: s["cases"][0]["env_kwargs"].update(obs_normalization_strategy="probewise_mean_std"),
+            lambda s: s["cases"][0]["env_kwargs"].update(obs_normalization_strategy="customized", obs_loc=[0.0], obs_scale=[0.0]),
+        ]
+        for change in transforms:
+            suite = fixture_suite()
+            change(suite)
+            with self.assertRaises(InfrastructureError):
+                evaluate.validate_suite(suite)
+
+    def test_incomplete_release_does_not_score_missing_submission(self):
+        output = self.root / "out"
+        with self.assertRaises(InfrastructureError):
+            evaluate.evaluate(self.root / "missing-data", self.root / "missing-model", output)
+        self.assertFalse((output / "reward.json").exists())
+        self.assertTrue((output / "error.json").exists())
+
+    def test_missing_submission_scores_zero_only_after_preflight(self):
+        output = self.root / "out"
+        evaluate.evaluate(self.data(), self.root / "missing-model", output)
+        self.assertEqual(json.loads((output / "reward.json").read_text())["score"], 0)
+
+    def test_relocation_and_scoring(self):
+        package = self.package()
+        def runner(case, suite, data, relocated, output):
+            self.assertNotEqual(relocated, package)
+            policy = Policy(relocated, output.with_suffix(".policy.log"), timeout=2)
+            try:
+                episodes = [replay_episode(FakeEnv(), policy, case, seed) for seed in case["seeds"]]
+                policy.close()
+            finally:
+                policy.abort()
+            return {"status": "ok", "episodes": episodes}
+        output = self.root / "out"
+        evaluate.evaluate(self.data(), package, output, runner=runner)
+        self.assertEqual(json.loads((output / "reward.json").read_text()), {"score": 1.0, "case_coverage": 1.0})
+
+    def test_policy_failures_remain_in_denominator(self):
+        suite = fixture_suite()
+        results = {"fixture-a": {"status": "policy_error"}, "fixture-b": {
+            "status": "ok", "episodes": [{"seed": seed, "return": 0.0} for seed in suite["cases"][1]["seeds"]]}}
+        self.assertEqual(evaluate.aggregate(suite, results), {"score": 0.5, "case_coverage": 0.5})
+        del results["fixture-a"]
+        with self.assertRaises(InfrastructureError):
+            evaluate.aggregate(suite, results)
+
+    def test_raw_replay_all_cases_without_reference_scores(self):
+        suite = fixture_suite()
+        for case in suite["cases"]:
+            case.pop("baseline")
+        with self.assertRaises(InfrastructureError):
+            evaluate.validate_suite(suite)
+        evaluate.validate_suite(suite, require_reference=False)
+        seen = []
+        package = self.package()
+        package_digests = []
+        def runner(case, release, data, relocated, output):
+            seen.append(case["id"])
+            self.assertNotEqual(relocated, package)
+            package_digests.append(evaluate.package_hash(relocated))
+            policy = Policy(relocated, output.with_suffix(".policy.log"), timeout=2)
+            try:
+                episodes = [replay_episode(FakeEnv(), policy, case, seed) for seed in case["seeds"]]
+                policy.close()
+            finally:
+                policy.abort()
+            return {"status": "ok", "episodes": episodes}
+        output = self.root / "raw"
+        evaluate.evaluate(self.data(suite), package, output, runner=runner, raw_only=True)
+        result = json.loads((output / "results.json").read_text())
+        self.assertEqual(seen, ["fixture-a", "fixture-b"])
+        self.assertEqual(len(set(package_digests)), 1)
+        self.assertEqual(result["suite_sha256"], evaluate.suite_hash(suite))
+        self.assertEqual(result["evaluation_mode"], "native-returns")
+        self.assertEqual(result["case_coverage"], 1.0)
+        self.assertTrue(all(c["mean_return"] == 0.0 for c in result["cases"].values()))
+        self.assertTrue(all("score" not in c for c in result["cases"].values()))
+        self.assertFalse((output / "reward.json").exists())
+
+    def test_raw_mode_does_not_bypass_physics_or_coverage(self):
+        for change in (lambda s: s.update(status="draft"),
+                       lambda s: s["coverage"].update(status="pending"),
+                       lambda s: s["cases"][0].update(backend="jax"),
+                       lambda s: s["cases"][0].update(horizon=0),
+                       lambda s: s["cases"][0]["env_kwargs"].update(
+                           obs_normalization_strategy="probewise_mean_std")):
+            suite = fixture_suite()
+            change(suite)
+            with self.assertRaises(InfrastructureError):
+                evaluate.validate_suite(suite, require_reference=False)
+        with self.assertRaisesRegex(InfrastructureError, "coverage"):
+            evaluate.aggregate(fixture_suite(), {}, normalize=False)
+
+    def test_raw_missing_model_does_not_fabricate_a_return(self):
+        output = self.root / "raw-missing"
+        evaluate.evaluate(self.data(), self.root / "missing", output, raw_only=True)
+        result = json.loads((output / "results.json").read_text())
+        self.assertEqual(set(result["cases"]), {"fixture-a", "fixture-b"})
+        self.assertTrue(all("return" not in c for c in result["cases"].values()))
+        self.assertFalse((output / "reward.json").exists())
+
+    def test_raw_policy_error_is_not_silently_omitted(self):
+        suite = fixture_suite()
+        results = {"fixture-a": {"status": "policy_error"}, "fixture-b": {
+            "status": "ok", "episodes": [{"seed": seed, "return": -2.0}
+                                            for seed in suite["cases"][1]["seeds"]]}}
+        self.assertEqual(evaluate.aggregate(suite, results, normalize=False), {"case_coverage": 0.5})
+        self.assertIsNone(results["fixture-a"]["mean_return"])
+        self.assertEqual(results["fixture-b"]["mean_return"], -2.0)
+
+    def test_release_mutation_during_replay_is_not_a_score(self):
+        data = self.data()
+        def runner(case, suite, data, relocated, output):
+            changed = json.loads((data / "suite.json").read_text())
+            changed["policy_timeout_sec"] += 1
+            (data / "suite.json").write_text(json.dumps(changed))
+            return {"status": "policy_error"}
+        output = self.root / "changed-release"
+        with self.assertRaisesRegex(InfrastructureError, "release changed"):
+            evaluate.evaluate(data, self.package(), output, runner=runner)
+        self.assertFalse((output / "reward.json").exists())
+
+    def test_negative_gains_remain_visible(self):
+        suite = fixture_suite()
+        results = {c["id"]: {"status": "ok", "episodes": [{"seed": seed, "return": -6.0} for seed in c["seeds"]]}
+                   for c in suite["cases"]}
+        self.assertEqual(evaluate.aggregate(suite, results)["score"], 0)
+        self.assertEqual(results["fixture-a"]["normalized_gain"], -1)
+
+    def test_mutation_and_solver_error_are_not_scores(self):
+        for mode in ("mutation", "solver"):
+            with self.subTest(mode=mode):
+                def runner(case, suite, data, package, output):
+                    if mode == "solver":
+                        raise InfrastructureError("solver failed")
+                    (package / "README.md").write_text("mutated")
+                    return {"status": "policy_error"}
+                data = self.root / "data"
+                if not data.exists():
+                    data = self.data()
+                output = self.root / mode
+                with self.assertRaises(InfrastructureError):
+                    evaluate.evaluate(data, self.package(), output, runner=runner)
+                self.assertFalse((output / "reward.json").exists())
+
+    def test_escaping_package_symlink(self):
+        package = self.package()
+        (package / "escape").symlink_to(self.root)
+        with self.assertRaises(PolicyError):
+            evaluate.package_hash(package)
+
+    def test_stale_output_rejected(self):
+        output = self.root / "out"
+        output.mkdir()
+        (output / "reward.json").write_text('{"score":123}')
+        with self.assertRaises(InfrastructureError):
+            evaluate.evaluate(self.data(), self.package(), output)
+
+    def test_materialize_plan_downloads_nothing(self):
+        destination = self.root / "do-not-create"
+        result = subprocess.run([sys.executable, str(materialize.CATALOG.with_name("materialize.py")),
+                                 str(destination), "--case", "Cylinder_2D_Re200"], capture_output=True, text=True, check=True)
+        plan = json.loads(result.stdout)
+        self.assertEqual(plan["mode"], "plan")
+        self.assertEqual(len(plan["download_commands"]), 1)
+        self.assertFalse(destination.exists())
+
+    def test_resource_checksums_and_truncation(self):
+        path = self.root / "asset"
+        path.write_bytes(b"verified")
+        item = {"rfilename": "asset", "size": 8,
+                "lfs": {"sha256": hashlib.sha256(b"verified").hexdigest()}}
+        materialize.verify_files(self.root, [item])
+        path.write_bytes(b"modified")
+        with self.assertRaises(ValueError):
+            materialize.verify_files(self.root, [item])
+        path.write_bytes(b"v")
+        with self.assertRaises(ValueError):
+            materialize.verify_files(self.root, [item])
+
+    def test_catalog_pins_and_inventory_is_not_suite(self):
+        catalog = json.loads(materialize.CATALOG.read_text())
+        self.assertEqual(catalog["revision"], evaluate.SOURCE_REVISION)
+        self.assertEqual(len(catalog["directories"]), 89)
+        self.assertEqual(sum(c["has_environment_config"] for c in catalog["directories"]), 66)
+        self.assertNotIn("cases", catalog)
+
+
+if __name__ == "__main__":
+    unittest.main()

reproduction/files/04/0429ac4b74abdd4ed14c76efd89f119299132ba6d4fa03e1eb242e4a16df3616/container_smoke.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""Exercise actual Docker role separation with tiny synthetic inputs, not accuracy.
+
+Host orchestration uses only Python's standard library. Fixture generation runs
+inside the already-built verifier image, whose pinned runtime supplies NumPy.
+All three cases use the real supervisor, grader, and Compose topology.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import uuid
+from typing import Any
+
+TASK = Path(__file__).resolve().parents[1]
+PROJECT = Path(__file__).resolve().parents[1] / "environment" / "baseline" / "alphaqubit" if (Path(__file__).resolve().parents[1] / "environment" / "baseline" / "alphaqubit").is_dir() else Path(__file__).resolve().parents[1]
+
+# An executable without a .sh suffix also tests frozen-artifact execute bits.
+DECODER = '''#!/opt/qec/.venv/bin/python
+from pathlib import Path
+import errno
+import json
+import os
+import socket
+import sys
+import numpy as np
+
+assert os.getuid() == os.geteuid() == 10001, "inference must run as isolated UID"
+assert os.getgid() == os.getegid() == 10001
+assert {name for _, name in socket.if_nameindex()} == {"lo"}, "network namespace is not offline"
+assert not Path("/private").exists(), "grader labels leaked into inference container"
+try:
+    list(Path("/sealed").iterdir())
+except PermissionError:
+    pass
+else:
+    raise AssertionError("inference can read the trusted sealed volume")
+status = Path("/proc/self/status").read_text()
+assert any(line.split() == ["NoNewPrivs:", "1"] for line in status.splitlines())
+root = Path(__file__).resolve().parents[1]
+assert root != Path("/workspace/submission"), "artifact was not relocated"
+for target in [root / "model_config.json", Path("/opt/task/qecbench/scoring.py"),
+               Path("/benchmark/manifest.json"), Path("/logs/verifier/forged-reward.json"),
+               Path("/workspace/submission/forged-file")]:
+    try:
+        with target.open("ab"):
+            pass
+    except OSError as error:
+        assert error.errno in (errno.EACCES, errno.EPERM, errno.EROFS), (target, error)
+    else:
+        raise AssertionError(f"inference can modify protected path: {target}")
+inputs, output = map(Path, sys.argv[1:])
+manifest = json.loads((inputs / "manifest.json").read_text())
+probability = json.loads((root / "weights/constant.json").read_text())["probability"]
+assert probability == 0.1
+for condition in manifest["conditions"]:
+    with np.load(inputs / condition["arrays"], allow_pickle=False) as source:
+        assert set(source.files) == {"sample_ids", "detectors"}, "labels leaked into inference input"
+        ids = source["sample_ids"][::-1]
+    np.savez(output / (condition["name"] + ".npz"), sample_ids=ids,
+             probabilities=np.full(len(ids), probability, dtype=np.float32))
+print(json.dumps({"container_security_probe": "passed", "uid": os.getuid(),
+                  "conditions": len(manifest["conditions"]), "probability": probability,
+                  "network_interfaces": [name for _, name in socket.if_nameindex()],
+                  "private_labels_absent": True, "sealed_volume_inaccessible": True,
+                  "protected_paths_not_writable": True, "artifact_relocated": True,
+                  "extensionless_executable_ran": True}), flush=True)
+'''
+
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n")
+
+
+def prepare(root: Path) -> None:
+    """Create unmistakably synthetic public inputs and separately held labels."""
+    import numpy as np
+
+    sys.path.insert(0, str(PROJECT))
+    from baselines.alphaqubit_artifact import EXPECTED_GROUPS
+    from qecbench.data import SCHEMA
+
+    inputs, labels = root / "data/verifier", root / "labels"
+    rows, target_rows = [], []
+    for group in EXPECTED_GROUPS:
+        distance, basis = int(group[1]), group[4]
+        center = group.split("center_")[1]
+        for rounds in range(1, 26, 2):
+            name = f"surface_code_b{basis}_d{distance}_r{rounds:02}_center_{center}"
+            folder = inputs / "conditions" / name
+            folder.mkdir(parents=True)
+            ids = np.array([1017, 5, 991, 70], dtype=np.uint64) + np.uint64(len(rows) * 10000)
+            packed = np.zeros((4, (rounds * (distance ** 2 - 1) + 7) // 8), dtype=np.uint8)
+            np.savez(folder / "arrays.npz", sample_ids=ids, detectors=packed)
+            # The constant decoder does not parse circuits; still provide a valid
+            # Stim detector-count fixture, never an actual experimental circuit.
+            (folder / "circuit_ideal.stim").write_text(
+                "# Synthetic container plumbing fixture, not a physical experiment\nR 0\nM 0\n"
+                + "DETECTOR rec[-1]\n" * (rounds * (distance ** 2 - 1))
+                + "OBSERVABLE_INCLUDE(0) rec[-1]\n"
+            )
+            label_path = labels / "conditions" / f"{name}.npz"
+            label_path.parent.mkdir(parents=True, exist_ok=True)
+            np.savez(label_path, sample_ids=ids, labels=np.array([0, 0, 0, 1], dtype=np.uint8))
+            rows.append({"name": name, "group": group, "distance": distance, "basis": basis,
+                "rounds": rounds, "shots": 4, "num_detectors": rounds * (distance ** 2 - 1),
+                "arrays": f"conditions/{name}/arrays.npz", "arrays_sha256": sha256(folder / "arrays.npz"),
+                "circuit": f"conditions/{name}/circuit_ideal.stim", "circuit_sha256": sha256(folder / "circuit_ideal.stim")})
+            target_rows.append({"name": name, "shots": 4, "arrays": f"conditions/{name}.npz", "arrays_sha256": sha256(label_path)})
+    write_json(inputs / "manifest.json", {"schema": SCHEMA, "split": "test", "synthetic_smoke_only": True,
+        "shots": 520, "conditions": list(reversed(rows))})
+    write_json(labels / "manifest.json", {"schema": "surface-code-decoding-labels/v1",
+        "synthetic_smoke_only": True, "input_manifest_sha256": sha256(inputs / "manifest.json"), "conditions": target_rows})
+    submission = root / "submission-valid"
+    (submission / "bin").mkdir(parents=True)
+    (submission / "bin/decoder").write_text(DECODER)
+    (submission / "bin/decoder").chmod(0o755)
+    (submission / "infer.sh").write_text('#!/usr/bin/env bash\nset -euo pipefail\nROOT="$(cd -- "$(dirname -- "$0")" && pwd)"\nexec "$ROOT/bin/decoder" "$1" "$2"\n')
+    (submission / "infer.sh").chmod(0o755)
+    (submission / "README.md").write_text("Synthetic constant-decoder container smoke. This artifact is not a scientific reference.\n")
+    (submission / "requirements.lock").write_text("Uses the verifier image's pinned NumPy runtime; no additional packages.\n")
+    write_json(submission / "weights/constant.json", {"probability": 0.1})
+    write_json(submission / "model_config.json", {"model": "constant Bernoulli probability", "weights": "weights/constant.json"})
+    write_json(submission / "training_provenance.json", {"purpose": "synthetic container security smoke only",
+        "fit": "Maximum likelihood on nine synthetic negative and one synthetic positive observation", "scientific_accuracy_evidence": False})
+    write_json(submission / "model_manifest.json", {"schema": "surface-code-decoding-model/v1",
+        "checkpoints": [{"path": "weights/constant.json", "sha256": sha256(submission / "weights/constant.json")}],
+        "model_config": "model_config.json", "training_provenance": "training_provenance.json"})
+    shutil.copytree(submission, root / "submission-invalid")
+    (root / "submission-invalid/model_manifest.json").write_text("[]\n")
+    (root / "missing-labels").mkdir()
+    write_json(root / "fixture.json", {"synthetic_smoke_only": True, "conditions": 130, "shots": 520,
+        "expected_valid_performance": 0.75, "source": "deterministic synthetic fixture; no downloaded scientific data"})
+
+
+def command(args: list[str], *, cwd: Path | None = None, env: dict[str, str] | None = None,
+            timeout: int = 600, check: bool = True) -> subprocess.CompletedProcess[str]:
+    print("+ " + " ".join(args), flush=True)
+    result = subprocess.run(args, cwd=cwd, env=env, text=True, stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT, timeout=timeout)
+    if result.stdout:
+        print(result.stdout, end="", flush=True)
+    if check and result.returncode:
+        raise subprocess.CalledProcessError(result.returncode, args, output=result.stdout)
+    return result
+
+
+def collect_reports(container: str, destination: Path) -> None:
+    """Copy individual evidence files without exporting the protected artifact.
+
+    Recursively copying /logs/verifier also exports the frozen 0555 submission
+    tree. Docker then cannot create its children as the unprivileged host user.
+    Keep those security permissions intact and request only reviewable files.
+    """
+    for relative in ("report.json", "reward.json", "inference/inference.log"):
+        target = destination / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        result = command(["docker", "cp", f"{container}:/logs/verifier/{relative}", str(target)], check=False)
+        if result.returncode:
+            # An infrastructure failure must have no reward; an invalid
+            # manifest has no inference log. Other copy errors remain errors.
+            missing = "Could not find the file" in result.stdout
+            if relative != "report.json" and missing:
+                continue
+            raise RuntimeError(f"Cannot collect {relative} from {container}: {result.stdout.strip()}")
+
+
+def case_run(case: str, fixture: Path, output: Path, image: str) -> dict[str, Any]:
+    """Run a fresh main/grader pair and private sealed volume per scenario."""
+    project = "qec-smoke-" + uuid.uuid4().hex[:12]
+    container = project + "-inference"
+    case_output = output / case
+    case_output.mkdir(parents=True)
+    submission = fixture / ("submission-invalid" if case == "invalid-submission" else "submission-valid")
+    labels = fixture / ("missing-labels" if case == "missing-labels" else "labels")
+    override = fixture / f"override-{case}.json"
+    write_json(override, {"services": {
+        "main": {"image": image, "cpus": 2, "mem_limit": "4g", "shm_size": "256m",
+            "volumes": [{"type": "bind", "source": str(submission), "target": "/workspace/submission",
+                         "read_only": True, "bind": {"create_host_path": False}}]},
+        "grader": {"image": image, "cpus": 2, "mem_limit": "4g",
+                   "command": ["python", "/opt/task/tests/grader.py", "--wait-seconds", "180"]}}})
+    env = dict(os.environ, TASK_DATA_DIR=str(fixture / "data"), TASK_PRIVATE_DIR=str(labels))
+    compose = ["docker", "compose", "--project-name", project, "-f", str(TASK / "tests/docker-compose.yaml"),
+               "-f", str(TASK / "tests/docker-compose.cpu-smoke.yaml"), "-f", str(override)]
+    # Check the actual Compose merge: CI must not silently request a GPU.
+    resolved = json.loads(command(compose + ["config", "--format", "json"], env=env).stdout)
+    for service in resolved["services"].values():
+        assert not service.get("deploy", {}).get("resources", {}).get("reservations", {}).get("devices")
+        assert service["network_mode"] == "none"
+    run: subprocess.CompletedProcess[str] | None = None
+    try:
+        command(compose + ["up", "-d", "--no-build", "grader"], env=env)
+        run = command(compose + ["run", "--no-deps", "--name", container, "-e", "QEC_INFERENCE_TIMEOUT_SECONDS=60",
+                                  "main", "/opt/task/tests/test.sh"], env=env, timeout=420, check=False)
+        (case_output / "supervisor.log").write_text(run.stdout)
+        collect_reports(container, case_output)
+        grader_logs = command(compose + ["logs", "--no-color", "grader"], env=env, check=False)
+        (case_output / "grader.log").write_text(grader_logs.stdout)
+        report_path = case_output / "report.json"
+        if not report_path.is_file():
+            raise AssertionError(f"{case}: supervisor did not publish a report; see {case_output}")
+        report = json.loads(report_path.read_text())
+        reward_path = case_output / "reward.json"
+        config = json.loads((PROJECT / "score_config.json").read_text())
+        if case == "valid":
+            assert run.returncode == 0, run.stdout
+            assert report["status"] == "valid" and report["model_quality_measured"] is True
+            assert report["shots"] == 520 and report["conditions"] == 130
+            assert report["performance"] == 0.75 and report["balanced_logical_failure"] == 0.25
+            expected = max(0.0, (0.75 - config["lower_bound"]) / (config["upper_bound"] - config["lower_bound"]))
+            assert math.isclose(report["score"], expected, rel_tol=0, abs_tol=1e-12)
+            assert json.loads(reward_path.read_text())["reward"] == report["performance"]
+            inference_log = (case_output / "inference/inference.log").read_text()
+            probes = [json.loads(line) for line in inference_log.splitlines() if line.startswith('{"container_security_probe"')]
+            assert len(probes) == 1 and probes[0]["container_security_probe"] == "passed"
+        elif case == "invalid-submission":
+            assert run.returncode == 0 and report["status"] == "invalid_submission"
+            assert report["model_quality_measured"] is False and report["performance"] is None
+            assert json.loads(reward_path.read_text()) == {"reward": 0.0}
+        else:
+            assert run.returncode != 0 and report["status"] == "infrastructure_error"
+            assert report["model_quality_measured"] is False and not reward_path.exists()
+        return {"case": case, "status": "passed", "verifier_status": report["status"],
+                "supervisor_exit_code": run.returncode, "score": report.get("score"),
+                "scientific_accuracy_evidence": False}
+    finally:
+        command(["docker", "rm", "-f", container], check=False)
+        command(compose + ["down", "--volumes", "--remove-orphans"], env=env, check=False)
+
+
+def orchestrate(args: argparse.Namespace) -> None:
+    started = time.monotonic()
+    args.output.mkdir(parents=True, exist_ok=True)
+    command(["docker", "version"])
+    command(["docker", "compose", "version"])
+    if args.build:
+        command(["docker", "build", "-t", args.image, "-f", str(TASK / "tests/Dockerfile"), str(TASK)], timeout=2400)
+    with tempfile.TemporaryDirectory(prefix="qec-container-smoke-") as temporary:
+        fixture = Path(temporary)
+        command(["docker", "run", "--rm", "--network", "none", "--user", f"{os.getuid()}:{os.getgid()}",
+                 "--mount", f"type=bind,src={fixture},dst=/fixture", args.image,
+                 "python", "/opt/task/tests/container_smoke.py", "--prepare", "/fixture"])
+        results = [case_run(case, fixture, args.output, args.image)
+                   for case in ("valid", "invalid-submission", "missing-labels")]
+    write_json(args.output / "container-smoke.json", {"schema": "surface-code-container-smoke/v1",
+        "status": "passed", "scientific_accuracy_evidence": False,
+        "scope": "Actual native Docker CPU supervisor/grader role separation and error classification on synthetic data",
+        "cases": results, "wall_seconds": time.monotonic() - started})
+    print(f"Container smoke passed; evidence: {args.output / 'container-smoke.json'}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--prepare", type=Path, help="Internal: generate synthetic fixtures using the image's NumPy")
+    parser.add_argument("--image", default="surface-code-verifier:smoke")
+    parser.add_argument("--build", action="store_true", help="Build the pinned verifier image before the smoke")
+    parser.add_argument("--output", type=Path, default=Path("container-smoke-results"))
+    args = parser.parse_args()
+    if args.prepare:
+        prepare(args.prepare)
+    else:
+        args.output = args.output.resolve()
+        orchestrate(args)
+
+
+if __name__ == "__main__":
+    main()

reproduction/files/05/0554f498d0368ecd36ac232c40d7bcd0b9dc20ed1a901d72e300b13d501ae4d5/test_inference.py

@@ -0,0 +1,69 @@
+"""CPU regression checks for missing observations and batch independence."""
+
+import argparse
+import json
+from pathlib import Path
+import sys
+import numpy as np
+import torch
+
+p = argparse.ArgumentParser()
+p.add_argument("--model", type=Path, required=True)
+p.add_argument("--output", type=Path, required=True)
+a = p.parse_args()
+sys.path.insert(0, str(a.model.resolve()))
+from infer import EncoderConfig, Modality, configure_inference, embed
+
+model = EncoderConfig.from_dict(
+    json.loads((a.model / "config.json").read_text())
+).build()
+model.load_state_dict(
+    torch.load(a.model / "encoder.pt", map_location="cpu", weights_only=True)
+)
+configure_inference(model)
+rng = np.random.default_rng(42)
+pixels = {
+    "sentinel2_l2a": rng.normal(size=(3, 8, 8, 3, 12)).astype(np.float32),
+    "sentinel1": rng.normal(size=(3, 8, 8, 3, 2)).astype(np.float32),
+}
+valid = {
+    "sentinel2_l2a": np.ones((3, 3, 3), dtype=bool),
+    "sentinel1": np.ones((3, 3, 1), dtype=bool),
+}
+valid["sentinel1"][0] = False
+valid["sentinel2_l2a"][1, 1, 1] = False
+for mask in valid.values():
+    mask[2] = False
+
+
+def run(x, masks):
+    return embed(model, x, torch.device("cpu"), center=True, valid=masks)
+
+
+joint = run(pixels, valid)
+alone = np.concatenate(
+    [
+        run(
+            {k: v[i : i + 1] for k, v in pixels.items()},
+            {k: v[i : i + 1] for k, v in valid.items()},
+        )
+        for i in range(3)
+    ]
+)
+altered = {k: v.copy() for k, v in pixels.items()}
+for name in altered:
+    spec = Modality.get(name)
+    for row, time, group in np.argwhere(~valid[name]):
+        for band in spec.band_sets[group].bands:
+            altered[name][row, :, :, time, spec.band_order.index(band)] = 100000
+perturbed = run(altered, valid)
+report = {
+    "single_vs_batch_max_abs": float(np.max(abs(joint - alone))),
+    "masked_pixel_perturbation_max_abs": float(np.max(abs(joint - perturbed))),
+    "unobserved_row_is_zero": bool(np.all(joint[2] == 0)),
+}
+assert report["single_vs_batch_max_abs"] < 1e-5, report
+assert report["masked_pixel_perturbation_max_abs"] < 1e-5, report
+assert report["unobserved_row_is_zero"], report
+a.output.write_text(json.dumps(report, indent=2))
+print(json.dumps(report, indent=2))

reproduction/files/05/05735f6057ba486e9a82f09c0748bf41c8c736b775acd454c0343ff826bded8a/crystal_cache.py

@@ -0,0 +1,29 @@
+"""Per-grading-job writable HF lock directory over frozen dataset tables.
+
+This is the same directory-link layout used by the task's native
+writable_datasets_cache helper, applied explicitly by the Beaker launcher.
+No scorer functions or dataset bytes are changed.
+"""
+from pathlib import Path
+
+
+def prepare(source, destination):
+    source = Path(source).resolve(strict=True)
+    destination = Path(destination)
+    if not source.is_dir():
+        raise ValueError('Prepared dataset cache is not a directory')
+    if destination.resolve().is_relative_to(source):
+        raise ValueError('Writable cache must be outside prepared assets')
+    destination.mkdir(parents=True, exist_ok=False)
+    linked = []
+    for entry in sorted(source.iterdir()):
+        if entry.is_dir():
+            target = entry.resolve(strict=True)
+            if not target.is_relative_to(source):
+                raise ValueError('Prepared dataset directory escapes asset cache')
+            (destination / entry.name).symlink_to(target, target_is_directory=True)
+            linked.append(entry.name)
+    if not linked:
+        raise ValueError('No prepared dataset tables found')
+    return {'source': str(source), 'writable_cache': str(destination),
+            'linked_datasets': linked, 'table_bytes_copied': False}

reproduction/files/06/06574a519731708f2dbb71ebeb491fbdf3114f4d7af8b9eb121da35fd30c1b62/test_sharding.py

@@ -0,0 +1,100 @@
+"""Check lossless input shards, complete batch boundaries and merge rejection."""
+
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+import h5py
+import numpy as np
+
+TRACK = Path(__file__).resolve().parents[1]
+
+
+class ShardingTest(unittest.TestCase):
+    def test_coverage_and_rejection(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            source = root / "input.h5"
+            pixels = np.arange(102, dtype=np.uint16).reshape(51, 2)
+            with h5py.File(source, "w") as h:
+                h.attrs["task"] = "lfmc"
+                h.create_dataset(
+                    "ids", data=[str(i) for i in range(51)], dtype=h5py.string_dtype()
+                )
+                h.create_dataset("sentinel2_l2a", data=pixels)
+            command = [
+                sys.executable,
+                str(TRACK / "environment/data/shard_inputs.py"),
+                "--input",
+                str(source),
+                "--output",
+                str(root / "shards"),
+                "--shards",
+                "3",
+            ]
+            result = subprocess.run(command, capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            manifest_path = root / "shards/manifest.json"
+            manifest = json.loads(manifest_path.read_text())
+            self.assertEqual([s["start"] for s in manifest["shards"]], [0, 16, 32])
+            collected = []
+            for index, shard in enumerate(manifest["shards"]):
+                with h5py.File(root / "shards" / shard["file"]) as h:
+                    collected.append(h["sentinel2_l2a"][:])
+                    ids = h["ids"].asstr()[:].astype(str)
+                    features = np.repeat(
+                        np.arange(shard["start"], shard["stop"], dtype=np.float32)[
+                            :, None
+                        ],
+                        3,
+                        axis=1,
+                    )
+                part = root / f"features/part{index:03d}"
+                part.mkdir(parents=True)
+                np.savez(part / "features.npz", ids=ids, features=features)
+            np.testing.assert_array_equal(np.concatenate(collected), pixels)
+            output = root / "merged.npz"
+            merge = [
+                sys.executable,
+                str(TRACK / "docs/analysis/merge_features.py"),
+                "--manifest",
+                str(manifest_path),
+                "--features",
+                str(root / "features"),
+                "--output",
+                str(output),
+            ]
+            result = subprocess.run(merge, capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            with np.load(output, allow_pickle=False) as merged:
+                np.testing.assert_array_equal(merged["ids"], np.arange(51).astype(str))
+                np.testing.assert_array_equal(merged["features"][:, 0], np.arange(51))
+            result = subprocess.run(merge, capture_output=True, text=True)
+            self.assertNotEqual(
+                result.returncode, 0, "must not overwrite existing features"
+            )
+            output.unlink()
+            original = manifest_path.read_text()
+            manifest["start"] = 16
+            manifest["full_release"] = False
+            manifest_path.write_text(json.dumps(manifest))
+            result = subprocess.run(merge, capture_output=True, text=True)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("complete release", result.stderr)
+            manifest_path.write_text(original)
+            path = root / "features/part001/features.npz"
+            with np.load(path, allow_pickle=False) as good:
+                ids, features = good["ids"].copy(), good["features"].copy()
+            ids[0] = ids[1]
+            np.savez(path, ids=ids, features=features)
+            result = subprocess.run(merge, capture_output=True, text=True)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("IDs do not match", result.stderr)
+            self.assertFalse(output.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

reproduction/files/07/07c28629ae97a2a93f1730061d27d8d096731bcd7a9e579e00c7980e0d6afc24/test_native_replay.py

@@ -0,0 +1,246 @@
+"""Synthetic bookkeeping/adapter tests, never substitutes for native CFD runs."""
+import json
+from pathlib import Path
+import sys
+import subprocess
+import tempfile
+import unittest
+from unittest.mock import Mock, patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'environment/evaluation'))
+import case_spec
+import evaluate_native as replay
+from evaluate import package_hash
+from protocol import InfrastructureError, PolicyError
+
+
+class NativeProfilesTests(unittest.TestCase):
+    def test_exact_frozen_coverage_and_semantics(self):
+        spec, cases = case_spec.select_cases(['all'])
+        release = case_spec.load_release()
+        self.assertEqual([c['id'] for c in cases], [c['id'] for c in release['cases']])
+        self.assertEqual(len(cases), 39)
+        self.assertEqual(spec['data_release_sha256'], case_spec.digest(release))
+        for c, source in zip(cases, release['cases']):
+            self.assertEqual(c['runtime_profile'], source['runtime_profile'])
+            self.assertEqual(c['solver_processes'], source['required_solver_gpus'])
+            self.assertEqual(c['horizon'], source['selection_review']['native_episode_controls_for_costing'])
+            self.assertEqual(c['seeds'], [123])
+            self.assertEqual(c['episode_end'], 'native')
+            self.assertGreaterEqual(c['timeout_sec'], 1800)
+        self.assertEqual({c['backend'] for c in cases}, {'maia', 'jax', 'jax-fluids'})
+        self.assertEqual(max(c['observation_size'] for c in cases), 128)
+        self.assertEqual(max(c['action_size'] for c in cases), 24)
+
+    def test_unknown_duplicate_and_mixed_all_rejected(self):
+        for names in ([], ['unknown'], ['all', 'Cylinder_2D_Re200'],
+                      ['Cylinder_2D_Re200', 'Cylinder_2D_Re200']):
+            with self.subTest(names=names), self.assertRaises(InfrastructureError):
+                case_spec.select_cases(names)
+
+    def test_source_rejection_precedes_policy(self):
+        with tempfile.TemporaryDirectory() as directory:
+            with self.assertRaises((InfrastructureError, OSError)):
+                case_spec.verify_resources(Path(directory), case_spec.select_cases(['all'])[1])
+
+    def test_missing_second_gpu_fails_before_native_solver_import(self):
+        import run_native
+        with tempfile.TemporaryDirectory() as directory:
+            args = ['run_native.py', '--case', 'Cube_3D_Re3700', '--data', directory,
+                    '--submission', directory, '--output', directory]
+            with patch.object(sys, 'argv', args), patch.object(run_native, 'verify_resources'), \
+                    patch.object(run_native, 'local_only'), \
+                    patch.object(run_native.subprocess, 'check_output', return_value='["GPU-test"]'):
+                with self.assertRaisesRegex(RuntimeError, 'requires 2 distinct GPUs'):
+                    run_native.main()
+            self.assertTrue((Path(directory) / 'launcher-error.json').exists())
+
+
+class NativeReplayTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.data = self.root / 'data'
+        self.data.mkdir()
+        self.package = self.root / 'candidate'
+        self.package.mkdir()
+        (self.package / 'README.md').write_text('Synthetic bookkeeping fixture, not a model.\n')
+        (self.package / 'infer.sh').write_text('exit 0\n')
+        self.names = ['Cylinder_2D_Re200', 'Channel_3D_Retau180']
+        self.output = self.root / 'results'
+        self.verify = patch.object(replay, 'verify_resources').start()
+        self.addCleanup(patch.stopall)
+        self.snapshots = []
+
+    def runner(self, case, data, package, output):
+        self.assertNotEqual(package, self.package)
+        self.assertEqual(package_hash(package), package_hash(self.package))
+        self.snapshots.append(str(package))
+        return {'status': 'ok', 'submission_sha256': package_hash(package), 'episodes': [
+            {'seed': seed, 'steps': case['horizon'], 'return': -4.0,
+             'primary_metric': dict(case['primary_metric'], status='ok', value=1.25),
+             'terminated': True, 'truncated': False} for seed in case['seeds']]}
+
+    def evaluate(self, runner=None):
+        return replay.evaluate_native(self.data, self.package, self.output, self.names,
+                                      runner=runner or self.runner)
+
+    def test_relocated_same_package_no_anchors_or_suite_required(self):
+        result = self.evaluate()
+        self.assertEqual(result['status'], 'ok')
+        self.assertEqual(result['successful_cases'], 2)
+        self.assertFalse(result['benchmark_validated'])
+        self.assertFalse(result['all_frozen_cases_selected'])
+        self.assertEqual(len(set(self.snapshots)), 1)
+        self.assertEqual(result['cases'][self.names[0]]['mean_return'], -4)
+        self.assertEqual(result['cases'][self.names[0]]['primary_metric']['value'], 1.25)
+        self.assertEqual(self.verify.call_count, 2)
+        self.assertFalse((self.output / 'reward.json').exists())
+        self.assertFalse((self.data / 'suite.json').exists())
+
+    def test_all_cases_keep_one_package_and_full_accounting(self):
+        self.names = ['all']
+        result = self.evaluate()
+        self.assertEqual(result['successful_cases'], 39)
+        self.assertTrue(result['all_frozen_cases_selected'])
+        self.assertFalse(result['benchmark_validated'])
+        self.assertEqual(len(set(self.snapshots)), 1)
+
+    def test_failures_are_explicit_and_remaining_cases_still_run(self):
+        def runner(case, *args):
+            if case['id'] == self.names[0]:
+                raise InfrastructureError('Synthetic solver failure')
+            row = self.runner(case, *args)
+            row.update(status='policy_error', error='Synthetic malformed action')
+            row.pop('episodes')
+            return row
+        result = self.evaluate(runner)
+        self.assertEqual(result['status'], 'completed_with_errors')
+        self.assertEqual(len(result['cases']), 2)
+        self.assertEqual(result['cases'][self.names[0]]['status'], 'infrastructure_error')
+        self.assertEqual(result['cases'][self.names[1]]['status'], 'policy_error')
+        self.assertNotIn('mean_return', result['cases'][self.names[1]])
+        self.assertFalse((self.output / 'reward.json').exists())
+
+    def test_missing_package_records_every_requested_case(self):
+        self.package = self.root / 'absent'
+        result = self.evaluate()
+        self.assertEqual(result['requested_cases'], 2)
+        self.assertTrue(all(r['status'] == 'policy_error' for r in result['cases'].values()))
+
+    def test_invalid_episode_or_package_identity_rejected(self):
+        corruptions = [lambda row: row.update(submission_sha256='wrong'),
+            lambda row: row['episodes'][0].update(steps=1),
+            lambda row: row['episodes'][0].update(seed=0),
+            lambda row: row['episodes'][0].update(**{'return': float('nan')}),
+            lambda row: row['episodes'][0].pop('primary_metric'),
+            lambda row: row['episodes'][0]['primary_metric'].update(value=float('nan')),
+            lambda row: row['episodes'][0].update(terminated=False, truncated=False)]
+        for i, corrupt in enumerate(corruptions):
+            self.output = self.root / f'bad-{i}'
+            def runner(*args):
+                row = self.runner(*args)
+                corrupt(row)
+                return row
+            with self.subTest(i=i):
+                result = self.evaluate(runner)
+                self.assertTrue(all(r['status'] == 'infrastructure_error' for r in result['cases'].values()))
+
+    def test_snapshot_mutation_rejects_entire_run(self):
+        def runner(case, data, package, output):
+            row = self.runner(case, data, package, output)
+            (package / 'README.md').write_text('Changed during replay')
+            return row
+        with self.assertRaisesRegex(InfrastructureError, 'snapshot mutated'):
+            self.evaluate(runner)
+        self.assertTrue((self.output / 'error.json').exists())
+        self.assertFalse((self.output / 'results.json').exists())
+
+    def test_resource_change_rejects_results(self):
+        self.verify.side_effect = [None, InfrastructureError('Source changed')]
+        with self.assertRaisesRegex(InfrastructureError, 'Source changed'):
+            self.evaluate()
+        self.assertFalse((self.output / 'results.json').exists())
+
+    def test_code_change_rejects_results(self):
+        with patch.object(replay, 'implementation_hash', side_effect=['before', 'after']):
+            with self.assertRaisesRegex(InfrastructureError, 'implementation changed'):
+                self.evaluate()
+
+    def test_policy_session_cleanup_and_pid_reuse_protection(self):
+        process = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(30)'], start_new_session=True)
+        self.addCleanup(lambda: process.poll() is None and process.kill())
+        ticks = Path(f'/proc/{process.pid}/stat').read_text().rsplit(')', 1)[1].split()[19]
+        receipt = self.root / 'policy-process.json'
+        receipt.write_text(json.dumps({'pid': process.pid, 'start_ticks': 'stale'}))
+        replay.stop_policy(self.root)
+        self.assertIsNone(process.poll())
+        receipt.write_text(json.dumps({'pid': process.pid, 'start_ticks': ticks}))
+        replay.stop_policy(self.root)
+        self.assertEqual(process.wait(timeout=3), -9)
+        replay.stop_policy(self.root)
+
+    def test_immediate_policy_exit_is_not_an_infrastructure_error(self):
+        import native_envs
+        import run_native
+        env, policy = Mock(), Mock()
+        policy.process.pid = 999999999
+        case = case_spec.select_cases([self.names[0]])[1][0]
+        with patch.object(native_envs, 'make_env', return_value=env), \
+                patch.object(run_native, 'Policy', return_value=policy), \
+                patch.object(run_native, 'replay_episode', side_effect=PolicyError('Exited')):
+            run_native.worker(case, self.data, self.package, self.root)
+        self.assertEqual(json.loads((self.root / 'result.json').read_text())['status'], 'policy_error')
+        policy.abort.assert_called_once()
+        env.close.assert_called_once()
+
+    def test_overlapping_and_stale_outputs_rejected(self):
+        for output in (self.data / 'output', self.package / 'output', self.root):
+            self.output = output
+            with self.subTest(output=output), self.assertRaises(InfrastructureError):
+                self.evaluate()
+        self.output = self.root / 'results'
+        self.output.mkdir()
+        (self.output / 'reward.json').write_text('{"score":1}')
+        with self.assertRaisesRegex(InfrastructureError, 'empty'):
+            self.evaluate()
+
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+@unittest.skipIf(np is None, 'Native scalar adapters need NumPy from the task runtime')
+class ReplayAdapterTests(unittest.TestCase):
+    def test_native_completion_and_scalar_diagnostics(self):
+        from native_envs import ReplayAdapter
+        class Env:
+            class Space:
+                dtype, shape = np.float32, (1,)
+            observation_space = action_space = Space()
+            def reset(self, seed):
+                self.count = 0
+                return np.zeros(1), {}
+            def step(self, action):
+                self.count += 1
+                return np.ones(1), np.float32(-1), self.count == 2, False, {'lift': np.array([2.])}
+        with tempfile.TemporaryDirectory() as directory:
+            env = ReplayAdapter(Env(), {'id': 'synthetic', 'horizon': 2}, Path(directory))
+            env.reset(seed=123)
+            self.assertFalse(env.step([0])[2])
+            self.assertEqual(env.step([0])[4], {'lift': 2.0})
+            self.assertEqual(json.loads((Path(directory) / 'progress.json').read_text())['phase'], 'complete')
+            with self.assertRaises(InfrastructureError):
+                env.step([0])
+            env.case['horizon'] = 3
+            env.reset(seed=123)
+            env.step([0])
+            with self.assertRaisesRegex(InfrastructureError, 'termination differs'):
+                env.step([0])
+
+
+if __name__ == '__main__':
+    unittest.main()

reproduction/files/08/08431c3d888f0a102552f1facf1ea72135d88e504584f2531dea1a5c0c979e2f/score_extra.py

@@ -0,0 +1,201 @@
+"""Score a run of extra.py against the references of the same split.
+
+    python score_extra.py --suite kappa|mof|amorphous|cleavage|neb --run RUN_DIR \
+        --inputs INPUTS_DIR --references REFERENCES_DIR
+
+INPUTS_DIR is the label-free split directory given to extra.py; REFERENCES_DIR holds its
+references.json(.gz). The two may be the same directory (development builds).
+
+Missing or failed items are scored, never dropped:
+- kappa: SRME as in Matbench Discovery (imaginary modes, broken symmetry and failures score 2).
+- mof: MAPE of B0; each MOF's error is capped at 200 %, and a failed MOF scores the cap.
+- amorphous: per-system energy RMSE (offset removed) and force RMSE, each relative to the reference
+  standard deviation; a failed structure scores about twice the error of predicting the mean
+  (energy error +-2 std, forces -F_ref).
+- cleavage: relative MAE (MAE / mean |reference|); each slab's error is capped at 2 |reference|, and
+  a failed slab scores the cap.
+- neb: barrier MAE over all paths with each error capped at 2 eV (diverging NEB runs give errors of
+  tens of eV); a failed path scores the cap. Also reports the converged fraction and the MAE over
+  converged paths.
+"""
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+from pathlib import Path
+
+import numpy as np
+
+KAPPA_ERROR_MAX = 2.0
+MOF_CAP = 2.0
+NEB_CAP_EV = 2.0
+
+
+def load(path: Path):
+    return json.load(gzip.open(path)) if path.suffix == ".gz" else json.loads(path.read_text())
+
+
+def predictions(run: Path) -> dict[str, dict]:
+    out = {}
+    for f in (run / "items").glob("*.json"):
+        r = json.loads(f.read_text())
+        out[r["id"]] = r
+    return out
+
+
+def ok(p):
+    return p is not None and p.get("status") == "ok"
+
+
+# ------------------------------------------------------------------------------------------ kappa
+def kappa_avg(kappa) -> np.ndarray:
+    a = np.asarray(kappa, dtype=float)
+    if a.shape[-2:] == (3, 3):
+        return np.trace(a, axis1=-2, axis2=-1) / 3
+    if a.shape[-1] == 6:
+        return a[..., :3].mean(axis=-1)
+    if a.shape[-1] == 3:
+        return a.mean(axis=-1)
+    raise ValueError(f"unexpected kappa shape {a.shape}")
+
+
+def _finite(value, nonnegative=False):
+    try:
+        v = np.asarray(value, dtype=float)
+    except (TypeError, ValueError):
+        return None
+    if v.size == 0 or not np.all(np.isfinite(v)) or (nonnegative and np.any(v < 0)):
+        return None
+    return v
+
+
+def srme_one(pred: dict | None, ref: dict) -> tuple[float, float, bool]:
+    """(SRME, SRD, censored) for one material, following matbench_discovery/metrics/phonons.py."""
+    true_total = float(np.ravel(ref["kappa_tot_avg"])[0])
+    true_mode = np.asarray(ref["mode_kappa_tot_avg"], dtype=float)
+    if not ok(pred):
+        return KAPPA_ERROR_MAX, -KAPPA_ERROR_MAX, True
+    censored = bool(pred.get("has_imag_ph_modes"))
+    expected_spg = ref.get("init_spg_num")
+    if not censored and pred.get("final_spg_num") and expected_spg:
+        censored = pred["final_spg_num"] != expected_spg
+    total = _finite(kappa_avg(pred["kappa_tot_rta"]) if pred.get("kappa_tot_rta") is not None else None, True)
+    srd = -KAPPA_ERROR_MAX
+    if total is not None and total.size == 1:
+        t = float(total.ravel()[0])
+        srd = 0.0 if t + true_total == 0 else KAPPA_ERROR_MAX * (t - true_total) / (t + true_total)
+    if censored or total is None or total.size != 1:
+        return KAPPA_ERROR_MAX, srd, True
+    mode = _finite(kappa_avg(pred["mode_kappa_tot_rta"]) if pred.get("mode_kappa_tot_rta") is not None else None)
+    # Predictions are produced in the process that imports the untrusted calculator.
+    # The quadrature normalizer belongs to the pinned reference, never that process.
+    weights = _finite(ref.get("weights"), True)
+    if mode is None or weights is None or weights.sum() <= 0 or mode.shape != true_mode.shape:
+        return KAPPA_ERROR_MAX, srd, True
+    micro = np.abs(mode - true_mode).sum(axis=tuple(range(1, mode.ndim))) / weights.sum()
+    denom = np.atleast_1d(total) + np.atleast_1d(true_total)
+    score = float(np.ravel(np.where(denom == 0, np.where(micro == 0, 0, KAPPA_ERROR_MAX),
+                                    KAPPA_ERROR_MAX * micro / denom))[0])
+    if not np.isfinite(score) or not 0 <= score <= KAPPA_ERROR_MAX:
+        return KAPPA_ERROR_MAX, srd, True
+    return score, srd, False
+
+
+def score_kappa(pred, root):
+    ref = {r["material_id"]: r for r in load(root / "references.json.gz")}
+    rows = {m: srme_one(pred.get(m), r) for m, r in sorted(ref.items())}
+    srme = np.array([r[0] for r in rows.values()]); srd = np.array([r[1] for r in rows.values()])
+    return {"items": len(rows), "kappa_SRME": float(srme.mean()), "kappa_SRE": float(np.abs(srd).mean()),
+            "kappa_SRD": float(srd.mean()), "censored_or_failed": int(sum(r[2] for r in rows.values()))}
+
+
+# ------------------------------------------------------------------------------------------ others
+def score_mof(pred, root):
+    ref = {r["id"]: float(r["B0_GPa"]) for r in load(root / "references.json")}
+    err, failed = [], 0
+    for k, y in sorted(ref.items()):
+        p = pred.get(k)
+        b = p.get("B_GPa") if ok(p) else None
+        if b is None or not np.isfinite(b):
+            failed += 1; err.append(MOF_CAP)
+        else:
+            err.append(min(abs(b - y) / abs(y), MOF_CAP))
+    return {"items": len(ref), "bulk_modulus_MAPE_pct": float(100 * np.mean(err)), "failed": failed}
+
+
+def score_amorphous(pred, root):
+    refs = load(root / "references.json.gz")
+    systems = sorted({r["system"] for r in refs})
+    out, failed = {"items": len(refs)}, 0
+    for s in systems:
+        rs = [r for r in refs if r["system"] == s]
+        er = np.array([r["energy_per_atom"] for r in rs])
+        d, fr, fp = [], [], []
+        for k, r in enumerate(rs):
+            p = pred.get(r["id"])
+            f_ref = np.asarray(r["forces"], dtype=float)
+            if ok(p) and np.isfinite(p["energy_per_atom"]) and np.shape(p["forces"]) == f_ref.shape \
+                    and np.isfinite(p["forces"]).all():
+                d.append(p["energy_per_atom"] - r["energy_per_atom"]); fp.append(np.asarray(p["forces"], dtype=float))
+            else:  # about twice the trivial predictor's error, so failing never helps
+                failed += 1; d.append((1 if k % 2 == 0 else -1) * 2 * er.std()); fp.append(-f_ref)
+            fr.append(f_ref)
+        d = np.array(d)
+        d = d - d.mean()
+        fr, fp = np.concatenate(fr), np.concatenate(fp)
+        out[f"{s}_energy_RelRMSE_pct"] = float(100 * np.sqrt((d ** 2).mean()) / er.std())
+        out[f"{s}_force_RelRMSE_pct"] = float(100 * np.sqrt(((fp - fr) ** 2).mean()) / fr.std())
+    out["energy_RelRMSE_pct_mean"] = float(np.mean([out[f"{s}_energy_RelRMSE_pct"] for s in systems]))
+    out["force_RelRMSE_pct_mean"] = float(np.mean([out[f"{s}_force_RelRMSE_pct"] for s in systems]))
+    out["failed"] = failed
+    return out
+
+
+def score_cleavage(pred, root):
+    ref = {r["id"]: float(r["cleavage_energy"]) for r in load(root / "references.json")}
+    y = np.array(list(ref.values()))
+    good = np.array([ok(pred.get(k)) and np.isfinite(pred[k]["cleavage_energy"]) for k in ref])
+    p = np.array([pred[k]["cleavage_energy"] if g else np.nan for k, g in zip(ref, good)])
+    err = np.where(good, np.minimum(np.abs(p - y), 2 * np.abs(y)), 2 * np.abs(y))
+    return {"items": len(ref), "cleavage_relMAE_pct": float(100 * err.mean() / np.abs(y).mean()),
+            "cleavage_MAE_eV_A2": float(err.mean()), "cleavage_signed_eV_A2": float((p - y)[good].mean()) if good.any() else None,
+            "failed": int((~good).sum())}
+
+
+def score_neb(pred, root):
+    ref = {r["id"]: float(r["barrier_eV"]) for r in load(root / "references.json")}
+    y = np.array(list(ref.values()))
+    good = np.array([ok(pred.get(k)) and np.isfinite(pred[k]["barrier_eV"]) for k in ref])
+    p = np.array([pred[k]["barrier_eV"] if g else np.nan for k, g in zip(ref, good)])
+    err = np.where(good, np.minimum(np.abs(p - y), NEB_CAP_EV), NEB_CAP_EV)
+    conv = np.array([g and bool(pred[k]["converged"]) for k, g in zip(ref, good)])
+    return {"items": len(ref), "barrier_MAE_eV": float(err.mean()),
+            "barrier_MAE_converged_eV": float(np.abs(p - y)[conv].mean()) if conv.any() else None,
+            "converged_frac": float(conv.mean()), "failed": int(len(ref) - sum(good))}
+
+
+SCORERS = {"kappa": score_kappa, "mof": score_mof, "amorphous": score_amorphous,
+           "cleavage": score_cleavage, "neb": score_neb}
+
+
+def score(suite: str, run: Path, inputs: Path, references: Path) -> dict:
+    info = json.loads((run / "run.json").read_text())
+    import hashlib
+    if info.get("inputs_manifest_sha256") != hashlib.sha256((inputs / "manifest.json").read_bytes()).hexdigest():
+        raise SystemExit(f"{suite}: run was made on a different split")
+    return {"suite": suite, **SCORERS[suite](predictions(run), references), "complete": info["complete"]}
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    ap.add_argument("--suite", choices=sorted(SCORERS), required=True)
+    ap.add_argument("--run", type=Path, required=True)
+    ap.add_argument("--inputs", type=Path, required=True)
+    ap.add_argument("--references", type=Path, required=True)
+    a = ap.parse_args()
+    print(json.dumps(score(a.suite, a.run, a.inputs, a.references), indent=1))
+
+
+if __name__ == "__main__":
+    main()

reproduction/files/08/08b0e3ae8a6e54b006cf60ffe74c63de172d0fa89714ff77df4f93866b1d63c1/grader.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Trusted scorer. Reads sealed predictions + private responses; never executes submission code.
+
+Writes to --output:
+  reward.json          {"reward": mean over test contexts of the FINAL-subset score, ...}
+  report.json          full per-context / per-subset / per-stratum report (operator-facing)
+  agent_feedback.json  leaderboard-subset scores only (what the runner may return to the agent)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+
+from cellscore import cell_eval_version, score_context, sha256
+
+
+def harbor_reward(values):
+    """Harbor parses reward.json as a flat object of finite numbers; strings, None and nested details
+    belong in report.json / status.json."""
+    import math as _math
+    return {k: v for k, v in values.items() if isinstance(v, (int, float)) and _math.isfinite(v)}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--sealed", required=True, type=lambda x: Path(x).resolve())
+    ap.add_argument("--benchmark", required=True, type=lambda x: Path(x).resolve())
+    ap.add_argument("--private", required=True, type=lambda x: Path(x).resolve())
+    ap.add_argument("--output", required=True, type=lambda x: Path(x).resolve())
+    ap.add_argument("--wait-seconds", type=int, default=14400)
+    ap.add_argument("--threads", type=int)
+    args = ap.parse_args()
+    ready = args.sealed.parent / "READY"
+    deadline = time.monotonic() + args.wait_seconds
+    while not ready.is_file():
+        if time.monotonic() >= deadline:
+            raise TimeoutError("prediction snapshot was not published")
+        time.sleep(2)
+    snapshot_path = args.sealed / "snapshot.json"
+    if ready.read_text().strip() != sha256(snapshot_path):
+        raise ValueError("snapshot ready hash mismatch")
+    snapshot = json.loads(snapshot_path.read_text())
+    contexts = sorted(p.name for p in args.private.iterdir() if (p / "responses.h5ad").exists())
+    report = {"schema": "virtual-cell-zeroshot-report/v1", "cell_eval_version": cell_eval_version(),
+              "evaluation_mode": "isolated_model_replay", "contexts": {}}
+    finals, boards = [], []
+    scratch = args.output / "scratch"
+    for ctx in contexts:
+        priv = args.private / ctx
+        pm = json.loads((priv / "manifest.json").read_text())
+        if pm["responses_sha256"] != sha256(priv / "responses.h5ad"):
+            raise ValueError(f"{ctx}: private response checksum mismatch")
+        public = args.benchmark / ctx / "public"
+        entry = snapshot["contexts"].get(ctx)
+        if pm["requests_sha256"] != sha256(public / "requests.jsonl") or pm["public_basal_sha256"] != sha256(public / "basal.h5ad"):
+            raise ValueError(f"{ctx}: public inputs differ from the private manifest")
+        if not entry or entry.get("failed"):
+            report["contexts"][ctx] = {"status": "failed", "error": (entry or {}).get("error", "missing"),
+                                      "tier": pm["tier"], "final_score": 0.0, "leaderboard_score": 0.0}
+            finals.append(0.0); boards.append(0.0)
+            continue
+        pred = args.sealed / ctx / "predictions.h5ad"
+        if entry["predictions_sha256"] != sha256(pred) or entry["requests_sha256"] != sha256(public / "requests.jsonl") \
+                or entry["basal_sha256"] != sha256(public / "basal.h5ad"):
+            raise ValueError(f"{ctx}: sealed snapshot provenance mismatch")
+        subsets = {"leaderboard": [r["request_id"] for r in pm["requests"] if r["subset"] == "leaderboard"],
+                   "final": [r["request_id"] for r in pm["requests"] if r["subset"] == "final"]}
+        groups = {"stratum": {r["request_id"]: r["stratum"] for r in pm["requests"]},
+                  "target_seen": {r["request_id"]: ("withheld" if r["withheld"] else ("seen" if r["seen_in_training"] else "unseen"))
+                                  for r in pm["requests"]},
+                  "final_by_stratum": {r["request_id"]: r["stratum"] for r in pm["requests"] if r["subset"] == "final"}}
+        baseline_dir = priv / "noeffect" if (priv / "noeffect").exists() else None
+        res = score_context(pred, priv / "basal.h5ad", priv / "responses.h5ad", public / "requests.jsonl",
+                            scratch / ctx, subsets=subsets, groups=groups, threads=args.threads, baseline_dir=baseline_dir)
+        final = res["subsets"]["final"]["score"]; board = res["subsets"]["leaderboard"]["score"]
+        report["contexts"][ctx] = {"status": "ok", "tier": pm["tier"], "chemistry": pm["chemistry"],
+                                   "final_score": final, "leaderboard_score": board, "all_score": res["all"]["score"],
+                                   "final": res["subsets"]["final"], "leaderboard": res["subsets"]["leaderboard"],
+                                   "all": res["all"], "groups": res["groups"], "inference_seconds": entry.get("seconds")}
+        finals.append(final); boards.append(board)
+    reward = float(np.mean(finals)) if finals else 0.0
+    report["reward"] = reward
+    report["leaderboard_reward"] = float(np.mean(boards)) if boards else 0.0
+    args.output.mkdir(parents=True, exist_ok=True)
+    (args.output / "report.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+    (args.output / "agent_feedback.json").write_text(json.dumps({
+        "schema": "virtual-cell-zeroshot-feedback/v1", "cell_eval_version": report["cell_eval_version"],
+        "leaderboard_reward": report["leaderboard_reward"],
+        "contexts": {c: {"status": v["status"], "tier": v["tier"], "leaderboard_score": v["leaderboard_score"],
+                         "leaderboard": v.get("leaderboard"), "error": v.get("error")} for c, v in report["contexts"].items()},
+    }, indent=2, sort_keys=True) + "\n")
+    (args.output / "reward.json").write_text(json.dumps(harbor_reward({
+        "reward": reward, "leaderboard_reward": report["leaderboard_reward"],
+        **{f"{c}_final": v["final_score"] for c, v in report["contexts"].items()},
+        **{f"{c}_leaderboard": v["leaderboard_score"] for c, v in report["contexts"].items()},
+    }), indent=2, sort_keys=True) + "\n")
+
+
+if __name__ == "__main__":
+    main()

reproduction/files/0b/0b18d04b2b1f948d7d230ff451c93a205521037a985a856a979ba38d3c3d47ad/common.py

@@ -0,0 +1,106 @@
+"""Small, explicit interchange format. No model code is imported by the scorer."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+from ase import Atoms
+
+PROTOCOL = "atomistic-materials-v0.1"
+PHONON_FIELDS = {
+    "max_freq": "K",
+    "avg_freq": "K",
+    "entropy": "J/(mol primitive cell K)",
+    "heat_capacity": "J/(mol primitive cell K)",
+    "free_energy": "kJ/mol primitive cell",
+}
+ELASTIC_FIELDS = {"bulk_modulus_vrh": "GPa", "shear_modulus_vrh": "GPa"}
+
+
+def digest(path: Path, algorithm="sha256") -> str:
+    """File digest; a directory (submission) digests its sorted relative paths and file digests."""
+    h = hashlib.new(algorithm)
+    if path.is_dir():
+        for item in sorted(p for p in path.rglob("*") if p.is_file() and "__pycache__" not in p.parts):
+            h.update(f"{item.relative_to(path).as_posix()}\0{digest(item, algorithm)}\n".encode())
+        return h.hexdigest()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def with_oom_retry(run, attempts=4, wait=20.0):
+    """run() again after a CUDA out-of-memory error, which other jobs on a shared GPU can cause.
+
+    The verifier runs every suite at once, so a GPU can fill up briefly; that is not the model's
+    failure. Any other error, or a fourth OOM, propagates and the case is recorded as failed."""
+    import gc
+    import time
+    for attempt in range(attempts):
+        try:
+            return run()
+        except Exception as error:
+            if type(error).__name__ != "OutOfMemoryError" or attempt == attempts - 1:
+                raise
+            gc.collect()
+            import torch
+            torch.cuda.empty_cache()
+            time.sleep(wait * (attempt + 1))
+
+
+def write_json(path: Path, value) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, indent=2, allow_nan=False) + "\n")
+
+
+def write_rows(path: Path, rows) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w") as stream:
+        for row in rows:
+            stream.write(json.dumps(row, allow_nan=False) + "\n")
+
+
+def read_rows(path: Path) -> list[dict]:
+    with path.open() as stream:
+        return [json.loads(line) for line in stream if line.strip()]
+
+
+def indexed(rows: list[dict]) -> dict[str, dict]:
+    result = {}
+    for row in rows:
+        key = row["id"]
+        if key in result:
+            raise ValueError(f"Duplicate ID: {key}")
+        result[key] = row
+    if not result:
+        raise ValueError("Empty evaluation")
+    return result
+
+
+def encode_atoms(atoms: Atoms) -> dict:
+    # Whitelist geometry: never serialize calc, info, site properties, or arrays
+    # such as DFT magnetic moments/charges/forces.
+    return {
+        "numbers": atoms.numbers.tolist(),
+        "positions": atoms.positions.tolist(),
+        "cell": atoms.cell.array.tolist(),
+        "pbc": atoms.pbc.tolist(),
+    }
+
+
+def decode_atoms(data: dict) -> Atoms:
+    required = {"numbers", "positions", "cell", "pbc"}
+    if set(data) != required:
+        raise ValueError(f"Unexpected atomic fields: {set(data) ^ required}")
+    atoms = Atoms(**data)
+    if not len(atoms) or not np.isfinite(atoms.positions).all():
+        raise ValueError("Invalid atomic coordinates")
+    if not np.isfinite(atoms.cell).all() or atoms.get_volume() <= 0:
+        raise ValueError("Invalid unit cell")
+    if not atoms.pbc.all():
+        raise ValueError("Core tasks require fully periodic crystals")
+    return atoms

reproduction/files/0c/0c445f2319b2c3aca9fa1587339f781fbc5000c4c27ee1b478e72b9d9a27538c/validate_fly_verifier.py

@@ -0,0 +1,41 @@
+"""Credential-free real-GPU canary for the adapted Pathfinder prediction boundary."""
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+from fly_boundary import enter,cleanup
+
+root=Path('/workspace/research/run');root.mkdir(parents=True)
+probe='''import os,socket,torch,json
+from pathlib import Path
+assert os.getuid()==10001
+assert not os.access('/private',os.X_OK)
+try:Path('/private/suite/label-canary').read_bytes()
+except PermissionError:pass
+else:raise AssertionError('private label read succeeded')
+try:Path('/operator/.untrusted-write').write_text('bad')
+except PermissionError:pass
+else:raise AssertionError('source write succeeded')
+for family in (socket.AF_INET,socket.AF_INET6):
+ try:s=socket.socket(family,socket.SOCK_STREAM)
+ except PermissionError:pass
+ else:s.close();raise AssertionError('external socket succeeded')
+assert torch.cuda.device_count()==8
+assert all('H100' in torch.cuda.get_device_name(i) for i in range(8))
+assert all(float((torch.ones(4,device=f'cuda:{i}')*2).sum())==8 for i in range(8))
+from pathlib import Path
+Path('rename-a').mkdir();Path('rename-b').mkdir();Path('rename-a/x').write_text('ok')
+Path('rename-a/x').rename('rename-b/x')
+print('FLY_BOUNDARY_GPU_AND_PRIVATE_LABEL_CHECKS_PASSED')
+'''
+try:
+    result=subprocess.run([sys.executable,'-c',probe],cwd=root,preexec_fn=lambda:enter(root),
+        capture_output=True,text=True,timeout=180,check=True)
+    print(result.stdout)
+finally:cleanup()
+Path('/logs/verifier/validation.json').write_text(json.dumps({'passed':True,'valid_benchmark_result':False,
+    'gpus':8,'private_labels_denied':True,'source_write_denied':True,'network_denied':True,
+    'cross_directory_rename_works':True,'native_numerical_pipeline_unchanged':True})+'\n')
+Path('/logs/verifier/reward.json').write_text('{"canary_passed":1}\n')

reproduction/files/0d/0d0cbb759d4e8333988e9bdfdff8a8bccce42cff7b73d1d7ed3b23e0e2d584b5/test_release_contract.py

@@ -0,0 +1,382 @@
+"""Executable release, grading, corruption, and label-isolation contracts."""
+from __future__ import annotations
+import importlib.util
+import io
+import json
+from pathlib import Path
+import sys
+import tarfile
+import zipfile
+import numpy as np
+import pytest
+
+TASK = Path(__file__).resolve().parents[1]
+PROJECT = Path(__file__).resolve().parents[1] / "environment" / "baseline" / "alphaqubit" if (Path(__file__).resolve().parents[1] / "environment" / "baseline" / "alphaqubit").is_dir() else Path(__file__).resolve().parents[1]  # environment/baseline/alphaqubit here, /opt/task in the verifier image
+sys.path.insert(0, str(PROJECT))
+from qecbench.data import SCHEMA, DevelopmentDataset, load_condition, load_manifest, read_npz, sha256, write_json
+from qecbench.scoring import InvalidPrediction, normalize, probabilities, score
+from qecbench.stage_validation import stage
+from baselines.alphaqubit_artifact import EXPECTED_GROUPS
+
+
+def module(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    result = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(result)
+    return result
+
+
+materializer = module("qec_materializer", TASK / "environment/data/materialize.py")
+supervisor = module("qec_supervisor", TASK / "tests/main_verifier.py")
+grader = module("qec_grader", TASK / "tests/grader.py")
+
+
+@pytest.fixture
+def suite(tmp_path: Path):
+    inputs, labels, predictions = (tmp_path / name for name in ("inputs", "labels", "predictions"))
+    for folder in (inputs, labels, predictions):
+        folder.mkdir()
+    rows, targets = [], []
+    for group in EXPECTED_GROUPS:
+        distance, basis = int(group[1]), group[4]
+        center = group.split("center_")[1]
+        for rounds in range(1, 26, 2):
+            name = f"surface_code_b{basis}_d{distance}_r{rounds:02}_center_{center}"
+            folder = inputs / name
+            folder.mkdir()
+            ids = np.array([991, 27, 64, 118], dtype=np.uint64)
+            detectors = np.zeros((4, (rounds * (distance**2 - 1) + 7) // 8), dtype=np.uint8)
+            np.savez(folder / "arrays.npz", sample_ids=ids, detectors=detectors)
+            (folder / "circuit_ideal.stim").write_text("fixture circuit\n")
+            target = np.array([0, 0, 0, 1], dtype=np.uint8)
+            np.savez(labels / f"{name}.npz", sample_ids=ids, labels=target)
+            np.savez(predictions / f"{name}.npz", sample_ids=ids[::-1], probabilities=np.array([1, 0, 0, 0], dtype=np.float32))
+            rows.append({"name": name, "group": group, "distance": distance, "basis": basis, "rounds": rounds,
+                "shots": 4, "num_detectors": rounds * (distance**2 - 1), "arrays": f"{name}/arrays.npz",
+                "arrays_sha256": sha256(folder / "arrays.npz"), "circuit": f"{name}/circuit_ideal.stim",
+                "circuit_sha256": sha256(folder / "circuit_ideal.stim")})
+            targets.append({"name": name, "arrays": f"{name}.npz", "arrays_sha256": sha256(labels / f"{name}.npz")})
+    write_json(inputs / "manifest.json", {"schema": SCHEMA, "split": "test", "conditions": rows})
+    write_json(labels / "manifest.json", {"schema": "surface-code-decoding-labels/v1", "input_manifest_sha256": sha256(inputs / "manifest.json"), "conditions": targets})
+    return inputs, labels, predictions, rows
+
+
+def test_frozen_normalization_anchors():
+    config = json.loads((PROJECT / "score_config.json").read_text())
+    assert normalize(config["lower_bound"], config)["score"] == 0
+    assert normalize(config["upper_bound"], config)["score"] == 1
+    assert normalize(1, config)["score_unclipped"] > 1
+    assert normalize(1, config)["score"] == normalize(1, config)["score_unclipped"]   # no upper clip (v1.1.0)
+    assert normalize(0, config)["score_unclipped"] < 0
+    assert normalize(0, config)["score"] == 0
+
+
+def test_full_suite_reordering_and_perfect_score(suite):
+    inputs, labels, predictions, _ = suite
+    result = score(inputs, predictions, labels, PROJECT / "score_config.json")
+    assert result["shots"] == 520
+    assert result["performance"] == 1
+    assert result["score"] == result["score_unclipped"] > 1   # perfect decoding is above the TN anchor; no upper clip
+    assert result["failure_by_distance"] == {"d3": 0, "d5": 0}
+
+
+def test_missing_prediction_is_invalid_not_infrastructure(suite):
+    inputs, labels, predictions, rows = suite
+    (predictions / f"{rows[0]['name']}.npz").unlink()
+    with pytest.raises(InvalidPrediction):
+        score(inputs, predictions, labels, PROJECT / "score_config.json")
+
+
+@pytest.mark.parametrize("failure", ["nan", "float64", "duplicate", "extra-id", "zip-garbage", "encrypted", "compression"])
+def test_bad_outputs_fail_closed(suite, failure):
+    inputs, _, predictions, rows = suite
+    row = rows[0]
+    ids = load_condition(inputs, row)["sample_ids"]
+    values = np.zeros(4, dtype=np.float32)
+    if failure == "nan":
+        values[0] = np.nan
+    elif failure == "float64":
+        values = values.astype(np.float64)
+    elif failure == "duplicate":
+        ids[1] = ids[0]
+    elif failure == "extra-id":
+        ids[1] += 1
+    path = predictions / f"{row['name']}.npz"
+    np.savez(path, sample_ids=ids, probabilities=values)
+    if failure == "zip-garbage":
+        path.write_bytes(b"not-a-zip")
+    if failure in ("encrypted", "compression"):
+        payload = bytearray(path.read_bytes())
+        for marker, offset in ((b"PK\x03\x04", 6), (b"PK\x01\x02", 8)):
+            cursor = 0
+            while (cursor := payload.find(marker, cursor)) >= 0:
+                payload[cursor + offset + (2 if failure == "compression" else 0)] = 99 if failure == "compression" else 1
+                cursor += 4
+        path.write_bytes(payload)
+    with pytest.raises(InvalidPrediction):
+        probabilities(predictions, row, load_condition(inputs, row)["sample_ids"])
+
+
+def test_trusted_label_corruption_is_infrastructure(suite):
+    inputs, labels, predictions, rows = suite
+    (labels / f"{rows[0]['name']}.npz").write_bytes(b"corrupt")
+    with pytest.raises(ValueError, match="Trusted label checksum"):
+        score(inputs, predictions, labels, PROJECT / "score_config.json")
+
+
+def test_label_free_schema_and_development_split_guard(suite):
+    inputs, _, _, rows = suite
+    row = rows[0]
+    path = inputs / row["arrays"]
+    arrays = load_condition(inputs, row)
+    np.savez(path, **arrays, labels=np.zeros(4, dtype=np.uint8))
+    with pytest.raises(ValueError, match="Wrong array fields"):
+        load_condition(inputs, row)
+    with pytest.raises(ValueError, match="train/validation only"):
+        DevelopmentDataset(inputs, "test")
+
+
+def test_symlink_prediction_rejected(suite, tmp_path):
+    inputs, _, predictions, rows = suite
+    row = rows[0]
+    path = predictions / f"{row['name']}.npz"
+    other = tmp_path / "outside.npz"
+    path.replace(other)
+    path.symlink_to(other)
+    with pytest.raises(InvalidPrediction):
+        probabilities(predictions, row, load_condition(inputs, row)["sample_ids"])
+
+
+def test_npz_bomb_and_forged_shape_rejected(tmp_path):
+    path = tmp_path / "bomb.npz"
+    np.savez_compressed(path, probabilities=np.zeros(100000, dtype=np.float32))
+    with pytest.raises(ValueError, match="expanded content"):
+        read_npz(path, 48)
+    stream = io.BytesIO()
+    np.lib.format.write_array_header_1_0(stream, {"descr": "<f4", "fortran_order": False, "shape": (2**60,)})
+    with zipfile.ZipFile(path, "w") as output:
+        output.writestr("probabilities.npy", stream.getvalue())
+    with pytest.raises(ValueError, match="shape disagrees"):
+        read_npz(path, 48)
+
+
+def test_materializer_rejects_unsafe_tar_before_write(tmp_path):
+    archive = tmp_path / "unsafe.tar.gz"
+    with tarfile.open(archive, "w:gz") as output:
+        item = tarfile.TarInfo("development/../../escaped")
+        item.size = 1
+        output.addfile(item, io.BytesIO(b"x"))
+    with pytest.raises(ValueError, match="Unsafe archive"):
+        materializer.extract(archive, tmp_path / "dest", "development", 10)
+    assert not (tmp_path / "escaped").exists()
+
+
+def test_labeled_validation_staging(suite, tmp_path):
+    inputs, labels, _, rows = suite
+    manifest = json.loads((inputs / "manifest.json").read_text())
+    manifest["split"] = "validation"
+    for row in rows:
+        path = inputs / row["arrays"]
+        arrays = load_condition(inputs, row)
+        np.savez(path, **arrays, labels=np.zeros(4, dtype=np.uint8))
+        row["arrays_sha256"] = sha256(path)
+    manifest["conditions"] = rows
+    write_json(inputs / "manifest.json", manifest)
+    with pytest.raises(ValueError, match="physically label-free"):
+        load_manifest(inputs)
+    output = tmp_path / "stage"
+    stage(inputs, output, limit=3, seed=1, group=rows[0]["group"])
+    staged = load_manifest(output)
+    assert len(staged["conditions"]) == 13
+    assert {row["shots"] for row in staged["conditions"]} == {3}
+    assert set(load_condition(output, staged["conditions"][0])) == {"sample_ids", "detectors"}
+    predictions = tmp_path / "subset-predictions"
+    predictions.mkdir()
+    for row in staged["conditions"]:
+        arrays = load_condition(output, row)
+        np.savez(predictions / f"{row['name']}.npz", sample_ids=arrays["sample_ids"],
+                 probabilities=np.zeros(row["shots"], dtype=np.float32))
+    report = score(output, predictions, inputs, PROJECT / "score_config.json", require_full_suite=False, validation=True)
+    assert report["shots"] == 39 and report["performance"] == 1
+
+
+def test_root_grader_isolation_topology():
+    import tomllib
+    import yaml
+    compose = yaml.safe_load((TASK / "tests/docker-compose.yaml").read_text())
+    for service in compose["services"].values():
+        assert service["network_mode"] == "none"
+    main = compose["services"]["main"]
+    assert main["deploy"]["resources"]["reservations"]["devices"] == [
+        {"driver": "nvidia", "count": 1, "capabilities": ["gpu"]}
+    ]
+    development = yaml.safe_load((TASK / "environment/docker-compose.yaml").read_text())
+    # A Compose network override prevents Harbor's model API allowlist sidecar
+    # from attaching; the runner must apply the default-deny task policy.
+    assert "network_mode" not in development["services"]["main"]
+    assert "networks" not in development["services"]["main"]
+    task = tomllib.loads((TASK / "task.toml").read_text())
+    assert task["environment"]["network_mode"] == "no-network"
+    assert task["verifier"]["environment"]["network_mode"] == "no-network"
+    local = yaml.safe_load((TASK / "tests/docker-compose.local.yaml").read_text())
+    assert "gpus" not in local["services"]["main"]
+    assert all(not isinstance(volume, dict) or volume["target"] != "/private" for volume in main["volumes"])
+    trusted = compose["services"]["grader"]
+    assert any(isinstance(volume, dict) and volume["target"] == "/private" and volume["read_only"] for volume in trusted["volumes"])
+    assert all(not isinstance(volume, dict) or volume["target"] != "/workspace/submission" for volume in trusted["volumes"])
+
+
+def test_infrastructure_failure_emits_no_reward(tmp_path):
+    sealed, out = tmp_path / "sealed", tmp_path / "results"
+    sealed.mkdir()
+    token = "a" * 32
+    grader.grade(sealed, tmp_path / "absent", tmp_path / "private", PROJECT / "score_config.json", out,
+                 {"run_id": token, "snapshot_sha256": "0" * 64})
+    assert json.loads((out / token / "report.json").read_text())["status"] == "infrastructure_error"
+    assert not (out / token / "reward.json").exists()
+
+
+def test_invalid_submission_has_zero_not_missing_reward(tmp_path):
+    supervisor.invalid(tmp_path, "invalid_submission", ValueError("fixture"))
+    assert json.loads((tmp_path / "reward.json").read_text()) == {"reward": 0.0}
+    assert json.loads((tmp_path / "report.json").read_text())["model_quality_measured"] is False
+
+
+def test_submission_manifest_nonobject_rejected(tmp_path):
+    for name in ("infer.sh", "README.md", "requirements.lock"):
+        (tmp_path / name).write_text("fixture")
+    (tmp_path / "model_manifest.json").write_text("[]")
+    with pytest.raises(ValueError, match="Unsupported submission manifest"):
+        supervisor.validate_submission(tmp_path)
+
+
+@pytest.mark.parametrize("case", ["nested-inventory", "symlink-root", "fifo"])
+def test_materializer_exact_existing_inventory(tmp_path, case):
+    root = tmp_path / "development"
+    root.mkdir()
+    write_json(root / "inventory.json", {"schema": "surface-code-decoding-inventory/v1", "files": {}})
+    materializer.verify_role(root)
+    if case == "nested-inventory":
+        (root / "unexpected").mkdir()
+        (root / "unexpected/inventory.json").write_text("undeclared")
+    elif case == "symlink-root":
+        link = tmp_path / "linked"
+        link.symlink_to(root, target_is_directory=True)
+        root = link
+    else:
+        import os
+        os.mkfifo(root / "special")
+    with pytest.raises(ValueError):
+        materializer.verify_role(root)
+
+
+def test_invalid_prediction_does_not_hide_late_infrastructure_corruption(suite):
+    inputs, labels, predictions, rows = suite
+    (predictions / f"{rows[0]['name']}.npz").unlink()
+    (labels / f"{rows[-1]['name']}.npz").write_bytes(b"corrupt")
+    with pytest.raises(ValueError, match="Trusted label checksum"):
+        score(inputs, predictions, labels, PROJECT / "score_config.json")
+
+
+def test_primary_uses_equal_distance_group_duration_weights(suite):
+    inputs, labels, predictions, rows = suite
+    chosen = [next(row for row in rows if row["distance"] == distance) for distance in (3, 5)]
+    for row in chosen:
+        ids = load_condition(inputs, row)["sample_ids"]
+        with np.load(labels / f"{row['name']}.npz", allow_pickle=False) as truth:
+            wrong = 1 - truth["labels"]
+        np.savez(predictions / f"{row['name']}.npz", sample_ids=ids, probabilities=wrong.astype(np.float32))
+    report = score(inputs, predictions, labels, PROJECT / "score_config.json")
+    # One failed duration in one group per distance: d3 has eight groups; d5 two.
+    expected = 0.5 * (1 / (8 * 13) + 1 / (2 * 13))
+    assert report["balanced_logical_failure"] == pytest.approx(expected)
+    assert report["balanced_logical_failure"] != pytest.approx(2 / 130)
+
+
+@pytest.fixture
+def reusable_materialization(tmp_path):
+    import argparse
+    source = tmp_path / "source"
+    role = source / "development"
+    role.mkdir(parents=True)
+    (role / "payload.bin").write_bytes(b"verified data")
+    write_json(role / "inventory.json", {"schema": "surface-code-decoding-inventory/v1", "files": {
+        "payload.bin": {"bytes": 13, "sha256": sha256(role / "payload.bin")}}})
+    archive_root = tmp_path / "archives"
+    archive_root.mkdir()
+    archive = archive_root / "development.tar.gz"
+    lock = tmp_path / "lock.json"
+
+    def publish():
+        with tarfile.open(archive, "w:gz") as tar:
+            for path in sorted(role.iterdir()):
+                # Avoid NSS lookups in gettarinfo on cluster hosts.
+                item = tarfile.TarInfo(f"development/{path.name}")
+                item.size = path.stat().st_size
+                with path.open("rb") as stream:
+                    tar.addfile(item, stream)
+        write_json(lock, {"schema": "surface-code-decoding-hf-release/v1", "release": "fixture",
+            "artifacts": {"development": {"repo_id": "local/fixture", "revision": "0" * 40,
+                "filename": archive.name, "bytes": archive.stat().st_size, "sha256": sha256(archive),
+                "expanded_bytes": sum(path.stat().st_size for path in role.iterdir())}}})
+
+    publish()
+    args = argparse.Namespace(from_sources=False, lock=lock, output=tmp_path / "restored",
+                              roles=["development"], archive_dir=archive_root, cache_dir=None)
+    materializer.run(args)
+    return args, role, publish
+
+
+def test_reuse_skips_payload_extraction(reusable_materialization, monkeypatch):
+    args, _, _ = reusable_materialization
+
+    def forbidden_extract(*args, **kwargs):
+        raise AssertionError("Reused roles must not extract a second payload tree")
+
+    monkeypatch.setattr(materializer, "extract", forbidden_extract)
+    monkeypatch.setattr(materializer.tempfile, "TemporaryDirectory", forbidden_extract)
+    assert materializer.run(args)["status"] == "verified"
+    assert (args.output / "development/payload.bin").read_bytes() == b"verified data"
+    assert not list(args.output.glob(".qec-materialize-*"))
+
+
+def test_reuse_rejects_corrupt_existing_payload(reusable_materialization, monkeypatch):
+    args, _, _ = reusable_materialization
+    (args.output / "development/payload.bin").write_bytes(b"corrupt data!")
+    monkeypatch.setattr(materializer, "extract", lambda *a, **k: pytest.fail("Unexpected extraction"))
+    with pytest.raises(ValueError, match="checksum mismatch"):
+        materializer.run(args)
+
+
+def test_reuse_rejects_different_hash_verified_inventory(reusable_materialization, monkeypatch):
+    args, source, publish = reusable_materialization
+    (source / "payload.bin").write_bytes(b"different release")
+    write_json(source / "inventory.json", {"schema": "surface-code-decoding-inventory/v1", "files": {
+        "payload.bin": {"bytes": 17, "sha256": sha256(source / "payload.bin")}}})
+    publish()  # Lock authenticates this different archive, but the target is old.
+    monkeypatch.setattr(materializer, "extract", lambda *a, **k: pytest.fail("Unexpected extraction"))
+    with pytest.raises(ValueError, match="another release"):
+        materializer.run(args)
+    assert (args.output / "development/payload.bin").read_bytes() == b"verified data"
+
+
+@pytest.mark.parametrize("case", ["symlink", "directory", "oversized", "unsafe-path"])
+def test_archive_inventory_validates_paths_types_and_size(tmp_path, case):
+    archive = tmp_path / "archive.tar.gz"
+    with tarfile.open(archive, "w:gz") as tar:
+        item = tarfile.TarInfo("development/inventory.json")
+        payload = b"{}"
+        if case == "symlink":
+            item.type = tarfile.SYMTYPE
+            item.linkname = "outside"
+        elif case == "directory":
+            item.type = tarfile.DIRTYPE
+        else:
+            item.size = len(payload)
+        tar.addfile(item, io.BytesIO(payload) if item.isfile() else None)
+        if case == "unsafe-path":
+            other = tarfile.TarInfo("development/../outside")
+            other.size = 1
+            tar.addfile(other, io.BytesIO(b"x"))
+    with pytest.raises(ValueError):
+        materializer.archive_inventory(archive, "development", 1 if case == "oversized" else 100)

reproduction/files/0e/0e6e92803a5e581475f687f0ee03bfcab81c170775957d28668fd632a14c3e1b/benchmark_score.py

@@ -0,0 +1,27 @@
+"""Versioned benchmark normalization shared by development and trusted grading."""
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+BOUNDS = json.loads(Path(__file__).with_name("score_bounds.json").read_text())
+
+
+def normalize(performance: float) -> dict[str, Any]:
+    """Normalize Hit@1 against fixed reference anchors, preserving overperformance."""
+    if isinstance(performance, bool) or not math.isfinite(performance) or not 0 <= performance <= 1:
+        raise ValueError("Hit@1 must be a finite number in [0, 1]")
+    lower, upper = BOUNDS["lower"], BOUNDS["upper"]
+    if not 0 <= lower < upper <= 1:
+        raise ValueError("invalid benchmark score anchors")
+    unclipped = (performance - lower) / (upper - lower)
+    return {
+        "version": BOUNDS["version"], "metric": BOUNDS["metric"],
+        "direction": BOUNDS["direction"], "raw_performance": performance,
+        "lower_reference": lower, "upper_reference": upper,
+        "score": min(1.0, max(0.0, unclipped)), "unclipped_score": unclipped,
+        "saturation": "lower" if unclipped < 0 else "upper" if unclipped > 1 else None,
+        "at_or_above_upper_reference": performance >= upper,
+    }

reproduction/files/0e/0e79954672aa8606568a564fd0e1f8ceb76bfbdac6fda2eadea7650396b6de06/test_policy_isolation.py

@@ -0,0 +1,101 @@
+"""A root-run evaluator must drop the submitted policy to an unprivileged, short-lived process."""
+import os
+from pathlib import Path
+import sys
+import tempfile
+import time
+import unittest
+from unittest.mock import patch
+ISOLATED = {'HYDROGYM_POLICY_ISOLATION': '1'}
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'environment/evaluation'))
+import protocol
+from protocol import InfrastructureError, Policy
+
+POLICY = r'''
+import json, os, subprocess, sys
+target = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "target.txt")).read().strip()
+try:
+    open(target, "w").write("forged")
+except OSError as error:
+    sys.stderr.write("write-denied %s\n" % type(error).__name__)
+sys.stderr.write("uid=%d\n" % os.getuid()); sys.stderr.flush()
+subprocess.Popen(["setsid", "sleep", "300"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+for line in sys.stdin:
+    request = json.loads(line)
+    reply = {"protocol": request["protocol"], "request_id": request["request_id"]}
+    reply.update({"reset": {"ready": True}, "act": {"action": [0.0]}, "close": {"closed": True}}[request["op"]])
+    print(json.dumps(reply), flush=True)
+    if request["op"] == "close":
+        break
+'''
+
+
+def account_exists():
+    try:
+        import pwd
+        pwd.getpwuid(protocol.POLICY_UID)
+        return True
+    except KeyError:
+        return False
+
+
+class IsolationSwitchTests(unittest.TestCase):
+    def test_isolation_is_off_unless_requested(self):
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop('HYDROGYM_POLICY_ISOLATION', None)
+            self.assertIsNone(protocol.policy_account())
+
+    @unittest.skipIf(os.geteuid() == 0, 'checks the non-root refusal')
+    def test_requested_isolation_refuses_non_root(self):
+        with patch.dict(os.environ, ISOLATED), self.assertRaises(InfrastructureError):
+            protocol.policy_account()
+
+    def test_verifier_requests_isolation_offline(self):
+        here = Path(__file__).resolve().parents[1]
+        self.assertIn('export HYDROGYM_POLICY_ISOLATION=1', (here / 'tests/test.sh').read_text())
+        self.assertIn('network_mode: none', (here / 'tests/docker-compose.yaml').read_text())
+
+
+@unittest.skipUnless(os.geteuid() == 0 and account_exists(), 'needs root and the policy account (task image)')
+class PolicyIsolationTests(unittest.TestCase):
+    def test_policy_runs_unprivileged_cannot_write_results_and_leaves_no_process(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            os.chmod(root, 0o755)
+            package = root / 'package'; package.mkdir(); os.chmod(package, 0o755)
+            (package / 'policy.py').write_text(POLICY)
+            (package / 'infer.sh').write_text('exec python3 "$(dirname "$0")/policy.py"\n')
+            results = root / 'results'; results.mkdir(mode=0o755)
+            forged = results / 'reward.json'
+            (package / 'target.txt').write_text(str(forged))
+            for path in package.iterdir():
+                path.chmod(0o444)
+            with patch.dict(os.environ, ISOLATED):
+                policy = Policy(package, root / 'policy.log', timeout=20)
+            policy.reset({'environment': 'x', 'family': 'x', 'seed': 1}, [1], [1], [-1.0], [1.0])
+            self.assertEqual(policy.act([0.5]), [0.0])
+            policy.close()
+            log = (root / 'policy.log').read_text()
+            self.assertIn(f'uid={protocol.POLICY_UID}', log)
+            self.assertIn('write-denied PermissionError', log)
+            self.assertFalse(forged.exists())
+            time.sleep(0.5)
+            def alive(proc):  # killed children re-parented to a non-reaping PID 1 stay as zombies
+                try:
+                    return proc.stat().st_uid == protocol.POLICY_UID and \
+                        (proc / 'stat').read_text().rsplit(')', 1)[1].split()[0] != 'Z'
+                except FileNotFoundError:
+                    return False
+            owners = [p for p in Path('/proc').iterdir() if p.name.isdigit() and alive(p)]
+            self.assertEqual(owners, [])
+
+    def test_missing_account_fails_closed(self):
+        with tempfile.TemporaryDirectory() as tmp, patch.object(protocol, 'POLICY_UID', 54321), \
+                patch.dict(os.environ, ISOLATED):
+            with self.assertRaises(InfrastructureError):
+                Policy(Path(tmp), Path(tmp) / 'policy.log', timeout=5)
+
+
+if __name__ == '__main__':
+    unittest.main()

reproduction/files/11/110a51b699d57fd0239157173866513fab41f5d1ceeb6208bc2466bfa942486f/test_prepare_hf.py

@@ -0,0 +1,211 @@
+"""Offline integrity and split-isolation checks for HF preparation."""
+
+import hashlib
+import io
+import json
+from pathlib import Path
+import sys
+import tarfile
+import tempfile
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "environment/data"))
+from prepare_hf import (
+    copy_stream,
+    prepare_pretraining,
+    prepare_windows,
+    safe_path,
+    verify,
+)
+
+
+def archive(path, rows):
+    with tarfile.open(path, "w") as tar:
+        for name, data in rows:
+            data = data.encode()
+            m = tarfile.TarInfo(name)
+            m.size = len(data)
+            tar.addfile(m, io.BytesIO(data))
+
+
+class PreparationTests(unittest.TestCase):
+    def test_manifest_paths(self):
+        for name in ["../escape", "/absolute", "a/../../b", "a\\b"]:
+            with self.assertRaises(ValueError):
+                safe_path(name)
+        self.assertEqual(str(safe_path("archives/train.tar")), "archives/train.tar")
+
+    def test_checksum_and_size(self):
+        with tempfile.TemporaryDirectory() as t:
+            p = Path(t) / "data"
+            p.write_bytes(b"abc")
+            entry = dict(path="data", size=3, sha256=hashlib.sha256(b"abc").hexdigest())
+            verify(p, entry)
+            p.write_bytes(b"abd")
+            with self.assertRaises(ValueError):
+                verify(p, entry)
+
+    def test_resume_must_match(self):
+        with tempfile.TemporaryDirectory() as t:
+            p = Path(t) / "data"
+            copy_stream(io.BytesIO(b"abc"), p)
+            copy_stream(io.BytesIO(b"abc"), p)
+            for value in [b"ab", b"abcd", b"xyz"]:
+                with self.assertRaises(ValueError):
+                    copy_stream(io.BytesIO(value), p)
+            self.assertEqual(p.read_bytes(), b"abc")
+
+    def test_selected_aliases_and_exclusions(self):
+        with tempfile.TemporaryDirectory() as t:
+            p = Path(t)
+            archive(
+                p / "a.tar",
+                [("root/sample_9.h5", "selected"), ("root/sample_3.h5", "excluded")],
+            )
+            selection = dict(
+                source_samples=2,
+                kept=1,
+                samples=[dict(sample_index=0, source="sample_9.h5")],
+                excluded=["sample_3.h5"],
+            )
+            self.assertEqual(
+                prepare_pretraining([p / "a.tar"], selection, p / "out"), 1
+            )
+            self.assertEqual((p / "out/sample_0.h5").read_text(), "selected")
+            self.assertEqual(len(list((p / "out").iterdir())), 1)
+            self.assertEqual(
+                prepare_pretraining([p / "a.tar"], selection, p / "out"), 1
+            )
+            with self.assertRaises(ValueError):
+                prepare_pretraining([p / "a.tar", p / "a.tar"], selection, p / "out")
+
+    def test_missing_selected_member(self):
+        with tempfile.TemporaryDirectory() as t:
+            p = Path(t)
+            archive(p / "a.tar", [])
+            selection = dict(
+                source_samples=1,
+                kept=1,
+                samples=[dict(sample_index=0, source="sample_9.h5")],
+                excluded=[],
+            )
+            with self.assertRaises(ValueError):
+                prepare_pretraining([p / "a.tar"], selection, p / "out")
+
+    def test_native_trainval_payload_before_metadata(self):
+        with tempfile.TemporaryDirectory() as t:
+            p = Path(t)
+            rows = [("dataset/config.json", "{}")]
+            for split in ["train", "val", "test"]:
+                prefix = f"dataset/windows/spatial_split/{split}"
+                rows.extend(
+                    [
+                        (prefix + "/layers/label/value", "label-" + split),
+                        (
+                            prefix + "/metadata.json",
+                            json.dumps({"options": {"split": split}}),
+                        ),
+                    ]
+                )
+            archive(p / "a.tar", rows)
+            expected = {"train": 1, "val": 1, "test": 1}
+            report = prepare_windows(p / "a.tar", p / "out", expected)
+            self.assertFalse(report["heldout_window_payloads_read"])
+            self.assertFalse((p / "out/windows/spatial_split/test").exists())
+            self.assertTrue(
+                (p / "out/windows/spatial_split/train/layers/label/value").exists()
+            )
+            self.assertEqual(
+                prepare_windows(p / "a.tar", p / "out", expected)["files"], 5
+            )
+            with self.assertRaises(ValueError):
+                prepare_windows(
+                    p / "a.tar", p / "other", {"train": 2, "val": 1, "test": 1}
+                )
+
+    def test_unsafe_archive_member(self):
+        with tempfile.TemporaryDirectory() as t:
+            p = Path(t)
+            archive(p / "a.tar", [("../sample_9.h5", "x")])
+            selection = dict(
+                source_samples=1,
+                kept=1,
+                samples=[dict(sample_index=0, source="sample_9.h5")],
+                excluded=[],
+            )
+            with self.assertRaises(ValueError):
+                prepare_pretraining([p / "a.tar"], selection, p / "out")
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+class DownloadPipelineTests(unittest.TestCase):
+    def test_hub_revision_pin_and_component_selection(self):
+        from types import SimpleNamespace
+        from unittest.mock import patch
+        import prepare_hf
+
+        with tempfile.TemporaryDirectory() as t:
+            root = Path(t)
+            snapshot = root / "snapshot"
+            snapshot.mkdir()
+            payload = snapshot / "inputs"
+            payload.write_bytes(b"fixture")
+            entries = [
+                dict(
+                    path="eval/awf/inputs.h5",
+                    size=7,
+                    sha256=hashlib.sha256(b"fixture").hexdigest(),
+                    components=["probe"],
+                ),
+                dict(
+                    path="archives/unused.tar",
+                    size=99,
+                    sha256="0" * 64,
+                    components=["pretrain"],
+                ),
+            ]
+            (snapshot / "manifest.json").write_text(
+                json.dumps(dict(schema_version=1, files=entries))
+            )
+            calls = []
+            revision = "a" * 40
+
+            def download(repo, name, **kwargs):
+                calls.append((repo, name, kwargs["revision"]))
+                return str(
+                    snapshot / "manifest.json" if name == "manifest.json" else payload
+                )
+
+            hub = SimpleNamespace(
+                HfApi=lambda: SimpleNamespace(
+                    dataset_info=lambda *args, **kwargs: SimpleNamespace(sha=revision)
+                ),
+                hf_hub_download=download,
+            )
+            args = [
+                "prepare_hf",
+                "--repo",
+                "example/data",
+                "--revision",
+                "v1",
+                "--output",
+                str(root / "output"),
+                "--components",
+                "probe",
+            ]
+            with (
+                patch.dict(sys.modules, {"huggingface_hub": hub}),
+                patch.object(sys, "argv", args),
+            ):
+                prepare_hf.main()
+                prepare_hf.main()
+            self.assertEqual(
+                (root / "output/eval/awf/inputs.h5").read_bytes(), b"fixture"
+            )
+            self.assertTrue(all(r == revision for _, _, r in calls))
+            self.assertNotIn("archives/unused.tar", [n for _, n, _ in calls])
+            report = json.loads((root / "output/hf-prepared.json").read_text())
+            self.assertEqual(report["revision"], revision)

reproduction/files/12/12033212bd52ab4a3c31643ee1434fdf4b84489b59feb62322cba2c56c127ff2/replay.py

@@ -0,0 +1,56 @@
+"""Run exported model in a filesystem/network-isolated process."""
+
+import argparse
+import errno
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import sys
+
+checks = Path(__file__).resolve().parents[1] / "environment/evaluation"
+if not checks.is_dir():
+    checks = Path(__file__).resolve().parent
+if not (checks / "package_contract.py").is_file():
+    checks = Path("/evaluation")
+sys.path.insert(0, str(checks))
+from package_contract import InvalidSubmission, validate_features
+from namespace import command, direct
+
+p = argparse.ArgumentParser()
+p.add_argument("--model", type=Path, required=True)
+p.add_argument("--input", type=Path, required=True)
+p.add_argument("--output", type=Path, required=True)
+p.add_argument("--no-namespace", action="store_true",
+               help="development only: run without Bubblewrap where user namespaces are unavailable")
+a = p.parse_args()
+a.output.mkdir(parents=True, exist_ok=True)
+# Only unlabeled pixels and an empty output directory enter model execution.
+# Previous scores/predictions in the destination are never mounted.
+with tempfile.TemporaryDirectory(prefix="olmo-replay-", dir=a.output) as temp:
+    workspace = Path(temp)
+    inputs = workspace / "input"
+    inputs.mkdir()
+    outputs = workspace / "output"
+    outputs.mkdir()
+    dst = inputs / "inputs.h5"
+    try:
+        dst.hardlink_to(a.input)
+    except OSError as exc:
+        if exc.errno not in (errno.EXDEV, errno.EPERM, errno.EACCES):
+            raise
+        shutil.copyfile(a.input, dst)
+    if a.no_namespace:
+        argv, environment = direct(a.model.resolve(), inputs.resolve(), outputs.resolve())
+        subprocess.run(argv, check=True, env=environment, cwd=a.model.resolve())
+    else:
+        subprocess.run(
+            command(a.model.resolve(), inputs.resolve(), outputs.resolve()), check=True
+        )
+    result = outputs / "features.npz"
+    try:
+        validate_features(result, a.input)
+    except InvalidSubmission as error:
+        print(str(error), file=sys.stderr)
+        raise SystemExit(42)
+    result.replace(a.output / "features.npz")

reproduction/files/13/13b471d6183aced98dc4c168348cdfe26bd35c28f03f2e06f9da94345dfc7d12/run_local.py

@@ -0,0 +1,92 @@
+"""Run the physical suites (discovery, phonons, elasticity) on local GPUs.
+
+One worker process per GPU pulls chunks from distributed.chunk_plan, writes each chunk with
+predict.run, and distributed.merge assembles and checks the complete run:
+
+    python run_local.py --inputs CASES.jsonl --artifact MODEL.pt [--energy-audit AUDIT.json] \
+        --output OUT_DIR [--gpus 0,1,2,3] [--factory uma|module:function]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import multiprocessing as mp
+import os
+import socket
+import time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+
+
+def _worker(gpu, queue, args, chunk_root):
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
+    import sys
+    sys.path.insert(0, str(HERE))
+    from common import write_rows
+    import predict
+    calculator = predict.load_calculator(args.factory, args.artifact, "cuda")
+    while True:
+        item = queue.get()
+        if item is None:
+            return
+        chunk, rows = item
+        directory = chunk_root / chunk["chunk_id"]
+        if (directory / "worker.json").exists():
+            continue
+        staging = chunk_root / f".{chunk['chunk_id']}.tmp"
+        staging.mkdir(parents=True, exist_ok=True)
+        write_rows(staging / "inputs.jsonl", rows)
+        started = time.monotonic()
+        predict.run(staging / "inputs.jsonl", staging / "out", args.factory, args.artifact, "cuda",
+                    args.energy_audit, calculator=calculator, verbose=False)
+        for name in ("run.json", "predictions.jsonl"):
+            (staging / "out" / name).rename(staging / name)
+        (staging / "out").rmdir()
+        (staging / "worker.json").write_text(json.dumps({
+            "worker_id": f"{socket.gethostname()}-gpu{gpu}", "chunk_id": chunk["chunk_id"],
+            "chunk_input_sha256": chunk["input_sha256"], "seconds": time.monotonic() - started}))
+        staging.rename(directory)
+        print(json.dumps({"chunk": chunk["chunk_id"], "gpu": gpu}), flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--inputs", type=Path, required=True)
+    parser.add_argument("--artifact", type=Path, required=True)
+    parser.add_argument("--energy-audit", type=Path)
+    parser.add_argument("--factory", default="uma")
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--gpus", default=os.environ.get("CUDA_VISIBLE_DEVICES", "0"))
+    args = parser.parse_args()
+    import sys
+    sys.path.insert(0, str(HERE))
+    from common import digest, indexed, read_rows
+    from distributed import chunk_plan, merge
+    cases = read_rows(args.inputs)
+    by_id = indexed(cases)
+    plan = chunk_plan(cases)
+    chunk_root = args.output.parent / f"{args.output.name}.chunks"
+    chunk_root.mkdir(parents=True, exist_ok=True)
+    ctx = mp.get_context("spawn")
+    queue = ctx.Queue()
+    for chunk in plan:
+        queue.put((chunk, [by_id[key] for key in chunk["case_ids"]]))
+    gpus = [g for g in args.gpus.split(",") if g != ""]
+    for _ in gpus:
+        queue.put(None)
+    procs = [ctx.Process(target=_worker, args=(g, queue, args, chunk_root)) for g in gpus]
+    for p in procs:
+        p.start()
+    for p in procs:
+        p.join()
+    # Chunks left by a crashed worker must not block interpreter exit on the queue's feeder thread.
+    queue.cancel_join_thread()
+    failed = [p.exitcode for p in procs if p.exitcode]
+    if failed:
+        raise SystemExit(f"worker failed with exit code {failed[0]}")
+    merge(args.inputs, chunk_root, plan, args.output, digest(args.artifact))
+
+
+if __name__ == "__main__":
+    main()

reproduction/files/15/154b329ae33e35d2e254590344f029ae4b85350111b0a9a00f0e95019db0ff25/test_scaffold.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+
+import numpy as np
+
+
+TASK_ROOT = Path(__file__).resolve().parents[1]
+ENVIRONMENT = TASK_ROOT / "environment"
+DELPHI = ENVIRONMENT / "references" / "delphi"
+
+
+def test_task_metadata_is_versioned() -> None:
+    metadata = (TASK_ROOT / "task.toml").read_text(encoding="utf-8")
+    assert 'name = "ai4sci/natural-disease-progression"' in metadata
+    assert 'input_schema = "natural-disease-progression-input/v2"' in metadata
+
+
+def test_task_layers_exist() -> None:
+    assert (ENVIRONMENT / "data" / "README.md").is_file()
+    assert (ENVIRONMENT / "references" / "scaffold" / "data.py").is_file()
+    assert (ENVIRONMENT / "references" / "scaffold" / "predict.py").is_file()
+    assert (ENVIRONMENT / "baseline" / "temporal-gru" / "longitudinal.py").is_file()
+    assert (ENVIRONMENT / "evaluation" / "score.py").is_file()
+
+
+def test_agent_surface_is_neural_architecture_development() -> None:
+    instruction = (TASK_ROOT / "instruction.md").read_text(encoding="utf-8")
+    contract = (ENVIRONMENT / "contract.md").read_text(encoding="utf-8")
+    dockerfile = (ENVIRONMENT / "Dockerfile").read_text(encoding="utf-8")
+    assert "neural architecture development track" in instruction
+    assert "does not obtain its final predictions from LightGBM" in instruction
+    assert "fixed population time scaling" in contract
+    assert "COPY starter /workspace/starter" not in dockerfile
+    assert "COPY data /workspace/data" not in dockerfile
+    assert "maintenance" not in dockerfile
+    assert "starter/tabular_baseline.py" not in dockerfile
+
+
+def test_real_evaluator_is_present() -> None:
+    source = (ENVIRONMENT / "evaluation" / "score.py").read_text()
+    assert "from risk_scoring import score" in source
+    assert "panel_scoring" in source
+
+
+def test_verifier_separates_public_and_trusted_inputs() -> None:
+    main = (TASK_ROOT / "tests" / "main_verifier.py").read_text()
+    grader = (TASK_ROOT / "tests" / "grader.py").read_text()
+    assert "--trusted" not in main
+    assert "--trusted" in grader
+
+
+def test_harbor_entry_runs_inference_not_unit_tests() -> None:
+    entry = (TASK_ROOT / "tests" / "test.sh").read_text()
+    assert "main_verifier.py" in entry
+    assert "pytest" not in entry
+    assert "/logs/verifier" in (TASK_ROOT / "tests" / "main_verifier.py").read_text()
+
+
+def test_verifier_requires_review_readme_without_claiming_architecture_detection() -> None:
+    main = (TASK_ROOT / "tests" / "main_verifier.py").read_text(encoding="utf-8")
+    assert "submission/README.md is required for architecture review" in main
+    assert "cannot establish that infer.sh actually uses" in main
+
+
+def test_verifier_main_installs_official_starter_inference_dependencies() -> None:
+    dockerfile = (TASK_ROOT / "tests" / "Dockerfile").read_text(encoding="utf-8")
+    for dependency in ("lightgbm==4.6.0", "joblib==1.5.3"):
+        assert dependency in dockerfile
+
+
+def test_compose_mounts_do_not_expose_materialization_roots() -> None:
+    development = (ENVIRONMENT / "docker-compose.yaml").read_text()
+    verifier = (TASK_ROOT / "tests" / "docker-compose.yaml").read_text()
+    # task.toml owns the network policy (TASK_STANDARD); the compose file must not override it.
+    assert "network_mode" not in development
+    assert 'network_mode = "no-network"' in (TASK_ROOT / "task.toml").read_text()
+    assert "target: /workspace/data/train" in development
+    assert "target: /workspace/data/public/validation" in development
+    assert "target: /workspace/data/trusted/validation" in development
+    assert "target: /data" not in development
+    assert "/public/test" in verifier
+    assert "target: /trusted/test" in verifier
+    assert "target: /input" in verifier
+    assert "target: /trusted\n" not in verifier
+
+
+def test_delphi_demo_data_has_uint32_triples() -> None:
+    for split in ("train", "val"):
+        data = np.memmap(DELPHI / "data" / "ukb_simulated_data" / f"{split}.bin", dtype=np.uint32, mode="r")
+        assert data.size > 0
+        assert data.size % 3 == 0
+
+
+def test_vendored_python_compiles() -> None:
+    for name in ("model.py", "train.py", "utils.py", "configurator.py"):
+        source = (DELPHI / name).read_text(encoding="utf-8")
+        compile(source, str(DELPHI / name), "exec")

reproduction/files/15/1553aceb037cf137db93f3156f0bb339ca179b773e58552a6400ad51b1699538/main_verifier.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""Run the submitted calculator through every test suite as uid 10001 and seal the predictions.
+
+All suites run at the same time, each with its own workers spread over every visible GPU, inside one
+shared time budget: physical (WBM discovery, MDR phonons, MP elasticity) with run_local.py, and
+thermal conductivity, MOF bulk modulus, amorphous AM26, cleavage and Li-migration NEB with extra.py.
+The long-tailed suites (MOF, NEB) get the most workers and start their most expensive items first. The evaluator code
+drives every relaxation, displacement and strain; the submission only supplies the calculator.
+At the shared time limit (3 h by default) every suite stops: the cases it finished are kept and the
+rest are scored as failures. A suite that crashes is sealed as it is: the grader scores its missing
+cases as failures (extra suites) or marks the suite invalid (physical suites).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pwd
+import shutil
+import signal
+import stat
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from verifier_common import sha256, tree_sha256, write_json
+
+EVALUATION = Path("/evaluation") if Path("/evaluation").is_dir() else Path(__file__).resolve().parents[1] / "environment/evaluation"
+EXTRA_SUITES = ("kappa", "mof", "amorphous", "cleavage", "neb")
+SUITES = ("physical",) + EXTRA_SUITES
+SCHEMA = "atomistic-materials-prediction-snapshot/v2"
+MAX_SNAPSHOT_BYTES = 8 * 1024 ** 3
+# Workers per GPU for each suite when they all run at once. MOF (EOS of large cells) and NEB (relaxed end
+# points, then a climbing-image band) dominate the wall time, so they get the most workers; relaxations
+# and phono3py leave a single worker's GPU mostly idle.
+WORKERS_PER_GPU = {"physical": 2, "kappa": 2, "mof": 4, "amorphous": 1, "cleavage": 1, "neb": 3}
+
+
+def harbor_reward(values):
+    """Harbor parses reward.json as a flat object of finite numbers; strings, None and nested details
+    belong in report.json / status.json."""
+    import math as _math
+    return {k: v for k, v in values.items() if isinstance(v, (int, float)) and _math.isfinite(v)}
+
+
+def validate_submission(root: Path):
+    root = root.resolve()
+    entry = root / "calculator.py"
+    if not entry.is_file() or entry.is_symlink():
+        raise FileNotFoundError("submission/calculator.py required")
+    for path in root.rglob("*"):
+        if path.is_symlink() and not path.resolve().is_relative_to(root):
+            raise ValueError(f"submission symlink escapes package: {path.relative_to(root)}")
+
+
+def validate_input(root: Path):
+    for suite in SUITES:
+        inputs = root / suite / "inputs"
+        if not inputs.is_dir():
+            raise FileNotFoundError(f"missing verifier input: {inputs}")
+        if any(p.name.startswith(("references", "targets")) for p in (root / suite).rglob("*")):
+            raise ValueError(f"untrusted input contains references: {suite}")
+
+
+def gpu_ids():
+    if os.environ.get("CUDA_VISIBLE_DEVICES"):
+        return os.environ["CUDA_VISIBLE_DEVICES"]
+    out = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True).stdout
+    return ",".join(str(i) for i in range(max(1, sum(line.startswith("GPU ") for line in out.splitlines()))))
+
+
+def command(suite, inputs, submission, output, gpus):
+    py = "/opt/venv/bin/python"
+    if suite == "physical":
+        return [py, str(EVALUATION / "run_local.py"), "--inputs", str(inputs / "cases.jsonl"), "--factory", "submission",
+                "--artifact", str(submission), "--output", str(output), "--gpus", gpus]
+    return [py, str(EVALUATION / "extra.py"), "run", "--suite", suite, "--inputs", str(inputs), "--factory", "submission",
+            "--artifact", str(submission), "--output", str(output), "--gpus", gpus]
+
+
+def _agent_processes(uid):
+    result = []
+    for entry in Path("/proc").iterdir():
+        if not entry.name.isdigit():
+            continue
+        try:
+            status = (entry / "status").read_text()
+            real_uid = int(next(line for line in status.splitlines() if line.startswith("Uid:")).split()[1])
+            state = next(line for line in status.splitlines() if line.startswith("State:")).split()[1]
+        except (FileNotFoundError, PermissionError, StopIteration, ValueError):
+            continue
+        if real_uid == uid and state != "Z":
+            result.append(int(entry.name))
+    return result
+
+
+def _stop_untrusted(uid):
+    # SIGKILLed GPU workers can take tens of seconds to exit while the driver tears down their CUDA
+    # contexts (seen at the time limit, with ~100 workers killed at once).
+    deadline = time.monotonic() + 180
+    while True:
+        for pid in _agent_processes(uid):
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+        remaining = _agent_processes(uid)
+        if not remaining:
+            return
+        if time.monotonic() >= deadline:
+            raise RuntimeError(f"untrusted processes survived cleanup: {remaining}")
+        time.sleep(0.05)
+
+
+def run_suite(suite, args, work, gpus, timeout):
+    agent = pwd.getpwnam("agent")
+    output = work / suite
+    env = {"PATH": "/opt/venv/bin:/usr/local/bin:/usr/bin:/bin", "HOME": agent.pw_dir, "PYTHONUNBUFFERED": "1",
+           "PIP_NO_INDEX": "1", "HF_HUB_OFFLINE": "1", "OMP_NUM_THREADS": "2",
+           # Many workers share each GPU; fewer fragmented blocks means fewer out-of-memory retries.
+           "PYTORCH_CUDA_ALLOC_CONF": "expandable_segments:True"}
+
+    def demote():
+        os.setgid(agent.pw_gid)
+        os.setuid(agent.pw_uid)
+    started = time.monotonic()
+    status = "complete"
+    with (work / f"{suite}.log").open("wb") as log:
+        process = subprocess.Popen(command(suite, args.input / suite / "inputs", args.submission, output, gpus),
+                                   cwd=work, env=env, stdout=log, stderr=subprocess.STDOUT,
+                                   start_new_session=True, preexec_fn=demote)
+        try:
+            code = process.wait(timeout=max(1, timeout))
+            if code:
+                status = f"exit {code}"
+        except subprocess.TimeoutExpired:
+            status = "timeout"
+        finally:
+            # Only this suite's process group: the other suites are still running as the same user.
+            # Anything that left the group is killed by the user-wide sweep after the last suite.
+            try:
+                os.killpg(process.pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            if process.poll() is None:
+                process.wait()
+    return {"suite": suite, "status": status, "seconds": round(time.monotonic() - started, 1)}
+
+
+def close_unfinished(suite, args, work):
+    """After the shared time limit: keep what a suite finished and mark the rest as failed cases.
+
+    Physical: merge the finished chunks; the cases of unfinished chunks become failed records.
+    Extra suites: write the run record the driver would have written; items without a file are
+    scored as failures by score_extra."""
+    import sys
+    sys.path.insert(0, str(EVALUATION))
+    from common import digest, read_rows
+    reason = "verifier time limit reached"
+    output = work / suite
+    if suite == "physical":
+        from distributed import chunk_plan, merge
+        if (output / "run.json").exists():
+            return
+        inputs = args.input / suite / "inputs" / "cases.jsonl"
+        merge(inputs, work / "physical.chunks", chunk_plan(read_rows(inputs)), output, digest(args.submission),
+              unfinished_reason=reason)
+        return
+    if (output / "run.json").exists():
+        return
+    import hashlib
+    done = len(list((output / "items").glob("*.json"))) if (output / "items").is_dir() else 0
+    manifest = args.input / suite / "inputs" / "manifest.json"
+    write_json(output / "run.json", {
+        "protocol": "atomistic-extra-suites-v1", "suite": suite,
+        "inputs_manifest_sha256": hashlib.sha256(manifest.read_bytes()).hexdigest(),
+        "checkpoint_sha256": digest(args.submission), "factory": "submission",
+        "completed": done, "complete": False, "unfinished_reason": reason})
+
+
+def _copy_snapshot(source: Path, destination: Path):
+    keep = ["run.json", "predictions.jsonl"] if (source / "predictions.jsonl").exists() else None
+    destination.mkdir(parents=True)
+    if not source.exists():
+        return
+    for path in source.rglob("*"):
+        mode = path.lstat().st_mode
+        if path.is_symlink() or not (stat.S_ISREG(mode) or stat.S_ISDIR(mode)):
+            raise ValueError(f"prediction output contains non-regular entry: {path.relative_to(source)}")
+    if keep:
+        for name in keep:
+            shutil.copyfile(source / name, destination / name)
+    else:
+        for name in ("run.json",):
+            if (source / name).is_file():
+                shutil.copyfile(source / name, destination / name)
+        if (source / "items").is_dir():
+            shutil.copytree(source / "items", destination / "items")
+
+
+def _lock(root: Path):
+    for path in sorted(root.rglob("*"), reverse=True):
+        os.chown(path, 0, 0, follow_symlinks=False)
+        os.chmod(path, 0o500 if path.is_dir() else 0o400, follow_symlinks=False)
+    os.chown(root, 0, 0)
+    os.chmod(root, 0o500)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    p.add_argument("--submission", type=Path, required=True)
+    p.add_argument("--input", type=Path, required=True)
+    p.add_argument("--sealed", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True)
+    p.add_argument("--timeout", type=int, default=10800, help="shared limit for all suites (s)")
+    p.add_argument("--grader-timeout", type=int, default=7200)
+    p.add_argument("--suites", default=",".join(SUITES))
+    p.add_argument("--workers-per-gpu", type=int, default=0, help="same for every suite (default: WORKERS_PER_GPU)")
+    p.add_argument("--no-wait", action="store_true")
+    a = p.parse_args()
+    a.output.mkdir(parents=True, exist_ok=True)
+    try:
+        validate_submission(a.submission)
+        validate_input(a.input)
+    except (FileNotFoundError, ValueError) as error:
+        # The package, not the verifier, failed: every metric is unavailable and the run scores 0.
+        from grader import expanded_score, flatten
+        aggregate = expanded_score({}, valid=False)
+        write_json(a.output / "report.json", {"status": "invalid_submission", "error": str(error)[:2000],
+                                              "aggregate": aggregate})
+        write_json(a.output / "reward.json", harbor_reward({"reward": 0.0, "crystal_potential_score": 0.0,
+                                                            "invalid_submission": True, **flatten({})}))
+        return
+    work = a.output / "main"
+    work.mkdir()
+    agent = pwd.getpwnam("agent")
+    os.chown(work, agent.pw_uid, agent.pw_gid)
+    os.chmod(work, 0o700)
+    # The untrusted user reads a private copy of the package, whatever the snapshot's ownership.
+    package = work / "submission"
+    shutil.copytree(a.submission, package, symlinks=True)
+    for path in [package, *package.rglob("*")]:
+        os.chown(path, agent.pw_uid, agent.pw_gid, follow_symlinks=False)
+    a.submission = package
+    # Label-free inputs, likewise copied so their host permissions cannot block the untrusted user.
+    inputs = work / "inputs"
+    shutil.copytree(a.input, inputs)
+    for path in [inputs, *inputs.rglob("*")]:
+        os.chmod(path, 0o555 if path.is_dir() else 0o444)
+    original_input, a.input = a.input, inputs
+    devices = gpu_ids().split(",")
+    deadline = time.monotonic() + a.timeout
+    suites = a.suites.split(",")
+
+    def launch(suite):
+        per_gpu = a.workers_per_gpu or WORKERS_PER_GPU[suite]
+        run = run_suite(suite, a, work, ",".join(devices * per_gpu), int(deadline - time.monotonic()))
+        print(json.dumps({"event": "suite_done", "workers": per_gpu * len(devices), **run}), flush=True)
+        return run
+    with ThreadPoolExecutor(max_workers=len(suites)) as pool:
+        runs = list(pool.map(launch, suites))
+    _stop_untrusted(agent.pw_uid)
+    for run in runs:
+        if run["status"] == "timeout":
+            close_unfinished(run["suite"], a, work)
+    temporary = a.sealed.with_name(a.sealed.name + f".tmp-{os.getpid()}")
+    for suite in a.suites.split(","):
+        _copy_snapshot(work / suite, temporary / suite)
+    size = sum(f.stat().st_size for f in temporary.rglob("*") if f.is_file())
+    if size > MAX_SNAPSHOT_BYTES:
+        raise ValueError("prediction snapshot exceeds 8 GiB")
+    snapshot = {"schema": SCHEMA, "runs": runs,
+                "inputs": {s: tree_sha256(original_input / s / "inputs") for s in a.suites.split(",")},
+                "predictions": {s: tree_sha256(temporary / s) for s in a.suites.split(",")}}
+    write_json(temporary / "snapshot.json", snapshot)
+    _lock(temporary)
+    os.replace(temporary, a.sealed)
+    (a.sealed.parent / "READY").write_text(sha256(a.sealed / "snapshot.json") + "\n")
+    if not a.no_wait:
+        results = a.sealed.parent / "results"
+        end = time.monotonic() + a.grader_timeout
+        while not (results / "reward.json").is_file():
+            if time.monotonic() >= end:
+                raise TimeoutError("grader did not publish reward")
+            time.sleep(2)
+        for name in ("report.json", "reward.json"):
+            shutil.copyfile(results / name, a.output / name)
+
+
+if __name__ == "__main__":
+    main()

reproduction/files/15/15779511279917cfb9d960cb391c0edf6e60b35d2b247738ad7fc93a38a399a5/runtime.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -eo pipefail
+# Upstream image's documented MPI/solver stack; fail clearly if it changes.
+source /etc/profile
+module purge
+module load MAIA/1.0-NVHPC-26.1
+source /home/easybuild/venvs/hydrogym_gpu/bin/activate
+set -u
+export OMP_NUM_THREADS=1
+export HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1
+export PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
+exec "$@"

reproduction/files/16/1649bbc73b03f29924a080b6fd4830d1efa5ced52914253d1f54ab0ef86a27f2/test_resource_audit.py

@@ -0,0 +1,74 @@
+"""Resource coverage checks, not native CFD or scientific acceptance tests."""
+
+import copy
+import importlib.util
+import json
+from pathlib import Path
+import unittest
+
+
+DATA = Path(__file__).resolve().parents[1] / "environment/data"
+spec = importlib.util.spec_from_file_location("resource_audit", DATA / "resource_audit.py")
+resource_audit = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(resource_audit)
+
+
+class ResourceAuditTests(unittest.TestCase):
+    def setUp(self):
+        self.coverage = json.loads((DATA / "paper-coverage.json").read_text())
+        self.catalog = json.loads((DATA / "catalog.json").read_text())
+        self.report = resource_audit.audit(self.coverage, self.catalog)
+
+    def test_complete_table_accounting_does_not_exclude_cases(self):
+        self.assertEqual(self.report["paper_rows"], 55)
+        self.assertEqual(sum(self.report["resource_counts"].values()), 55)
+        self.assertEqual(self.report["scope_exclusions"], [])
+        self.assertEqual(self.report["resource_counts"]["missing_payload"], 9)
+        self.assertAlmostEqual(self.report["missing_payload_fraction"], 9 / 55)
+        self.assertNotIn("cases", self.report)
+
+    def test_checked_in_report_matches_reproducible_audit(self):
+        self.assertEqual(json.loads((DATA / "resource-audit.json").read_text()), self.report)
+
+    def test_4140_is_not_silently_4200_or_a_missing_family(self):
+        row = next(r for r in self.report["rows"] if r["family"] == "cavity"
+                   and r["dimension"] == 2 and r["parameters"]["Re"] == 4200)
+        self.assertEqual(row["resource_status"], "parameter_mismatch")
+        self.assertEqual(row["candidate_payloads"], [])
+        self.assertIn("Cavity_2D_Re4140", row["related_not_equivalent"])
+
+    def test_dra_marker_and_mach_are_not_usable_payloads(self):
+        rows = {r["parameters"]["Mach"]: r for r in self.report["rows"]
+                if r["family"] == "dra2303"}
+        self.assertEqual(rows[0.2]["resource_status"], "partial_variant_payload")
+        self.assertEqual(rows[0.7]["resource_status"], "missing_payload")
+        self.assertEqual(len(rows[0.7]["marker_only"]), 2)
+        self.assertEqual(rows[0.7]["candidate_payloads"], [])
+
+    def test_firedrake_and_marl_are_not_discarded_for_adapter_gaps(self):
+        row = next(r for r in self.report["rows"] if r["family"] == "cylinder"
+                   and r["dimension"] == 2 and r["parameters"]["Re"] == 100)
+        self.assertEqual(len(row["candidate_payloads"]), 2)
+        self.assertEqual(row["resource_status"], "candidate_payload_unvalidated")
+        marl = [r for r in self.report["rows"] if r["family"] == "cylinder-marl"]
+        self.assertEqual(len(marl), 2)
+        self.assertTrue(all(r["candidate_payloads"] for r in marl))
+        self.assertTrue(all(r["evaluation_status"] == "not_full_suite_validated" for r in marl))
+
+    def test_other_reynolds_number_does_not_replace_channel180(self):
+        catalog = copy.deepcopy(self.catalog)
+        catalog["directories"] = [d for d in catalog["directories"]
+                                  if d["name"] != "TCFmini_3D_Re180"]
+        report = resource_audit.audit(self.coverage, catalog)
+        row = next(r for r in report["rows"] if r["family"] == "turbulent-channel")
+        self.assertEqual(row["resource_status"], "parameter_mismatch")
+        self.assertEqual(row["related_not_equivalent"], ["TCFlarge_3D_Re207"])
+
+    def test_reject_inconsistent_revision(self):
+        self.catalog["revision"] = "different"
+        with self.assertRaisesRegex(ValueError, "revisions"):
+            resource_audit.audit(self.coverage, self.catalog)
+
+
+if __name__ == "__main__":
+    unittest.main()

reproduction/files/17/1756e9907b650c8ec13b6d0b30c3c09297586db754ebdf7f18cf6c6566514c4c/fetch_baseline.py

@@ -0,0 +1,35 @@
+"""Download the pinned baseline using existing authorized Hugging Face access."""
+
+import argparse
+import json
+from pathlib import Path
+import shutil
+
+from huggingface_hub import hf_hub_download
+
+from common import digest, write_json
+
+
+def fetch(output: Path):
+    baseline = json.loads(Path(__file__).with_name("baseline.json").read_text())
+    if output.exists():
+        raise FileExistsError(output)
+    downloaded = Path(
+        hf_hub_download(
+            baseline["repository"],
+            baseline["filename"],
+            revision=baseline["revision"],
+        )
+    )
+    if digest(downloaded) != baseline["sha256"]:
+        raise ValueError("Baseline checkpoint checksum mismatch")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(downloaded, output)
+    write_json(output.with_suffix(".json"), baseline)
+    print(output)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    fetch(parser.parse_args().output)

reproduction/files/17/1788a1f2895aae12e5639dbf83cccffcb00b5ef9b850b60ed7bf2f37057fe140/pipeline.py

@@ -0,0 +1,550 @@
+"""The designability pipeline: LigandMPNN inverse folding plus RoseTTAFold3 refolding.
+
+Runs inside the trusted grader only. It never imports, executes, or links against the
+delivered submission; it consumes sealed coordinates.
+
+Criteria follow the benchmark's per-track `success.txt` (vendored at
+environment/data/targets/*/success.txt). FOUR sequences per backbone on every track -
+the task's own uniform budget, against 8 for enzyme and sm_binder upstream. The
+criterion is "pass if ANY sequence passes", so fewer sequences can only lower a pass
+rate; these are conservative against the published numbers, never flattering.
+
+    enzyme      4 LigandMPNN sequences, 5 predictor models. Passes if ANY model for ANY
+                sequence has, after aligning on the motif backbone (N, CA, C), a motif
+                all-atom RMSD <= 1.5 A.
+    sm_binder   4 LigandMPNN sequences. backbone RMSD <= 1.5 A AND backbone-aligned
+                ligand RMSD <= 5 A AND interface min PAE <= 1.5 AND ipTM >= 0.8.
+    ppi_binder  4 ProteinMPNN sequences. min inter-chain PAE <= 1.5, plus binder
+                backbone RMSD <= 2 A.
+    unconditional
+                4 ProteinMPNN sequences. backbone RMSD <= 1.5 A.
+
+LigandMPNN is selected exactly where the context carries a ligand; ProteinMPNN
+otherwise. The enzyme ligand-clash term - the one published criterion measured on the raw
+design rather than on the refold - is applied by grader.py before folding, purely to skip
+a fold that cannot pass. The grader adds no criterion of its own; see
+environment/evaluation/RESULTS.md.
+
+ipTM and PAE require a complex-capable predictor, which is why RoseTTAFold3 is used
+rather than ESMFold: ESMFold is single-chain and emits neither, and cannot model a
+protein-ligand complex at all.
+
+Pinned assets
+-------------
+LigandMPNN   github.com/dauparas/LigandMPNN @ 26ec57ac976ade5379920dbd43c7f97a91cf82de
+             MIT. Weights fetched by its own get_model_params.sh, mirrored in
+             `environment/fetch_designability_weights.sh` with pinned sha256.
+
+             The ORIGINAL repository, deliberately - not the re-implementation in
+             foundry's `models/mpnn`. Upstream itself says to "use the old repositories
+             ... for model benchmarking/comparison until the API and public weights
+             stabilize", and that warning is justified: run against the foundry
+             re-implementation, `ligand_mpnn` returned byte-identical sequences AND
+             confidences with and without a ligand that had 52 of 53 atoms within 5 A
+             of the backbone, reporting `ligand_interface_sequence_recovery=nan`. Its
+             ligand conditioning is inert, and ligand conditioning is the whole point
+             of two of the four tracks.
+
+RoseTTAFold3 github.com/RosettaCommons/foundry @ b02eed6a6bdf8f44d14a80cc36e3da13c9f2291c
+             BSD-3, IPD/UW. Source vendored at `environment/evaluation/rf3`;
+             parameters are a public download (files.ipd.uw.edu), pinned by sha256 in
+             `environment/fetch_designability_weights.sh`.
+
+             RF3 replaces AlphaFold 3, whose parameters are not redistributable and so
+             had to be mounted by the operator - which kept designability off the
+             agent's own scoring path entirely. RF3's parameters ship, so the criterion
+             an agent optimises is the criterion it is graded on.
+
+             NOTE the consequence for comparability: the per-track thresholds below come
+             from RFdiffusion3's published `success.txt`, which was calibrated with
+             AlphaFold. Scoring with a different predictor does not preserve those
+             numbers' published meaning. This is a deliberate, recorded trade.
+"""
+
+import contextlib
+import json
+import os
+import queue
+import subprocess
+import sys
+import tempfile
+import threading
+from pathlib import Path
+
+import numpy as np
+
+from common import (IPTM_MIN, INTERFACE_PAE_MAX, LIGAND_RMSD_MAX, MODELS_PER_SEQUENCE,
+                    MOTIF_RMSD_MAX, PPI_RMSD_MAX, SAMPLING_TEMPERATURE, SC_RMSD_MAX,
+                    SEQUENCES_PER_BACKBONE, sha256)
+from geometry import kabsch_rotation, superposed_rmsd, write_allatom_pdb
+from residues import THREE_TO_ONE
+
+LIGANDMPNN_COMMIT = "26ec57ac976ade5379920dbd43c7f97a91cf82de"
+RF3_REVISION = "b02eed6a6bdf8f44d14a80cc36e3da13c9f2291c"
+RF3_CHECKPOINT = "rf3_foundry_01_24_latest_remapped.ckpt"
+# model_type -> the checkpoint run.py expects for it. Both are fetched by
+# environment/fetch_designability_weights.sh.
+LIGANDMPNN_WEIGHTS = {"ligand_mpnn": "ligandmpnn_v_32_010_25.pt",
+                      "protein_mpnn": "proteinmpnn_v_48_020.pt"}
+BINDER_CHAIN = "A"
+TARGET_CHAIN = "B"
+
+
+class ScorerUnavailable(RuntimeError):
+    """Raised when the pipeline cannot run. Never degrades into a zero score."""
+
+
+def sequence_of(restypes):
+    return "".join(THREE_TO_ONE.get(name, "X") for name in restypes)
+
+
+def _het_atom_name(element, index):
+    """PDB columns 13-16 for a ligand atom. Always exactly four characters.
+
+    A one-character element sits in column 14 and a two-character element starts in 13,
+    so ` C12` is never confused with `CL1`. The index wraps rather than overflowing the
+    field: a ligand with more than 999 atoms would otherwise shift every later column,
+    and het atom names are never read back - LigandMPNN embeds these atoms by element
+    (`getElements()`), not by name.
+    """
+    body = f"{index % 100:<2d}"          # two digits is all the field has room for
+    name = f"{element[:2]}{body}" if len(element) >= 2 else f" {element}{body}"
+    assert len(name) == 4, name
+    return name
+
+
+def verify_assets(assets_root, ligandmpnn_root):
+    """Fail loudly unless every pinned scoring asset is present.
+
+    Every message names the one command that fixes it, because this runs on whatever
+    cluster the operator has and a missing checkpoint must not read as a broken task.
+    """
+    assets_root, ligandmpnn_root = Path(assets_root), Path(ligandmpnn_root)
+    fetch = ("bash environment/fetch_designability_weights.sh "
+             f"{assets_root}")
+
+    runner = ligandmpnn_root / "run.py"
+    if not runner.is_file():
+        raise ScorerUnavailable(
+            f"LigandMPNN {LIGANDMPNN_COMMIT} is not installed at {ligandmpnn_root}. "
+            "Both images COPY it there from environment/evaluation/ligandmpnn, which vendors that "
+            "revision; outside an image, point LIGANDMPNN_ROOT at that directory.")
+    weights = assets_root / "ligandmpnn_params"
+    missing = [name for name in (LIGANDMPNN_WEIGHTS.values())
+               if not (weights / name).is_file()]
+    if missing:
+        raise ScorerUnavailable(
+            f"LigandMPNN parameters missing from {weights}: {', '.join(missing)}. "
+            f"Run: {fetch}")
+
+    try:
+        import rf3  # noqa: F401
+    except ImportError as error:
+        raise ScorerUnavailable(
+            f"RoseTTAFold3 {RF3_REVISION} is not importable ({error}). Its source is "
+            "vendored at environment/evaluation/rf3; put that plus "
+            "starter/rfd3/src on PYTHONPATH.")
+    checkpoint = assets_root / "rf3" / RF3_CHECKPOINT
+    if not checkpoint.is_file():
+        raise ScorerUnavailable(
+            f"The RoseTTAFold3 checkpoint is not at {checkpoint}. Run: {fetch}")
+
+    return {"ligandmpnn": str(ligandmpnn_root), "ligandmpnn_params": str(weights),
+            "rf3_ckpt": str(checkpoint)}
+
+
+def resolve_devices(devices=None):
+    """Which GPUs grading may use - one worker per device, in physical ordinals.
+
+    Every fold and every inverse-folding call is already an isolated subprocess, so the
+    only thing needed to use N GPUs is to pin each subprocess to one of them. Ids are
+    taken from CUDA_VISIBLE_DEVICES when the environment restricts us, which keeps them
+    physical: the CUDA runtime reads that variable afresh in each child, so passing one
+    of the parent's ids through selects the same card the parent meant.
+
+    Returns [None] when no GPU is visible, meaning "inherit the environment" - one
+    worker, unpinned, which is the single-GPU behaviour this used to have.
+    """
+    if devices:
+        return [str(device) for device in devices]
+    visible = os.environ.get("CUDA_VISIBLE_DEVICES")
+    if visible is not None:
+        return [part.strip() for part in visible.split(",") if part.strip()] or [None]
+    try:
+        import torch
+        count = torch.cuda.device_count()
+    except Exception:                                    # noqa: BLE001 - no torch, no GPU
+        count = 0
+    return [str(index) for index in range(count)] or [None]
+
+
+class DesignabilityScorer:
+    """Structure -> LigandMPNN sequences -> RoseTTAFold3 complexes -> per-track verdict.
+
+    Thread-safe across `evaluate` calls: each one leases a GPU for its duration and pins
+    its subprocesses to it, so `grader.score_track` can fold `len(self.devices)` designs
+    at once. Nothing else is shared - the weights live in the child processes, and every
+    call works in its own temporary directory.
+    """
+
+    def __init__(self, assets_root="/assets", ligandmpnn_root="/opt/ligandmpnn",
+                 timeout=3600, devices=None):
+        self.paths = verify_assets(assets_root, ligandmpnn_root)
+        self.timeout = timeout
+        self.devices = resolve_devices(devices)
+        self._free = queue.Queue()
+        for device in self.devices:
+            self._free.put(device)
+        self._leased = threading.local()
+
+    @contextlib.contextmanager
+    def _lease(self):
+        """Hold one GPU for the length of one design's scoring."""
+        device = self._free.get()
+        self._leased.device = device
+        try:
+            yield device
+        finally:
+            self._leased.device = None
+            self._free.put(device)
+
+    def _env(self):
+        """Child environment, pinned to this thread's leased GPU if it has one."""
+        env = dict(os.environ)
+        device = getattr(self._leased, "device", None)
+        if device is not None:
+            env["CUDA_VISIBLE_DEVICES"] = str(device)
+        return env
+
+    # ---- inverse folding ------------------------------------------------
+    def design_sequences(self, track, structure, context, motif_map):
+        """LigandMPNN sequences for one backbone, with the ligand in context."""
+        coordinates, mask, restypes = structure
+        count = SEQUENCES_PER_BACKBONE[track]
+        with tempfile.TemporaryDirectory() as scratch:
+            scratch = Path(scratch)
+            target = scratch / "design.pdb"
+            write_allatom_pdb(target, coordinates, mask, restypes)
+            # LigandMPNN reads het atoms from the same file, so append the ligand.
+            ligand = context.get("ligand_coords")
+            has_ligand = ligand is not None and np.size(ligand) > 0
+            if has_ligand:
+                names = context.get("ligand_ccd")
+                label = str(names[0]) if names is not None and len(names) else "LIG"
+                # LigandMPNN embeds each het atom by ELEMENT
+                # (`data_utils.parse_PDB` -> `getElements()` -> `element_dict`), so
+                # labelling the whole ligand carbon would hand the model the wrong
+                # chemistry. The context carries the real elements; use them.
+                elements = context.get("ligand_elements")
+                lines = target.read_text().splitlines()
+                lines = [line for line in lines if line not in ("TER", "END")]
+                for index, position in enumerate(np.asarray(ligand), start=1):
+                    x, y, z = position
+                    element = (str(elements[index - 1]).strip().upper()
+                               if elements is not None and len(elements) >= index
+                               else "C")
+                    lines.append(
+                        f"HETATM{9000 + index:>5d} {_het_atom_name(element, index)}"
+                        f" {label:<3s} "
+                        f"L{1:>4d}    {x:>8.3f}{y:>8.3f}{z:>8.3f}  1.00  0.00"
+                        + " " * 10 + f"{element:>2s}")
+                target.write_text("\n".join(lines + ["TER", "END"]) + "\n")
+
+            # run.py reads the checkpoint belonging to --model_type, and every
+            # --checkpoint_* default is RELATIVE ("./model_params/..."). Passing only
+            # --checkpoint_ligand_mpnn while selecting protein_mpnn therefore resolves
+            # against the current directory and only works if it happens to be the
+            # LigandMPNN root. Pass the flag that matches the model.
+            model_type = "ligand_mpnn" if has_ligand else "protein_mpnn"
+            weights = {"ligand_mpnn": ("--checkpoint_ligand_mpnn",
+                                       "ligandmpnn_v_32_010_25.pt"),
+                       "protein_mpnn": ("--checkpoint_protein_mpnn",
+                                        "proteinmpnn_v_48_020.pt")}[model_type]
+            command = [
+                sys.executable, str(Path(self.paths["ligandmpnn"]) / "run.py"),
+                "--model_type", model_type,
+                weights[0],
+                str(Path(self.paths["ligandmpnn_params"]) / weights[1]),
+                "--pdb_path", str(target),
+                "--out_folder", str(scratch),
+                "--batch_size", "1",
+                "--number_of_batches", str(count),
+                "--temperature", str(SAMPLING_TEMPERATURE),
+                "--seed", "37",
+            ]
+            if motif_map:
+                # Motif residues keep their declared identities; only the scaffold is
+                # redesigned, which is what the enzyme criterion measures.
+                fixed = " ".join(f"{BINDER_CHAIN}{index + 1}" for index in sorted(motif_map))
+                command += ["--fixed_residues", fixed]
+            result = subprocess.run(command, capture_output=True, text=True,
+                                    timeout=self.timeout, env=self._env())
+            if result.returncode:
+                raise ScorerUnavailable(f"LigandMPNN failed: {result.stderr[-500:]}")
+            fasta = list((scratch / "seqs").glob("*.fa"))
+            if not fasta:
+                raise ScorerUnavailable("LigandMPNN produced no sequences")
+            sequences = []
+            for line in fasta[0].read_text().splitlines():
+                if line and not line.startswith(">"):
+                    sequences.append(line.strip().split("/")[0])
+            # The first record is the input sequence echoed back.
+            return (sequences[1:] or sequences)[:count]
+
+    # ---- complex prediction ---------------------------------------------
+    def _components(self, sequence, context, scratch):
+        """RF3 `components` for one designed complex, plus the chains to template."""
+        components = [{"seq": sequence, "chain_id": BINDER_CHAIN}]
+        templates = []
+
+        ccd = context.get("ligand_ccd")
+        if ccd is not None and len(ccd):
+            components += [{"ccd_code": str(code)} for code in ccd]
+
+        target = context.get("target_coords")
+        if target is not None and np.size(target):
+            # TEMPLATE the target rather than handing RF3 its bare sequence. A natural
+            # target chain does not fold single-sequence - measured predicted-vs-native
+            # CA RMSD of 5.3-17.7 A across the five benchmark targets - and an interface
+            # scored against an unfolded target is meaningless. RF3 is trained on
+            # explicit atomic templates and its docs give templating as the way to fold
+            # a chain without an MSA. Measured with the template: target CA RMSD 0.097 A.
+            target_pdb = scratch / "target.pdb"
+            if not target_pdb.is_file():
+                write_allatom_pdb(
+                    target_pdb, np.asarray(target),
+                    np.asarray(context["target_mask"], dtype=bool),
+                    [str(res) for res in context["target_restypes"]],
+                    chain=TARGET_CHAIN)
+            components.append({"path": str(target_pdb)})
+            templates.append(TARGET_CHAIN)
+        return components, templates
+
+    def predict_all(self, name, sequences, context, seeds):
+        """Fold every designed sequence in ONE RF3 invocation.
+
+        Batching matters: RF3 loads a ~2.8 GB checkpoint per process, so folding eight
+        sequences as eight subprocesses spends most of its wall clock loading the same
+        weights. `inputs` takes a LIST of jobs, so one call covers a whole design.
+
+        Returns {job name -> [model record, ...]}, in the order given.
+        """
+        with tempfile.TemporaryDirectory() as scratch:
+            scratch = Path(scratch)
+            jobs, names = [], []
+            for index, sequence in enumerate(sequences):
+                components, templates = self._components(sequence, context, scratch)
+                job_name = f"{name}-{index}"
+                job = {"name": job_name, "components": components}
+                if templates:
+                    job["template_selection"] = templates
+                jobs.append(job)
+                names.append(job_name)
+            (scratch / "input.json").write_text(json.dumps(jobs))
+
+            # One seed; RF3 draws `diffusion_batch_size` diffusion samples from it, so
+            # that is what carries MODELS_PER_SEQUENCE. `seeds` is the caller's
+            # statement of how many models the criterion asks for.
+            command = [
+                sys.executable, "-c", "from rf3.cli import app; app()", "fold",
+                f"inputs={scratch / 'input.json'}",
+                f"out_dir={scratch / 'out'}",
+                f"ckpt_path={self.paths['rf3_ckpt']}",
+                f"diffusion_batch_size={max(1, len(list(seeds)))}",
+                "seed=37",
+            ]
+            result = subprocess.run(command, capture_output=True, text=True,
+                                    timeout=self.timeout, env=self._env())
+            if result.returncode:
+                raise ScorerUnavailable(f"RoseTTAFold3 failed: {result.stderr[-500:]}")
+
+            out = {}
+            for job_name in names:
+                # RF3 writes `<name>/seed-N_sample-M/<name>_seed-N_sample-M_model.cif`
+                # plus one top-ranked `<name>_model.cif`. Read the SAMPLES: the enzyme
+                # criterion is "any of 5 predictor models", and matching only the ranked
+                # file silently reduces that to one. `*model.cif` also matches
+                # AlphaFold's bare `model.cif`, so either layout works.
+                directory = scratch / "out" / job_name
+                samples = sorted(directory.rglob("seed-*_sample-*/*model.cif"))
+                if not samples:
+                    samples = sorted(directory.rglob("*_model.cif"))
+                out[job_name] = [self._read_model(path) for path in samples]
+            return [out[job_name] for job_name in names]
+
+    def predict(self, name, sequence, context, seeds):
+        """Fold one designed complex. Returns one record per model."""
+        return self.predict_all(name, [sequence], context, seeds)[0]
+
+    def _read_model(self, model_path):
+        """Extract designed-chain coordinates, ligand atoms, ipTM and interface PAE."""
+        try:
+            import gemmi
+        except ImportError as error:
+            raise ScorerUnavailable(f"gemmi is required to read predictor output: {error}")
+        structure = gemmi.read_structure(str(model_path))
+        structure.remove_alternative_conformations()
+        structure.remove_hydrogens()
+        tabulated = gemmi.find_tabulated_residue
+
+        backbone, ligand = [], []
+        for chain in structure[0]:
+            for residue in chain:
+                info = tabulated(residue.name)
+                if info is not None and info.is_amino_acid():
+                    if chain.name != BINDER_CHAIN:
+                        continue
+                    atoms = {a.name: [a.pos.x, a.pos.y, a.pos.z] for a in residue}
+                    if {"N", "CA", "C"} <= set(atoms):
+                        backbone.append({"name": residue.name, "atoms": atoms})
+                elif not residue.is_water():
+                    ligand.extend([a.pos.x, a.pos.y, a.pos.z] for a in residue)
+
+        # Two layouts: `<name>_model.cif` beside `<name>_summary_confidences.json`,
+        # and `seed-N_sample-M/model.cif` beside a bare `summary_confidences.json`.
+        stem = model_path.name.replace("_model.cif", "")
+        summary = model_path.parent / f"{stem}_summary_confidences.json"
+        if not summary.is_file():
+            summary = model_path.parent / "summary_confidences.json"
+        iptm = interface_pae = None
+        if summary.is_file():
+            payload = json.loads(summary.read_text())
+            iptm = payload.get("iptm")
+            pairs = payload.get("chain_pair_pae_min")
+            if isinstance(pairs, list) and pairs:
+                values = [pairs[i][j] for i in range(len(pairs))
+                          for j in range(len(pairs[i])) if i != j
+                          and isinstance(pairs[i][j], (int, float))]
+                interface_pae = min(values) if values else None
+        return {"backbone": backbone, "ligand": np.array(ligand) if ligand else None,
+                "iptm": iptm, "interface_pae": interface_pae}
+
+    # ---- per-track criteria ---------------------------------------------
+    @staticmethod
+    def _motif_arrays(residues, indices):
+        """Atom14-shaped coordinates and mask for selected refolded residues."""
+        from residues import ATOM14, ATOM14_WIDTH, atom_slot
+        coordinates = np.zeros((len(indices), ATOM14_WIDTH, 3))
+        mask = np.zeros((len(indices), ATOM14_WIDTH), dtype=bool)
+        names = []
+        for row, index in enumerate(indices):
+            if index >= len(residues):
+                return None, None, None
+            residue = residues[index]
+            names.append(residue["name"])
+            if residue["name"] not in ATOM14:
+                continue
+            for atom, position in residue["atoms"].items():
+                slot = atom_slot(residue["name"], atom)
+                if slot is not None:
+                    coordinates[row, slot] = position
+                    mask[row, slot] = True
+        return coordinates, mask, names
+
+    def _motif_recapitulation(self, model, motif_map, context):
+        """Align refolded motif on N/CA/C, then score all shared motif atoms."""
+        reference = context["motif_coords"]
+        reference_mask = np.asarray(context["motif_mask"], dtype=bool)
+        coordinates, mask, _ = self._motif_arrays(model["backbone"], motif_map)
+        if coordinates is None:
+            return None
+        shared = mask & reference_mask
+        frame = shared.copy()
+        frame[:, 3:] = False                      # align on N, CA, C only
+        if frame.sum() < 3:
+            # These contexts mostly carry fixed catalytic TIP atoms, not backbone: 25 of
+            # the 41 enzyme evaluation contexts have fewer than 3 backbone atoms in
+            # `motif_mask` (median 1, min 0). Returning None here made the criterion
+            # unsatisfiable by construction for 61% of the track. `geometry.py::
+            # backbone_aligned_motif_rmsd` has always had this fallback; keep the two
+            # in step.
+            frame = shared
+        if shared.sum() < 3:
+            return None
+        mobile, target = coordinates[frame], reference[frame]
+        offset_mobile, offset_target = mobile.mean(axis=0), target.mean(axis=0)
+        rotation = kabsch_rotation(mobile - offset_mobile, target - offset_target)
+        moved = (coordinates[shared] - offset_mobile) @ rotation.T + offset_target
+        return float(np.sqrt(np.mean(np.sum((moved - reference[shared]) ** 2, axis=1))))
+
+    @staticmethod
+    def _backbone_rmsd_and_transform(model, design_ca):
+        """CA RMSD of a refolded chain against the design, plus the fitted transform."""
+        refolded = np.array([r["atoms"]["CA"] for r in model["backbone"]])
+        if refolded.shape[0] != design_ca.shape[0] or refolded.shape[0] < 3:
+            return None, None
+        offset_mobile, offset_target = refolded.mean(axis=0), design_ca.mean(axis=0)
+        rotation = kabsch_rotation(refolded - offset_mobile, design_ca - offset_target)
+        moved = (refolded - offset_mobile) @ rotation.T + offset_target
+        rmsd = float(np.sqrt(np.mean(np.sum((moved - design_ca) ** 2, axis=1))))
+        return rmsd, (offset_mobile, rotation, offset_target)
+
+    def evaluate(self, track, structure, context, motif_map=None):
+        """Run the track's published criterion. Returns a verdict dict."""
+        with self._lease():
+            return self._evaluate(track, structure, context, motif_map)
+
+    def _evaluate(self, track, structure, context, motif_map):
+        coordinates, mask, restypes = structure
+        design_ca = coordinates[:, 1]
+        sequences = self.design_sequences(track, structure, context, motif_map)
+        seeds = list(range(MODELS_PER_SEQUENCE[track]))
+        best = {"passed": False, "sc_rmsd": float("inf"), "iptm": None,
+                "interface_pae": None, "ligand_rmsd": None, "motif_rmsd": None,
+                "sequences_tried": 0, "reason": "no sequence satisfied the criterion"}
+
+        # One RF3 call for the whole design, not one per sequence - see predict_all.
+        # This does mean every sequence is folded rather than stopping at the first
+        # success; the criterion is "any sequence passes", so the verdict is identical.
+        folded = self.predict_all("design", sequences, context, seeds)
+
+        for number, models in enumerate(folded):
+            best["sequences_tried"] = number + 1
+            for model in models:
+                rmsd, transform = self._backbone_rmsd_and_transform(model, design_ca)
+                if rmsd is None:
+                    continue
+                record = {"sc_rmsd": rmsd, "iptm": model["iptm"],
+                          "interface_pae": model["interface_pae"],
+                          "ligand_rmsd": None, "motif_rmsd": None}
+
+                if track == "enzyme":
+                    # Passes on motif recapitulation alone, by any model of any
+                    # sequence. The ligand-clash half of the criterion is a geometry
+                    # check on the design and is applied by the grader.
+                    record["motif_rmsd"] = self._motif_recapitulation(
+                        model, motif_map or [], context)
+                    ok = (record["motif_rmsd"] is not None
+                          and record["motif_rmsd"] <= MOTIF_RMSD_MAX)
+                elif track == "sm_binder":
+                    ligand = context.get("ligand_coords")
+                    if model["ligand"] is not None and ligand is not None and \
+                            model["ligand"].shape == np.asarray(ligand).shape:
+                        origin, rotation, destination = transform
+                        moved = (model["ligand"] - origin) @ rotation.T + destination
+                        record["ligand_rmsd"] = float(np.sqrt(np.mean(
+                            np.sum((moved - np.asarray(ligand)) ** 2, axis=1))))
+                    ok = (rmsd <= SC_RMSD_MAX
+                          and record["ligand_rmsd"] is not None
+                          and record["ligand_rmsd"] <= LIGAND_RMSD_MAX
+                          and record["interface_pae"] is not None
+                          and record["interface_pae"] <= INTERFACE_PAE_MAX
+                          and record["iptm"] is not None
+                          and record["iptm"] >= IPTM_MIN)
+                elif track == "ppi_binder":
+                    # success.txt gives no PAE threshold for this track; the
+                    # sm_binder value is reused and flagged as inferred.
+                    ok = (rmsd <= PPI_RMSD_MAX
+                          and record["interface_pae"] is not None
+                          and record["interface_pae"] <= INTERFACE_PAE_MAX)
+                else:
+                    ok = rmsd <= SC_RMSD_MAX
+
+                if rmsd < best["sc_rmsd"]:
+                    best.update(record)
+                if ok:
+                    best.update(record)
+                    best["passed"] = True
+                    best["reason"] = None
+                    return best
+        return best

reproduction/files/18/18303172092c875b81bbb92d12d0c42e94404f0ee430741b1941645320036c5f/physics.py

@@ -0,0 +1,139 @@
+"""Fixed protocols adapted from FAIRChem's MIT-licensed UMA benchmark recipes.
+
+See THIRD_PARTY_NOTICES.md and PROTOCOLS.md for source revision and differences.
+The calculator receives geometry only. These routines never open target files.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from ase import units
+from ase.build import make_supercell
+from ase.filters import FrechetCellFilter
+from ase.optimize import FIRE
+from phonopy import Phonopy
+from phonopy.harmonic.dynmat_to_fc import get_commensurate_points
+from phonopy.structure.atoms import PhonopyAtoms
+from pymatgen.analysis.elasticity import DeformedStructureSet, ElasticTensor, Strain
+from pymatgen.core import Structure
+from pymatgen.io.phonopy import get_pmg_structure, get_phonopy_structure
+
+from common import decode_atoms, encode_atoms
+
+THZ_TO_K = units._hplanck * 1e12 / units._k
+
+
+def relax(atoms, calculator, *, fmax=0.02, cell=True):
+    atoms.calc = calculator
+    optimizer = FIRE(FrechetCellFilter(atoms) if cell else atoms, logfile=None)
+    converged = optimizer.run(fmax=fmax, steps=500)
+    return {"converged": bool(converged), "steps": optimizer.nsteps}
+
+
+def discovery(case, calculator):
+    atoms = decode_atoms(case["atoms"])
+    diagnostics = relax(atoms, calculator)
+    return {
+        "energy": float(atoms.get_potential_energy()),
+        "atoms": encode_atoms(atoms),
+        "diagnostics": diagnostics,
+    }
+
+
+def make_phonon(case):
+    atoms = decode_atoms(case["atoms"])
+    cell = PhonopyAtoms(
+        numbers=atoms.numbers,
+        positions=atoms.positions,
+        cell=atoms.cell.array,
+        masses=case["phonon"]["masses"],
+    )
+    return Phonopy(
+        cell,
+        supercell_matrix=case["phonon"]["supercell_matrix"],
+        primitive_matrix=case["phonon"]["primitive_matrix"],
+        symprec=1e-4,
+    )
+
+
+def phonon_observables(phonon):
+    # Same commensurate q-points as upstream; retain negative frequencies.
+    qpoints = get_commensurate_points(phonon.supercell_matrix)
+    phonon.run_qpoints(qpoints)
+    frequencies = phonon.get_qpoints_dict()["frequencies"] * THZ_TO_K
+    phonon.run_mesh((20, 20, 20))
+    phonon.run_thermal_properties(t_min=0, t_max=600, t_step=75)
+    thermal = phonon.get_thermal_properties_dict()
+    index = list(thermal["temperatures"]).index(300)
+    return {
+        "max_freq": float(frequencies.max()),
+        "avg_freq": float(frequencies.mean()),
+        **{
+            key: float(thermal[key][index])
+            for key in ("entropy", "heat_capacity", "free_energy")
+        },
+    }
+
+
+def phonons(case, calculator):
+    reference_geometry = make_phonon(case)  # no DFT force constants
+    primitive = get_pmg_structure(reference_geometry.primitive).to_ase_atoms()
+    diagnostics = relax(primitive, calculator, fmax=0.005)
+    transform = (
+        np.linalg.inv(reference_geometry.primitive_matrix.T)
+        if reference_geometry.primitive_matrix is not None
+        else np.eye(3)
+    )
+    # Guard against silently truncating a nonintegral transformation.
+    if not np.allclose(transform, np.rint(transform), atol=1e-8):
+        raise ValueError("Nonintegral primitive-to-unit-cell transformation")
+    unitcell = make_supercell(primitive, np.rint(transform).astype(int))
+    phonon = Phonopy(
+        get_phonopy_structure(Structure.from_ase_atoms(unitcell)),
+        reference_geometry.supercell_matrix,
+        primitive_matrix=reference_geometry.primitive_matrix,
+        symprec=1e-4,
+    )
+    phonon.generate_displacements(distance=0.01)
+    phonon.forces = [
+        calculator.get_forces(get_pmg_structure(cell).to_ase_atoms())
+        for cell in phonon.supercells_with_displacements
+    ]
+    phonon.produce_force_constants(fc_calculator="traditional")
+    # No post-fit force-constant symmetrization, matching the UMA protocol.
+    diagnostics.update(
+        n_displacements=len(phonon.supercells_with_displacements),
+        supercell_atoms=len(phonon.supercell),
+    )
+    return {**phonon_observables(phonon), "diagnostics": diagnostics}
+
+
+def elasticity(case, calculator):
+    atoms = decode_atoms(case["atoms"])
+    diagnostics = relax(atoms, calculator)
+    equilibrium_stress = atoms.get_stress(voigt=False)
+    deformations = DeformedStructureSet(
+        Structure.from_ase_atoms(atoms),
+        norm_strains=(-0.01, -0.005, 0.005, 0.01),
+        shear_strains=(-0.06, -0.03, 0.03, 0.06),
+    )
+    stresses, relaxation_results = [], []
+    for structure in deformations:
+        strained = structure.to_ase_atoms()
+        relaxation_results.append(relax(strained, calculator, cell=False))
+        stresses.append(strained.get_stress(voigt=False))
+    tensor = ElasticTensor.from_independent_strains(
+        [Strain.from_deformation(d) for d in deformations.deformations],
+        stresses,
+        eq_stress=equilibrium_stress,
+    )
+    diagnostics["strained_relaxations"] = relaxation_results
+    return {
+        "bulk_modulus_vrh": float(tensor.k_vrh / units.GPa),
+        "shear_modulus_vrh": float(tensor.g_vrh / units.GPa),
+        "elastic_tensor_GPa": (tensor.voigt / units.GPa).tolist(),
+        "diagnostics": diagnostics,
+    }
+
+
+CALCULATIONS = {"discovery": discovery, "phonons": phonons, "elasticity": elasticity}

reproduction/files/18/18f409937d30e1f78dd33ca4ac2fc24db941a319443551146fb09ad505dfb472/native_settings.py

@@ -0,0 +1,86 @@
+"""Reviewed scalar MAIA settings; never alter geometry or replace native rewards."""
+
+import math
+
+from protocol import InfrastructureError
+
+
+ATTRIBUTES = {
+    "max_episode_steps": "max_episode_steps",
+    "substeps_per_action": "num_substeps_per_iteration",
+    "max_control": "MAX_CONTROL",
+    "omega": "omega",
+}
+
+
+def validate_settings(settings, horizon, episode_end="native"):
+    if episode_end not in ("native", "time_limit"):
+        raise InfrastructureError("Unknown reviewed episode_end convention")
+    if not isinstance(settings, dict) or set(settings) - ATTRIBUTES.keys():
+        raise InfrastructureError("Unknown/invalid reviewed native settings")
+    for key, value in settings.items():
+        if key in ("max_episode_steps", "substeps_per_action"):
+            minimum = 0 if key == "max_episode_steps" else 1
+            if type(value) is not int or value < minimum:
+                raise InfrastructureError(f"Invalid native setting: {key}")
+        elif type(value) not in (int, float) or not math.isfinite(value) or value < 0:
+            raise InfrastructureError(f"Invalid native setting: {key}")
+        if key == "max_control" and value == 0:
+            raise InfrastructureError("Native actuator limit must be positive")
+    offset = 1 if episode_end == "native" else 0
+    if "max_episode_steps" in settings and settings["max_episode_steps"] + offset != horizon:
+        raise InfrastructureError("Native completion setting and reviewed horizon disagree")
+
+
+def apply_settings(env, case):
+    settings = case.get("native_settings", {})
+    episode_end = case.get("episode_end", "native")
+    validate_settings(settings, case["horizon"], episode_end)
+    defaults = {}
+    for key, attribute in ATTRIBUTES.items():
+        if not hasattr(env, attribute):
+            raise InfrastructureError(f"Pinned MAIA attribute missing: {attribute}")
+        value = getattr(env, attribute)
+        defaults[key] = int(value) if key in ("max_episode_steps", "substeps_per_action") else float(value)
+    for key, value in settings.items():
+        setattr(env, ATTRIBUTES[key], value)
+    effective = {key: settings.get(key, value) for key, value in defaults.items()}
+    offset = 1 if episode_end == "native" else 0
+    if env.max_episode_steps + offset != case["horizon"]:
+        raise InfrastructureError("Native horizon differs from the reviewed release")
+    return {"native_defaults": defaults, "effective": effective, "episode_end": episode_end}
+
+
+def with_episode_limit(env, case):
+    """Apply the same reviewed boundary in training and independent evaluation.
+
+    Legacy releases keep their native flags. Public StepCounter reconstructions
+    leave native max_episode_steps=horizon and truncate before native completion.
+    Never hide an early/native failure by relabelling it a timeout.
+    """
+    if case.get("episode_end", "native") == "native":
+        return env
+    validate_settings(case.get("native_settings", {}), case["horizon"], case["episode_end"])
+    import gymnasium as gym
+
+    class ReviewedTimeLimit(gym.Wrapper):
+        def __init__(self):
+            super().__init__(env)
+            self.count = None
+            self.reviewed_protocol = env.reviewed_protocol
+
+        def reset(self, **kwargs):
+            result = self.env.reset(**kwargs)
+            self.count = 0
+            return result
+
+        def step(self, action):
+            if self.count is None or self.count >= case["horizon"]:
+                raise InfrastructureError("Reset is required before another reviewed episode")
+            observation, reward, terminated, truncated, info = self.env.step(action)
+            self.count += 1
+            if terminated or truncated:
+                raise InfrastructureError("Native completion preceded the reviewed external time limit")
+            return observation, reward, False, self.count == case["horizon"], info
+
+    return ReviewedTimeLimit()

reproduction/files/1a/1a17e381a1e20dff632e5a127d68deafe4786c27271e64de619787dff4f841c2/native_verifier.py

@@ -0,0 +1,400 @@
+"""Execute frozen upstream verifier entrypoints in credential-free Beaker jobs.
+
+Prediction and trusted grading use separate jobs and mounts. Folding retains its
+upstream single-process replay and is explicitly NOT called label-isolated.
+No scientific verifier functions are replaced or monkey-patched.
+"""
+import ctypes
+import hashlib
+import json
+import os
+from pathlib import Path
+import pwd
+import platform
+import re
+import shutil
+import signal
+import socket
+import subprocess
+import sys
+import time
+
+import gpu_access
+import runtime
+import sealed_sandbox
+
+STATE = Path('/phase-state')
+
+
+def enter_offline_namespace():
+    import offline_network
+    record = offline_network.configure(STATE)
+    libc = ctypes.CDLL(None, use_errno=True)
+    for name, flag in (('user', offline_network.CLONE_NEWUSER), ('net', offline_network.CLONE_NEWNET)):
+        fd = os.open(f'/proc/{record["pid"]}/ns/{name}', os.O_RDONLY | os.O_CLOEXEC)
+        try:
+            if libc.setns(fd, flag):
+                raise OSError(ctypes.get_errno(), 'enter offline verifier namespace')
+        finally:
+            os.close(fd)
+    if socket.if_nameindex() != [(1, 'lo')]:
+        raise RuntimeError('Offline verifier namespace has external interfaces')
+    return record
+
+
+def validate_ready_marker(sealed_root):
+    """Accept either upstream seal format, always checking the exact snapshot.
+
+Surface-code uses JSON with a run ID. Molecular, Genome and Protein-sequence
+use a plain SHA-256 line. The original scientific grader rechecks the seal.
+"""
+    root = Path(sealed_root)
+    raw = (root/'READY').read_text().strip()
+    snapshot = root/'run/snapshot.json'
+    observed = hashlib.sha256(snapshot.read_bytes()).hexdigest()
+    if re.fullmatch('[0-9a-f]{64}', raw):
+        if raw != observed:
+            raise RuntimeError('Native seal marker is inconsistent')
+        return
+    marker = json.loads(raw)
+    if (not isinstance(marker, dict) or marker.get('snapshot_sha256') != observed
+            or not isinstance(marker.get('run_id'), str)
+            or json.loads(snapshot.read_text()).get('run_id') != marker['run_id']):
+        raise RuntimeError('Native seal marker is inconsistent')
+
+
+def run_until_sealed(command, log, seconds, sealed_root=Path('/sealed')):
+    """End the native waiting supervisor only after its authenticated seal."""
+    process = subprocess.Popen(command, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
+    deadline = time.monotonic() + seconds
+    sealed_ready = False
+    try:
+        while process.poll() is None:
+            if (sealed_root / 'READY').is_file():
+                validate_ready_marker(sealed_root)
+                sealed_ready = True
+                break
+            if time.monotonic() >= deadline:
+                raise TimeoutError('Verifier inference budget exhausted')
+            time.sleep(.1)
+    finally:
+        if process.poll() is None:
+            os.killpg(process.pid, signal.SIGTERM)
+        try:
+            process.wait(timeout=30)
+        except subprocess.TimeoutExpired:
+            os.killpg(process.pid, signal.SIGKILL)
+            process.wait()
+    return subprocess.CompletedProcess(command, 0 if sealed_ready else process.returncode)
+
+
+def status(phase, **details):
+    runtime.write_json(STATE / 'status.json', {'phase': phase, 'unix': time.time(), **details})
+    print(json.dumps({'phase': phase, **details}), flush=True)
+
+
+def copy_readonly_benchmark(source, destination, verify_contents=False):
+    """Change permissions only on a private local copy of the input mount."""
+    source, destination = Path(source), Path(destination)
+    if destination.exists():
+        raise RuntimeError('Expected a fresh local benchmark directory')
+    shutil.copytree(source, destination, symlinks=False)
+    hashes = {}
+    def digest_file(path):
+        digest = hashlib.sha256()
+        with path.open('rb') as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b''):
+                digest.update(block)
+        return digest.hexdigest()
+    for path in [destination, *destination.rglob('*')]:
+        path.chmod(0o555 if path.is_dir() else 0o444)
+        if verify_contents and path.is_file():
+            relative = path.relative_to(destination)
+            digest = digest_file(path)
+            if digest_file(source / relative) != digest:
+                raise RuntimeError(f'Local benchmark copy differs: {relative}')
+            hashes[str(relative)] = digest
+    return dict(source_permissions_modified=False, verified_file_sha256=hashes)
+
+
+def main(phase):
+    entered = time.monotonic()
+    plan = json.loads(Path('/operator/plan.json').read_text())
+    cfg = plan['phases'][phase]
+    adapted = cfg.get('adapted_permissions', False)
+    if adapted:
+        import adapted_boundary
+        adapted_boundary.no_new_privileges()
+        os.setgroups([])
+    STATE.chmod(0o755)
+    kernel_features = {'kernel': platform.release(),
+                       'landlock_abi': ctypes.CDLL(None, use_errno=True).syscall(444, 0, 0, 1)}
+    runtime.write_json(STATE / 'kernel-features.json', kernel_features)
+    status('preflight', task=plan['task'], role=phase, **kernel_features)
+    for key in list(os.environ):
+        if any(word in key.upper() for word in ('API_KEY', 'TOKEN', 'SECRET')):
+            os.environ.pop(key, None)
+    os.environ.update(PYTHONDONTWRITEBYTECODE='1', PYTHONUNBUFFERED='1',
+                      HF_HUB_OFFLINE='1', TRANSFORMERS_OFFLINE='1', PIP_NO_INDEX='1',
+                      HF_HOME='/tmp/huggingface', MPLCONFIGDIR='/tmp/matplotlib',
+                      XDG_CACHE_HOME='/tmp/verifier-cache',
+                      NUMBA_CACHE_DIR='/tmp/verifier-cache/numba',
+                      TRITON_CACHE_DIR='/tmp/verifier-cache/triton',
+                      TORCH_EXTENSIONS_DIR='/tmp/verifier-cache/torch-extensions',
+                      CUDA_CACHE_PATH='/tmp/verifier-cache/cuda')
+    os.environ.update(cfg.get('environment', {}))
+    crystal_cache_receipt = None
+    if cfg.get('isolated_crystal_dataset_cache'):
+        if plan['task'] != 'crystal-structure-generation' or phase != 'score':
+            raise RuntimeError('Crystal cache isolation is for trusted grading only')
+        import crystal_cache
+        crystal_cache_receipt = crystal_cache.prepare(
+            '/scorer-assets/huggingface/datasets', os.environ['HF_DATASETS_CACHE'])
+        crystal_cache_receipt['asset_manifest_sha256'] = hashlib.sha256(
+            Path('/scorer-assets/READY.json').read_bytes()).hexdigest()
+        runtime.write_json(STATE / 'dataset-cache.json', crystal_cache_receipt)
+    for rel, expected in plan['verifier_source_sha256'].items():
+        if hashlib.sha256((Path('/operator/task') / rel).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f'Frozen verifier source changed: {rel}')
+    offline = enter_offline_namespace() if cfg.get('loopback_namespace') else None
+    cpus = cfg['cpu_count']
+    affinity = sorted(os.sched_getaffinity(0))
+    if len(affinity) < cpus:
+        raise RuntimeError('Insufficient allocated CPUs')
+    os.sched_setaffinity(0, affinity[:cpus])
+    memory = sealed_sandbox.allocated_memory_limit()
+    if memory < cfg['memory_gib'] * 1024**3:
+        raise RuntimeError('Insufficient allocated RAM')
+    if cfg.get('local_benchmark_copy'):
+        status('copying_benchmark', task=plan['task'], role=phase)
+        # The GPU Landlock policy grants existing root children. Create this
+        # local root child first, so the later policy can grant it read access.
+        # This is trusted input staging; no submitted code has run yet.
+        receipt = copy_readonly_benchmark('/source-benchmark', '/benchmark',
+                                         cfg.get('verify_benchmark_copy', False))
+        runtime.write_json(STATE / 'benchmark-copy.json', receipt)
+    gpu_policy = None
+    if cfg['accessible_gpus']:
+        gpu_policy = gpu_access.configure(STATE, count=cfg['accessible_gpus'], strict_allocation=adapted)
+        os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(gpu_policy['allowed_uuids'])
+        if adapted:
+            adapted_boundary.exact_gpu_allocation(gpu_policy)
+        else:
+            gpu_access.restrict_device_access(gpu_policy['denied_devices'])
+        if cfg.get('gpu_runtime', 'torch') == 'torch' and not adapted:
+            import torch
+            if torch.cuda.device_count() != cfg['accessible_gpus'] or not all(
+                    'H100' in torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())):
+                raise RuntimeError('Verifier did not receive the required H100 devices')
+    else:
+        os.environ['CUDA_VISIBLE_DEVICES'] = ''
+    if phase == 'inference':
+        status('copying_submission', task=plan['task'], role=phase)
+        if cfg.get('native_uid_isolation'):
+            # The original PDE verifier explicitly supports this UID fallback.
+            # The mount is below a local root-only parent, never chmod shared data.
+            Path('/private').chmod(0o700)
+            Path('/tests').chmod(0o700)
+        elif plan['task'] != 'protein-folding-prediction':
+            for path in ('/private', '/labels'):
+                if Path(path).is_dir() and any(Path(path).iterdir()):
+                    raise RuntimeError('Private labels unexpectedly mounted into inference')
+        package = Path('/workspace/submission')
+        if package.exists():
+            raise RuntimeError('Expected a fresh local submission directory')
+        shutil.copytree('/submission-source', package, symlinks=True)
+        status('checking_submission', task=plan['task'], role=phase)
+        if runtime.fingerprint(package) != plan['submission_sha256']:
+            raise RuntimeError('Frozen submission fingerprint mismatch')
+        try:
+            agent = pwd.getpwnam('agent')
+        except KeyError:
+            try:
+                agent = pwd.getpwuid(10001)
+            except KeyError:
+                subprocess.run(['/usr/sbin/useradd', '--create-home', '--uid', '10001', 'agent'], check=True)
+                agent = pwd.getpwnam('agent')
+        if agent.pw_uid != 10001:
+            raise RuntimeError('Unexpected inference user identity')
+        status('setting_submission_permissions', task=plan['task'], role=phase)
+        for path in [package, *package.rglob('*')]:
+            os.chown(path, agent.pw_uid, agent.pw_gid, follow_symlinks=False)
+    Path('/logs').mkdir(exist_ok=True)
+    # Some native images precreate this empty container-local mountpoint.
+    # rmdir fails closed if it contains anything; never remove existing logs.
+    if Path('/logs/verifier').is_dir() and not Path('/logs/verifier').is_symlink():
+        Path('/logs/verifier').rmdir()
+    Path('/logs/verifier').symlink_to(STATE / 'results', target_is_directory=True)
+    (STATE / 'results').mkdir()
+    if adapted and cfg.get('network_policy') != 'policy-children-only':
+        adapted_boundary.restrict_network()
+    elif not offline and not adapted:
+        runtime.deny_network()
+    if not adapted:
+        writable_roots = ['/phase-state', '/sealed', '/logs', '/workspace', '/tmp', '/dev', '/home', '/proc',
+                          *cfg.get('writable_runtime_paths', [])]
+        if crystal_cache_receipt:
+            # The native image links /scorer-assets beneath /workspace. A
+            # writable ancestor defeats a read-only Landlock child rule.
+            # Trusted grading needs its output and scratch directories only.
+            writable_roots.remove('/workspace')
+        sealed_sandbox.filesystem(
+        readonly=['/operator', '/submission-source', '/benchmark', '/private', '/labels',
+                  '/evaluation', '/tests', '/usr', '/bin', '/sbin', '/lib', '/lib64',
+                  '/opt', '/etc', '/sys', '/run', '/data', '/scorer-assets',
+                  *cfg.get('readonly_runtime_paths', [])],
+        # NVIDIA initialization requires writable procfs, as in the existing
+        # sealed adapter. Beaker's procfs protections and the upstream UID
+        # boundary still apply. Weka inputs and operator files stay read-only.
+        writable=writable_roots)
+    # Root also inherits the write restriction; this protects Weka source mounts
+    # even for the upstream folding evaluator, which does not drop privileges.
+    if adapted:
+        source_audit = adapted_boundary.audit_source_permissions(
+            ['/operator', '/submission-source', '/source-benchmark', '/benchmark', '/data', '/labels', '/private'],
+            untrusted_uids=tuple(range(10001, 10009)))
+    else:
+        try:
+            Path('/operator/.write-probe').write_text('must be denied')
+        except PermissionError:
+            pass
+        else:
+            raise RuntimeError('Operator source mount is writable')
+    if crystal_cache_receipt:
+        try:
+            fd = os.open('/scorer-assets/READY.json', os.O_WRONLY | os.O_CLOEXEC)
+        except PermissionError:
+            crystal_cache_receipt['asset_write_denied'] = True
+        else:
+            os.close(fd)
+            raise RuntimeError('Prepared scorer assets remain writable')
+        runtime.write_json(STATE / 'dataset-cache.json', crystal_cache_receipt)
+    if cfg['accessible_gpus']:
+        # Test a fresh CUDA process AFTER all restrictions, with the same UID
+        # used by the native verifier. A parent probe before Landlock can pass
+        # while the actual inference child cannot initialize CUDA.
+        uid = 0 if plan['task'] == 'protein-folding-prediction' and not adapted else 10001
+        def demote_probe():
+            if uid:
+                os.setgid(uid)
+                os.setuid(uid)
+        probe = (
+            'import torch; '
+            f'assert torch.cuda.device_count() == {cfg["accessible_gpus"]}; '
+            'assert all("H100" in torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())); '
+            'assert all((torch.ones(4, device=f"cuda:{i}") * 2).sum().item() == 8 '
+            'for i in range(torch.cuda.device_count())); '
+            'print("CUDA_AFTER_SANDBOX_OK")')
+        if cfg.get('gpu_runtime') == 'jax':
+            probe = ('import jax; import jax.numpy as jnp; '
+                     f'assert len(jax.devices("gpu")) == {cfg["accessible_gpus"]}; '
+                     'assert all("H100" in d.device_kind for d in jax.devices("gpu")); '
+                     'assert all(float(jnp.sum(jax.device_put(jnp.ones(4),d)*2)) == 8 '
+                     'for d in jax.devices("gpu")); print("JAX_CUDA_AFTER_SANDBOX_OK")')
+        probe_env = {'PATH': '/opt/conda/bin:/opt/venv/bin:/usr/local/bin:/usr/bin:/bin',
+                     'HOME': '/root' if uid == 0 else pwd.getpwuid(uid).pw_dir,
+                     'CUDA_VISIBLE_DEVICES': os.environ['CUDA_VISIBLE_DEVICES'],
+                     'PYTHONDONTWRITEBYTECODE': '1'}
+        if adapted and plan['task'] == 'fluid-flow-control':
+            # native_runtime.sh loads a module-provided libpython. Preserve
+            # only these runtime settings, never credentials, in the probe.
+            for key in ('PATH', 'LD_LIBRARY_PATH', 'OMP_NUM_THREADS',
+                        'OPENBLAS_NUM_THREADS', 'XLA_PYTHON_CLIENT_PREALLOCATE'):
+                if key in os.environ:
+                    probe_env[key] = os.environ[key]
+        with (STATE / 'gpu-child-probe.log').open('w') as log:
+            subprocess.run([cfg.get('driver_python', cfg['command'][0]), '-c', probe], env=probe_env,
+                           preexec_fn=demote_probe, stdout=log, stderr=subprocess.STDOUT,
+                           timeout=120, check=True)
+    if cfg.get('dependency_probe'):
+        # Exercise the original runtime imports under the final restrictions
+        # before spending time loading test data. Cache files belong in /tmp,
+        # while installed libraries and frozen source mounts remain read-only.
+        with (STATE / 'dependency-probe.log').open('w') as log:
+            def dependency_identity():
+                os.setgroups([]); os.setgid(10001); os.setuid(10001)
+            if cfg.get('untrusted_whole_verifier'):
+                cache=Path('/tmp/verifier-cache');cache.mkdir(exist_ok=True)
+                os.chown(cache,10001,10001)
+            subprocess.run([cfg.get('driver_python', cfg['command'][0]), '-c', cfg['dependency_probe']],
+                           stdout=log, stderr=subprocess.STDOUT, timeout=180, check=True,
+                           preexec_fn=dependency_identity if cfg.get('untrusted_whole_verifier') else None)
+    receipt = {'task': plan['task'], 'role': phase, 'cpu_affinity': sorted(os.sched_getaffinity(0)),
+               'kernel_features': kernel_features,
+               'gpu_policy': gpu_policy, 'requested_memory_gib': cfg['memory_gib'],
+               'allocated_memory_bytes': memory, 'strict_benchmark_ram_cap': False,
+               'network': ('seccomp in unprivileged policy children; trusted simulator retains MPI sockets'
+                           if cfg.get('network_policy') == 'policy-children-only' else
+                           'isolated loopback namespace' if offline else 'IPv4/IPv6 socket creation denied; inherited by children'),
+               'offline_namespace': offline,
+               'source_mounts': f'POSIX permission audit ({source_audit} entries); non-root submission' if adapted else 'Landlock read-only',
+               'gpu_child_probe': 'passed after sandbox' if cfg['accessible_gpus'] else 'not applicable',
+               'dependency_probe': 'passed' if cfg.get('dependency_probe') else 'not requested',
+               'cache_environment': {key: os.environ[key] for key in (
+                   'XDG_CACHE_HOME', 'NUMBA_CACHE_DIR', 'TRITON_CACHE_DIR',
+                   'TORCH_EXTENSIONS_DIR', 'CUDA_CACHE_PATH')},
+               'label_isolated': plan.get('label_isolated', plan['task'] != 'protein-folding-prediction'),
+               'adapted_execution': adapted,
+               'scientific_scorer_modified': False}
+    runtime.write_json(STATE / 'preflight.json', receipt)
+    status('verifying', task=plan['task'], role=phase)
+    start = time.monotonic()
+    with (STATE / 'verifier.log').open('w') as log:
+        remaining = cfg['timeout_seconds'] - (time.monotonic() - entered)
+        if remaining <= 0:
+            raise TimeoutError('Verifier budget exhausted during initialization')
+        if cfg.get('stop_after_sealed_ready'):
+            # The native supervisor has already killed all model processes and
+            # sealed/hashes its predictions before writing READY. End only its
+            # wait-for-grader loop; the unchanged grader runs in a separate job.
+            result = run_until_sealed(cfg['command'], log, remaining)
+        else:
+            def run_identity():
+                os.setgroups([])
+                os.setgid(10001)
+                os.setuid(10001)
+            if cfg.get('untrusted_whole_verifier'):
+                os.chown(STATE / 'results', 10001, 10001)
+            result = subprocess.run(cfg['command'], stdout=log, stderr=subprocess.STDOUT,
+                                    timeout=remaining, start_new_session=True,
+                                    preexec_fn=run_identity if cfg.get('untrusted_whole_verifier') else None)
+    if result.returncode:
+        raise RuntimeError(f'Original verifier exited with status {result.returncode}; inspect verifier.log')
+    if cfg.get('verify_crystal_assets_after'):
+        remaining = cfg['timeout_seconds'] - (time.monotonic() - entered)
+        if remaining <= 0:
+            raise TimeoutError('Verifier budget exhausted before post-score asset validation')
+        with (STATE / 'asset-validation-after.log').open('w') as log:
+            subprocess.run([cfg['driver_python'], '-c',
+                'import sys;sys.path.insert(0,"/tests");from pathlib import Path;'
+                'from grader import validate_assets;validate_assets(Path("/scorer-assets"));'
+                'print("ORIGINAL_SCORER_ASSET_DIGEST_OK")'],
+                stdout=log, stderr=subprocess.STDOUT, timeout=remaining, check=True)
+        if hashlib.sha256(Path('/scorer-assets/READY.json').read_bytes()).hexdigest() != crystal_cache_receipt['asset_manifest_sha256']:
+            raise RuntimeError('Scorer asset manifest changed during grading')
+        crystal_cache_receipt['original_asset_digest_after'] = 'passed'
+        runtime.write_json(STATE / 'dataset-cache.json', crystal_cache_receipt)
+    elapsed = time.monotonic() - entered
+    reward_path = STATE / 'results/reward.json'
+    if phase == 'score':
+        score_root = Path('/sealed/results')
+        if cfg.get('results_by_run_id'):
+            score_root /= json.loads(Path('/sealed/READY').read_text())['run_id']
+        for name in ('reward.json', 'report.json', 'agent_feedback.json'):
+            source = score_root / name
+            if source.exists():
+                shutil.copy2(source, STATE / 'results' / name)
+    reward = json.loads(reward_path.read_text()) if reward_path.exists() else None
+    ready = Path('/sealed/READY').is_file()
+    if reward is None and not (phase == 'inference' and ready):
+        raise RuntimeError('Verifier produced neither a reward nor sealed predictions')
+    status('complete', task=plan['task'], role=phase, elapsed_seconds=elapsed,
+           reward=reward, sealed_ready=ready)
+
+
+if __name__ == '__main__':
+    try:
+        main(sys.argv[1])
+    except Exception as error:
+        status('failed', error=f'{type(error).__name__}: {error}')
+        raise

reproduction/files/1c/1c96f70bde6addcf83179c92f5e5a0a4b2aeb5c8bed1c5bfea6a5a167ff575b1/grader.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Trusted labels-only service; never executes a submitted model or source."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+import sys
+import time
+from typing import Any
+PROJECT = Path(__file__).resolve().parents[1] / "environment" / "baseline" / "alphaqubit" if (Path(__file__).resolve().parents[1] / "environment" / "baseline" / "alphaqubit").is_dir() else Path(__file__).resolve().parents[1]  # the baseline project: environment/baseline/alphaqubit here, /opt/task in the verifier image
+sys.path.insert(0, str(PROJECT))
+from qecbench.data import contained, sha256, write_json
+from qecbench.scoring import InvalidPrediction, score
+
+
+def grade(sealed: Path, inputs: Path, labels: Path, config: Path, output: Path,
+          ready: dict[str, Any]) -> None:
+    run_id = ready["run_id"]
+    target = output / run_id
+    target.mkdir(parents=True)
+    try:
+        snapshot_path = contained(sealed, "snapshot.json")
+        if sha256(snapshot_path) != ready["snapshot_sha256"]:
+            raise ValueError("Sealed snapshot hash mismatch")
+        snapshot = json.loads(snapshot_path.read_text())
+        if snapshot.get("schema") != "surface-code-decoding-snapshot/v1" or snapshot.get("run_id") != run_id:
+            raise ValueError("Sealed snapshot identity mismatch")
+        if snapshot.get("input_manifest_sha256") != sha256(inputs / "manifest.json"):
+            raise ValueError("Input/snapshot mismatch")
+        actual = {path.name for path in sealed.iterdir() if path.name != "snapshot.json"}
+        if actual != set(snapshot["files"]):
+            raise ValueError("Sealed snapshot file coverage mismatch")
+        for name, digest in snapshot["files"].items():
+            if sha256(contained(sealed, name)) != digest:
+                raise ValueError("Sealed prediction checksum mismatch")
+        try:
+            result = score(inputs, sealed, labels, config)
+        except InvalidPrediction as error:
+            result = {"schema": "surface-code-decoding-report/v1", "status": "invalid_prediction",
+                "model_quality_measured": False, "score": 0.0, "score_unclipped": None,
+                "performance": None, "error": str(error)}
+        result["run_id"] = run_id
+        write_json(target / "report.json", result)
+        write_json(target / "reward.json", {"reward": result["performance"]})  # raw P; the normalized score stays in report.json
+    except Exception as error:
+        write_json(target / "report.json", {"schema": "surface-code-decoding-report/v1", "run_id": run_id,
+            "status": "infrastructure_error", "model_quality_measured": False,
+            "error": f"{type(error).__name__}: {error}"})
+    write_json(target / "DONE", {"run_id": run_id})
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--sealed", type=Path, default=Path("/sealed/run"))
+    parser.add_argument("--input", type=Path, default=Path("/benchmark"))
+    parser.add_argument("--labels", type=Path, default=Path("/private"))
+    parser.add_argument("--config", type=Path, default=Path("/opt/task/score_config.json"))
+    parser.add_argument("--output", type=Path, default=Path("/sealed/results"))
+    parser.add_argument("--wait-seconds", type=int, default=3900)
+    args = parser.parse_args()
+    deadline = time.monotonic() + args.wait_seconds
+    while time.monotonic() < deadline:
+        ready = args.sealed.parent / "READY"
+        if ready.is_file():
+            payload = json.loads(ready.read_text())
+            run_id = payload.get("run_id", "")
+            if len(run_id) != 32 or any(c not in "0123456789abcdef" for c in run_id):
+                raise ValueError("Invalid trusted run identity")
+            grade(args.sealed, args.input, args.labels, args.config, args.output, payload)
+            return
+        time.sleep(0.25)
+    raise TimeoutError("Inference supervisor did not seal a submission")
+
+
+if __name__ == "__main__":
+    main()

reproduction/files/1d/1d5ba0e3f6977b88e95f7c60f3e009a37ea398b47c5488deb44875335aff74e5/test_research_tools.py

@@ -0,0 +1,325 @@
+"""Regression tests for interrupted publication and scientific feedback."""
+
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / 'environment/evaluation'))
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+publication = load('publication', ROOT / 'environment/baseline/starter/publication.py')
+diagnostics = load('diagnostics', ROOT / 'environment/evaluation/diagnostics.py')
+sys.modules['diagnostics'] = diagnostics
+score = load('validation_score', ROOT / 'environment/evaluation/score.py')
+paired = load('paired_score', ROOT / 'environment/evaluation/paired_bootstrap.py')
+sys.path.insert(0, str(ROOT / 'tests'))
+import main_verifier
+
+
+def build(stage, marker):
+    (stage / 'README.md').write_text(marker)
+    (stage / 'weights.pt').write_bytes(marker.encode())
+    (stage / 'config.json').write_text('{}')
+    (stage / 'infer.sh').write_text('#!/bin/bash\nprintf "%s\\n" ' + marker + '\n')
+    (stage / 'model_manifest.json').write_text(json.dumps({
+        'schema': 'massspecgym-retrieval-model/v1',
+        'checkpoint': {'path': 'weights.pt', 'sha256': hashlib.sha256(marker.encode()).hexdigest(), 'format': 'pytorch'},
+        'model_config': 'config.json', 'training_provenance': {'data': 'fixture', 'pretrained_assets': []},
+    }))
+
+
+class NativePublicationTests(unittest.TestCase):
+    def setUp(self) -> None:
+        import torch
+        self.temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temporary.cleanup)
+        self.root = Path(self.temporary.name)
+        self.native = load('native_publish', ROOT / 'environment/baseline/starter/glacier/publish.py')
+        self.checkpoint = self.root / 'trained.ckpt'
+        self.state = {
+            'state_dict': {'fixture.weight': torch.tensor([1.0, 2.0])},
+            'hyper_parameters': json.loads((ROOT / 'environment/baseline/starter/glacier/config.json').read_text()),
+            'pytorch-lightning_version': '2.6.5', 'global_step': 10, 'epoch': 1,
+            'task_training': {'initialization': 'random', 'batch_size': 8,
+                              'data_manifest_sha256': 'a' * 64},
+        }
+        torch.save(self.state, self.checkpoint)
+        self.fallback = self.root / 'fallback'
+        self.fallback.mkdir()
+        build(self.fallback, 'trained-fallback-fixture')
+        self.source = self.root / 'source'
+        (self.source / 'src/ms_pred').mkdir(parents=True)
+        (self.source / 'src/ms_pred/__init__.py').write_text('# source fixture\n')
+        (self.source / 'LICENSE').write_text('fixture license\n')
+
+    def command(self, destination: Path) -> list[str]:
+        return [sys.executable, str(ROOT / 'environment/baseline/starter/glacier/publish.py'),
+                '--checkpoint', str(self.checkpoint), '--fallback', str(self.fallback),
+                '--source-root', str(self.source), '--output-dir', str(destination)]
+
+    def assert_native_invocation(self, generation: Path, batch_size: int) -> None:
+        """Exercise the published adapter with bounded stand-ins for model execution."""
+        native_infer = load('published_native_infer', generation / 'infer.py')
+        input_root, output_root = self.root / 'public-input', self.root / 'rankings'
+
+        def run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess:
+            script = Path(command[1]).name
+            if script == 'stage_input.py':
+                partition = Path(command[command.index('--output-root') + 1])
+                for branch in ('glacier', 'fallback'):
+                    (partition / branch).mkdir(parents=True)
+                    (partition / branch / 'queries.jsonl').write_text('{}\n')
+            elif script == 'prepare_glacier_candidates.py':
+                Path(command[command.index('--output') + 1]).write_text('smiles\nCCO\n')
+            elif script == 'merge_glacier_fallback.py':
+                (output_root / 'runtime.json').write_text('{}\n')
+            return subprocess.CompletedProcess(command, 0)
+
+        with mock.patch.object(sys, 'argv', ['infer.py', str(input_root), str(output_root)]), \
+                mock.patch.object(native_infer.subprocess, 'run', side_effect=run) as execute:
+            native_infer.main()
+        commands = [call.args[0] for call in execute.call_args_list]
+        predictor = next(command for command in commands if Path(command[1]).name == 'predict_smis_joint.py')
+        for option, value in {'--batch-size': batch_size, '--num-cpu-workers': 2,
+                              '--feat-cache-size': 64, '--prefetch-factor': 1}.items():
+            self.assertEqual(predictor[predictor.index(option) + 1], str(value))
+        self.assertEqual(predictor[predictor.index('--checkpoint') + 1], str(generation / 'glacier.ckpt'))
+        scorer = next(command for command in commands if Path(command[1]).name == 'score_glacier_predictions.py')
+        self.assertEqual(scorer[scorer.index('--distance') + 1], 'entropy')
+        self.assertTrue(any(command[:2] == ['bash', str(generation / 'fallback/infer.sh')] for command in commands))
+        self.assertFalse((output_root / 'runtime.json').exists())
+
+    def test_default_and_cli_override_preserve_model_and_training(self) -> None:
+        import torch
+        configs = []
+        for name, override, batch_size in [('api-default', None, 64),
+                                           ('cli-default', None, 64), ('cli-small', 8, 8)]:
+            with self.subTest(name=name):
+                destination = self.root / name
+                if name == 'api-default':
+                    self.native.publish(self.checkpoint, self.fallback, self.source, destination)
+                else:
+                    command = self.command(destination)
+                    if override is not None:
+                        command.extend(['--inference-batch-size', str(override)])
+                    subprocess.run(command, check=True, capture_output=True, text=True)
+                # Publication must remain portable, including its selected generation.
+                relocated = self.root / (name + '-relocated')
+                shutil.move(destination, relocated)
+                manifest = main_verifier.validate_submission(relocated)
+                config = json.loads((relocated / manifest['model_config']).read_text())
+                configs.append(config)
+                self.assertEqual(config['batch_size'], batch_size)
+                self.assertEqual(config['training'], self.state['task_training'])
+                self.assertEqual(config['method'], 'native-glacier-with-trained-deepsets-fallback')
+                self.assertEqual(config['routing'], 'released_conditions_with_usable_observation_and_supported_pool')
+                self.assertEqual(manifest['training_provenance'], {
+                    'data': 'MassSpecGym v1.5 train; validation for selection only', 'pretrained_assets': []})
+                saved = torch.load(relocated / manifest['checkpoint']['path'], weights_only=False)
+                self.assertTrue(torch.equal(saved.pop('state_dict')['fixture.weight'],
+                                            self.state['state_dict']['fixture.weight']))
+                self.assertEqual(saved, {key: value for key, value in self.state.items() if key != 'state_dict'})
+                generation = (relocated / manifest['model_config']).parent
+                for name in ['stage_input.py', 'config.json', 'train.py']:
+                    source = ROOT / 'environment/baseline/starter/glacier' / name
+                    target = generation / ('stage_input.py' if name == 'stage_input.py' else 'training/' + name)
+                    self.assertEqual(target.read_bytes(), source.read_bytes())
+                self.assertEqual((generation / 'fallback/weights.pt').read_bytes(),
+                                 (self.fallback / 'weights.pt').read_bytes())
+                self.assert_native_invocation(generation, batch_size)
+        self.assertEqual(configs[0], configs[1])
+        self.assertEqual(configs[0], {**configs[2], 'batch_size': 64})
+
+    def test_invalid_api_batch_preserves_existing_publication(self) -> None:
+        destination = self.root / 'published'
+        self.native.publish(self.checkpoint, self.fallback, self.source, destination)
+        before = (destination / 'model_manifest.json').read_bytes()
+        for value in (0, -1, 1.5, '8', True):
+            with self.subTest(value=value), self.assertRaisesRegex(ValueError, 'positive integer'):
+                self.native.publish(self.checkpoint, self.fallback, self.source, destination,
+                                    inference_batch_size=value)
+            self.assertEqual((destination / 'model_manifest.json').read_bytes(), before)
+
+    def test_invalid_cli_batch_fails_before_publication(self) -> None:
+        destination = self.root / 'invalid'
+        for value in ('0', '-1', '1.5', 'invalid'):
+            with self.subTest(value=value):
+                result = subprocess.run(self.command(destination) + ['--inference-batch-size', value],
+                                        capture_output=True, text=True)
+                self.assertEqual(result.returncode, 2)
+                self.assertIn('inference batch size must be a positive integer', result.stderr)
+                self.assertFalse(destination.exists())
+
+
+class ResearchToolsTests(unittest.TestCase):
+    def test_native_routes_unsupported_valid_inputs_to_the_trained_fallback(self):
+        native = load('native_stage', ROOT / 'environment/baseline/starter/glacier/stage_input.py')
+        self.assertTrue(native.supports_pool([{'smiles': 'CCO'}], {1, 6, 7, 8}))
+        self.assertFalse(native.supports_pool([{'smiles': 'C' * 101}], {1, 6, 7, 8}))
+        self.assertFalse(native.supports_observation(dict(mzs=[1500.0], intensities=[1.0], precursor_mz=200.0)))
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            source = root / 'input'; source.mkdir()
+            ordinary = dict(query_id='ordinary', candidate_pool_id='p', mzs=[50.0],
+                            intensities=[1.0], precursor_mz=100.0)
+            queries = [ordinary, dict(ordinary, query_id='outside', mzs=[1500.0]),
+                       dict(ordinary, query_id='large-pool', candidate_pool_id='large')]
+            pools = [{'candidate_pool_id': 'p', 'candidates': [{'candidate_id': 'c', 'smiles': 'CCO'}]},
+                     {'candidate_pool_id': 'large', 'candidates': [{'candidate_id': 'large-c', 'smiles': 'C' * 101}]}]
+            for filename, rows in [('queries.jsonl', queries), ('candidate_pools.jsonl', pools)]:
+                (source / filename).write_text(''.join(json.dumps(row) + '\n' for row in rows))
+            native.partition(source, root / 'output', {1, 6, 7, 8}, lambda query: True)
+            self.assertEqual((root / 'output/glacier-query-ids.txt').read_text(), 'ordinary\n')
+            fallback = [json.loads(line) for line in (root / 'output/fallback/queries.jsonl').read_text().splitlines()]
+            self.assertEqual({row['query_id'] for row in fallback}, {'outside', 'large-pool'})
+            self.assertEqual(len(fallback) + 1, len(queries))
+
+    def test_resuming_fit_state_does_not_refund_completed_validation(self):
+        native = load('native_train', ROOT / 'environment/baseline/starter/glacier/train.py')
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            # A fit checkpoint precedes expensive final validation/export.
+            self.assertEqual(native.charged_elapsed(root, 190), 190)
+            (root / 'result.json').write_text(json.dumps({'elapsed_seconds': 567}))
+            self.assertEqual(native.charged_elapsed(root, 190), 567)
+            # A later interrupted segment must retain its greater usage too.
+            self.assertEqual(native.charged_elapsed(root, 800), 800)
+            (root / 'budget-ledger.json').write_text(json.dumps({'elapsed_seconds': 900}))
+            self.assertEqual(native.charged_elapsed(root, 800), 900)
+
+    def test_unparseable_candidate_has_a_finite_fallback_but_training_stays_strict(self):
+        import torch
+        starter = load('starter_common', ROOT / 'environment/baseline/starter/common.py')
+        # Invalid in every RDKit version exercises the same boundary as legacy
+        # valences accepted by the task's RDKit 2023 but rejected by 2025.
+        with self.assertRaisesRegex(ValueError, 'invalid candidate SMILES'):
+            starter.morgan_fingerprint('not_a_smiles')
+        fp = starter.morgan_fingerprint('not_a_smiles', allow_unparseable=True)
+        self.assertTrue(torch.isfinite(fp).all())
+        self.assertEqual(tuple(fp.shape), (4096,))
+        self.assertEqual(int(torch.count_nonzero(fp)), 0)
+        self.assertTrue(torch.equal(starter.morgan_fingerprint('CCO'),
+                                    starter.morgan_fingerprint('CCO', allow_unparseable=True)))
+
+    def test_starter_accepts_valid_spectra_outside_its_preprocessing_window(self):
+        import torch
+        starter = load('starter_common', ROOT / 'environment/baseline/starter/common.py')
+        for mzs, intensities in [([1500.0], [1.0]), ([50.0, 1500.0], [0.0, 1.0])]:
+            with self.subTest(mzs=mzs):
+                encoded = starter.spectrum_tensor(dict(
+                    mzs=mzs, intensities=intensities, precursor_mz=1600.0))
+                self.assertTrue(torch.isfinite(encoded).all())
+                self.assertEqual(tuple(encoded.shape), (61, 2))
+                self.assertEqual(float(encoded[0, 0]), 1600.0)
+                self.assertEqual(int(torch.count_nonzero(encoded[1:])), 0)
+        with self.assertRaisesRegex(ValueError, 'maximum intensity must be positive'):
+            starter.spectrum_tensor(dict(mzs=[1500.0], intensities=[0.0], precursor_mz=1600.0))
+
+    def test_declared_external_weights_are_not_authorized_by_manifest(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            build(root, 'fixture')
+            manifest = main_verifier.validate_submission(root)
+            manifest['training_provenance']['pretrained_assets'] = [
+                {'name': 'external', 'revision': 'immutable', 'license': 'MIT'}]
+            (root / 'model_manifest.json').write_text(json.dumps(manifest))
+            with self.assertRaisesRegex(ValueError, 'no authorized pretrained'):
+                main_verifier.validate_submission(root)
+
+    def test_failed_publication_preserves_previous_runnable_model(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary) / 'submission'
+            publication.publish_directory(root, lambda stage: build(stage, 'first'))
+            for path in [root, *root.rglob('*')]:
+                if path.is_dir():
+                    self.assertEqual(path.stat().st_mode & 0o005, 0o005)
+                else:
+                    self.assertEqual(path.stat().st_mode & 0o004, 0o004)
+            before = (root / 'model_manifest.json').read_bytes()
+            def interrupted(stage):
+                build(stage, 'unfinished')
+                raise RuntimeError('simulated preemption while exporting')
+            with self.assertRaises(RuntimeError):
+                publication.publish_directory(root, interrupted)
+            self.assertEqual(before, (root / 'model_manifest.json').read_bytes())
+            publication.publish_directory(root, lambda stage: build(stage, 'second'))
+            relocated = Path(temporary) / 'elsewhere'
+            shutil.copytree(root, relocated)
+            shutil.rmtree(root)
+            self.assertEqual(subprocess.check_output(['bash', str(relocated / 'infer.sh')], text=True).strip(), 'second')
+            # A reader which captured the old manifest still has all its assets.
+            old = json.loads(before)
+            self.assertEqual((relocated / old['checkpoint']['path']).read_text(), 'first')
+            compact = Path(temporary) / 'compact'
+            publication.snapshot_package(relocated, compact)
+            self.assertFalse((compact / old['checkpoint']['path']).exists())
+            self.assertEqual(subprocess.check_output(['bash', str(compact / 'infer.sh')], text=True).strip(), 'second')
+
+    def test_escaping_publication_is_rejected_without_replacing_manifest(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary) / 'submission'
+            publication.publish_directory(root, lambda stage: build(stage, 'first'))
+            before = (root / 'model_manifest.json').read_bytes()
+            def escaping(stage):
+                build(stage, 'bad')
+                (stage / 'external').symlink_to('/etc/passwd')
+            with self.assertRaises(ValueError):
+                publication.publish_directory(root, escaping)
+            self.assertEqual(before, (root / 'model_manifest.json').read_bytes())
+
+    def test_cluster_bootstrap_keeps_spectrum_weighting(self):
+        # One molecule has nine spectra, the other one: macro would be 0.5.
+        report = diagnostics.cluster_interval([1] * 9 + [0], ['A'] * 9 + ['B'], resamples=500, seed=7)
+        self.assertEqual(report['estimate'], 0.9)
+        self.assertEqual(report['molecule_groups'], 2)
+        self.assertEqual(report['lower'], 0)
+        self.assertEqual(report['upper'], 1)
+        self.assertEqual(report, diagnostics.cluster_interval([1] * 9 + [0], ['A'] * 9 + ['B'], resamples=500, seed=7))
+
+    def test_no_difference_has_zero_paired_interval(self):
+        report = diagnostics.cluster_interval([0, 0, 0], ['A', 'A', 'B'], resamples=100)
+        self.assertEqual((report['estimate'], report['lower'], report['upper']), (0, 0, 0))
+
+    def test_paired_report_resamples_molecules_without_changing_delta(self):
+        truth = {f'q{i}': 'a' for i in range(10)}
+        baseline = {q: 'b' for q in truth}
+        challenger = {q: 'a' if q != 'q9' else 'b' for q in truth}
+        groups = {q: 'A' if q != 'q9' else 'B' for q in truth}
+        report = paired.compare(truth, baseline, challenger, confidence=0.95, resamples=500, seed=7, groups=groups)
+        self.assertEqual(report['delta'], 0.9)
+        self.assertEqual(report['molecule_groups'], 2)
+        self.assertEqual(report['interval'], [0, 1])
+        self.assertFalse(report['beats_reference'])
+
+    def test_validation_rejects_nested_or_partial_rankings(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / 'rankings.jsonl'
+            for ranking in [[['a'], 'b'], ['a'], ['a', 'a']]:
+                path.write_text(json.dumps({'query_id': 'q', 'ranking': ranking}) + '\n')
+                with self.assertRaises(ValueError):
+                    score.load_rankings(path, {'q': {'pool': 'p'}}, {'p': [{'candidate_id': 'a'}, {'candidate_id': 'b'}]})
+
+    def test_routing_does_not_treat_missing_energy_as_zero(self):
+        row = {'adduct': '[M+H]+', 'instrument_type': 'Orbitrap', 'collision_energy': None}
+        self.assertFalse(diagnostics.released_domain(row))
+        self.assertTrue(diagnostics.released_domain(dict(row, collision_energy=0.0)))
+        self.assertFalse(diagnostics.released_domain(dict(row, collision_energy=float('nan'))))
+
+
+if __name__ == '__main__':
+    unittest.main()

reproduction/files/1f/1f6f9a2579d1877217e9aba9c6c9eabcd30cac45975eee58c07e7a7bf00dd1ea/novelty.py

@@ -0,0 +1,61 @@
+"""Novelty against the fit corpus: the largest TM-score of a design to any fit chain.
+
+Protein-design benchmarks report novelty as the maximum TM-score of each designable design to the PDB or the
+training set, computed with Foldseek in TM-align mode (lower is more novel); generative models typically sit
+around 0.45-0.8 depending on the task. A design therefore passes only if, besides the published designability
+criterion, its maximum TM-score to the fit corpus is below `common.NOVELTY_MAX_TM`.
+
+The reference is the fit corpus the agent trains on (`development/fit/structures`), mounted read-only into
+the grader; its Foldseek database is built once per grading run (a few minutes on 16k structures).
+"""
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+FOLDSEEK = os.environ.get("FOLDSEEK", "/opt/foldseek/bin/foldseek")
+
+
+class FitNovelty:
+    def __init__(self, reference_dir, workdir=None, threads=None, foldseek=FOLDSEEK):
+        self.reference_dir = Path(reference_dir)
+        if not any(self.reference_dir.rglob("*.cif*")):
+            raise FileNotFoundError(f"novelty reference has no structures: {self.reference_dir}")
+        self.foldseek = foldseek
+        self.threads = str(threads or os.cpu_count() or 1)
+        self.work = Path(workdir or tempfile.mkdtemp(prefix="novelty-"))
+        self.db = self.work / "fitdb"
+        self._run("createdb", str(self.reference_dir), str(self.db), "--threads", self.threads)
+
+    def _run(self, *arguments):
+        subprocess.run([self.foldseek, *arguments], check=True, stdout=subprocess.DEVNULL,
+                       stderr=subprocess.PIPE)
+
+    def max_tm(self, designs):
+        """designs: {key: PDB path} -> {key: max TM-score (normalized by the design) to any fit chain}."""
+        if not designs:
+            return {}
+        query = Path(tempfile.mkdtemp(dir=self.work, prefix="query-"))
+        try:
+            names = {}
+            for index, (key, path) in enumerate(designs.items()):
+                name = f"q{index}"
+                shutil.copyfile(path, query / f"{name}.pdb")
+                names[name] = key
+            self._run("createdb", str(query), str(query / "db"), "--threads", self.threads)
+            # TM-align alignment of every prefilter hit; -a keeps the alignment so qtmscore can be reported.
+            self._run("search", str(query / "db"), str(self.db), str(query / "aln"), str(query / "tmp"),
+                      "--alignment-type", "1", "-a", "-e", "inf", "--max-seqs", "1000", "-s", "9.5",
+                      "--threads", self.threads)
+            self._run("convertalis", str(query / "db"), str(self.db), str(query / "aln"),
+                      str(query / "hits.tsv"), "--format-output", "query,target,qtmscore")
+            best = {key: 0.0 for key in designs}
+            for line in (query / "hits.tsv").read_text().splitlines():
+                name, _, score = line.split("\t")
+                key = names.get(name.split("_")[0])
+                if key is not None:
+                    best[key] = max(best[key], float(score))
+            return best
+        finally:
+            shutil.rmtree(query, ignore_errors=True)

reproduction/files/1f/1fb4ffce095d7d563544d2826539a9113032c80c3907c9e746c93e0dcbe677ff/make_zero_predictions.py

@@ -0,0 +1,12 @@
+"""Create the deterministic all-zero sanity baseline."""
+import argparse,json
+from pathlib import Path
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+ap=argparse.ArgumentParser();ap.add_argument("--input",type=Path,required=True);ap.add_argument("--output",type=Path,required=True);a=ap.parse_args()
+m=json.loads((a.input/"manifest.json").read_text());d=len(m["scored_diseases"]);h=len(m["horizons_days"])
+ids=pq.read_table(a.input/"samples.parquet",columns=["sample_id"])["sample_id"].to_pylist()
+schema=pa.schema([pa.field("sample_id",pa.string()),pa.field("disease_risk",pa.list_(pa.float32(),d*h)),pa.field("death_risk",pa.list_(pa.float32(),h))])
+row_d=[0.0]*(d*h);row_h=[0.0]*h;a.output.parent.mkdir(parents=True,exist_ok=True)
+pq.write_table(pa.Table.from_pylist([{"sample_id":x,"disease_risk":row_d,"death_risk":row_h} for x in ids],schema=schema),a.output,compression="zstd")

reproduction/files/1f/1fff1846a4ec5dcc7e2beb2eda5dbb97f35494d686a33e4a62974d482a8e583b/evaluate_native.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+# Bootstrap the image's Python libraries without loading CUDA solver modules.
+# The Python dispatcher selects the solver runtime separately for each case.
+exec bash "$root/native_runtime.sh" jax python "$root/evaluate_native.py" "$@"

reproduction/files/22/224957d662239021e18f16650cebeefedd5515b8b94454d64fc3064e98bb1a43/test_contract.py

@@ -0,0 +1,86 @@
+"""Checks ID alignment, rejection of malformed output, and test isolation."""
+
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+import numpy as np
+
+SCRIPT = Path(__file__).resolve().parents[1] / "environment/evaluation/probes.py"
+
+
+class ProbeContract(unittest.TestCase):
+    def test_alignment_failures_and_test_isolation(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            rng = np.random.default_rng(24)
+            x = rng.normal(size=(110, 12))
+            y = x[:, 0] * 4 + x[:, 1] * 2
+            rows = [
+                {
+                    "id": f"new-id-{i}",
+                    "label": float(y[i]),
+                    "split": "train" if i < 70 else "val" if i < 90 else "test",
+                }
+                for i in range(110)
+            ]
+            labels = root / "labels.json"
+            labels.write_text(json.dumps(rows))
+            ids = np.array([r["id"] for r in rows])
+            features = root / "features.npz"
+            cmd = [
+                sys.executable,
+                str(SCRIPT),
+                "--features",
+                str(features),
+                "--labels",
+                str(labels),
+                "--task",
+                "lfmc",
+                "--output",
+                str(root / "score.json"),
+                "--final-test",
+            ]
+
+            def run():
+                return subprocess.run(cmd, capture_output=True, text=True)
+
+            np.savez(features, ids=ids, features=x)
+            self.assertEqual(run().returncode, 0)
+            original = json.loads((root / "score.json").read_text())
+            perm = rng.permutation(len(ids))
+            np.savez(features, ids=ids[perm], features=x[perm])
+            self.assertEqual(run().returncode, 0)
+            self.assertEqual(original, json.loads((root / "score.json").read_text()))
+            for row in rows[90:]:
+                row["label"] += 100
+            labels.write_text(json.dumps(rows))
+            self.assertEqual(run().returncode, 0)
+            altered = json.loads((root / "score.json").read_text())
+            self.assertEqual(
+                original["probe"]["selected_parameter"],
+                altered["probe"]["selected_parameter"],
+            )
+            self.assertEqual(
+                original["probe"]["validation"], altered["probe"]["validation"]
+            )
+            self.assertNotEqual(original["probe"]["test"], altered["probe"]["test"])
+            np.savez(features, ids=ids[:-1], features=x[:-1])
+            self.assertNotEqual(run().returncode, 0)
+            np.savez(features, ids=np.repeat(ids[:1], len(ids)), features=x)
+            self.assertNotEqual(run().returncode, 0)
+            np.savez(
+                features,
+                ids=np.concatenate([ids, ids[:1]]),
+                features=np.concatenate([x, x[:1]]),
+            )
+            self.assertNotEqual(run().returncode, 0)
+            x[0, 0] = float("nan")
+            np.savez(features, ids=ids, features=x)
+            self.assertNotEqual(run().returncode, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

reproduction/files/24/24cdd224ba6133de77df91462bb66d12b3432ee2b21cd85e24379c7813b44561/check_training_recovery.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Real native-model recovery integration check; run in the GLACIER runtime."""
+
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+import torch
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    for name in ['data-root', 'fallback', 'output']:
+        parser.add_argument('--' + name, type=Path, required=True)
+    parser.add_argument('--source-root', type=Path, default=Path('/opt/ms-pred'))
+    parser.add_argument('--workers', type=int, default=0)
+    args = parser.parse_args()
+    args.output.mkdir(parents=True, exist_ok=False)
+    script = Path(__file__).resolve().parents[1] / 'environment/baseline/starter/glacier/train.py'
+    for name, steps, resume in [('resumed', 2, False), ('resumed', 4, True), ('continuous', 4, False)]:
+        command = [sys.executable, str(script), '--data-root', str(args.data_root),
+                   '--source-root', str(args.source_root), '--work-dir', str(args.output / name),
+                   '--fallback', str(args.fallback), '--submission-dir', str(args.output / (name + '-submission')),
+                   '--max-steps', str(steps), '--device', 'cpu', '--workers', str(args.workers), '--batch-size', '1',
+                   '--accumulate-grad-batches', '1', '--validate-every', '1', '--checkpoint-every', '500',
+                   '--max-seconds', '600', '--trace-batches']
+        if resume:
+            command += ['--resume', str(args.output / name / 'last.ckpt')]
+        with (args.output / f'{name}-{steps}.log').open('w') as log:
+            subprocess.run(command, check=True, env=dict(os.environ, OMP_NUM_THREADS='2'), stdout=log, stderr=subprocess.STDOUT)
+    resumed = torch.load(args.output / 'resumed/last.ckpt', map_location='cpu', weights_only=False)
+    continuous = torch.load(args.output / 'continuous/last.ckpt', map_location='cpu', weights_only=False)
+    different = [key for key, value in resumed['state_dict'].items() if not torch.equal(value, continuous['state_dict'][key])]
+    same_batches = ((args.output / 'resumed/batch-trace.jsonl').read_bytes() ==
+                    (args.output / 'continuous/batch-trace.jsonl').read_bytes())
+    report = {'global_steps': [resumed['global_step'], continuous['global_step']],
+              'magma_steps': [resumed['task_magma_step'], continuous['task_magma_step']],
+              'differing_parameter_tensors': different, 'identical_batch_order_and_rng': same_batches,
+              'scope': f'CPU, loader workers={args.workers}, same pinned runtime; not cross-hardware determinism'}
+    (args.output / 'report.json').write_text(json.dumps(report, indent=2) + '\n')
+    if different or not same_batches or report['global_steps'] != [4, 4] or report['magma_steps'] != [4, 4]:
+        raise AssertionError(report)
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == '__main__':
+    main()

reproduction/files/25/25821b034a3b87b31eb7bd03c266decee1a2de037c3680796119f04c0740c63d/test_heldout_confirmation.py

@@ -0,0 +1,220 @@
+"""A failed cohort cannot unlock test reporting; test labels cannot choose alpha."""
+
+import hashlib
+import json
+import os
+import runpy
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+import numpy as np
+from sklearn.linear_model import Ridge
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+
+class HeldoutConfirmationTest(unittest.TestCase):
+    def test_legacy_random_provenance(self):
+        sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "docs/analysis"))
+        check = runpy.run_path(
+            str(Path(__file__).resolve().parents[1] / "docs/analysis/heldout_confirmation.py")
+        )["is_random_initialization"]
+        self.assertTrue(check({"checkpoint": None}))
+        self.assertTrue(check({"origin": "random_initialization"}))
+        self.assertFalse(check({}))
+        self.assertFalse(check({"checkpoint": "weights.pt"}))
+        self.assertFalse(
+            check(
+                {"origin": "official_public_pretrained_reference", "checkpoint": None}
+            )
+        )
+
+    def test_lock_gate_and_fixed_probe_parameters(self):
+        script = Path(__file__).resolve().parents[1] / "docs/analysis/heldout_confirmation.py"
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "results").mkdir()
+            context = {"gpu_type": "a5000", "python_hash_seed": 0}
+            (root / "execution-context.json").write_text(json.dumps(context))
+            seeds, loader_seeds = [12536, 12539, 12540], [3622, 3625, 3626]
+            pairs = [
+                [f"large-random-eval-{seed}", f"train-{seed}-step6000"]
+                for seed in seeds
+            ]
+            recipe = {"global_batch": 64, "checkpoint_step": "step6000"}
+            lock = {
+                "selected": pairs[0][1],
+                "checkpoint_step": 6000,
+                "training_recipe": recipe,
+                "policy": {"development_seed": seeds[0], "execution_context": context},
+                "confirmation": [
+                    {
+                        "name": f"train-{seed}",
+                        "initialization_seed": seed,
+                        "data_seed": loader,
+                        "paired_random": pair[0],
+                    }
+                    for seed, loader, pair in zip(
+                        seeds[1:], loader_seeds[1:], pairs[1:]
+                    )
+                ],
+            }
+            comparison = {
+                "split": "val",
+                "pairs": pairs,
+                "initialization_seeds": seeds,
+                "data_seeds": loader_seeds,
+                "execution_context": context,
+                "tasks": {"lfmc": {"three_seed_criterion_met": False}},
+            }
+            lock_path, comparison_path = root / "lock.json", root / "comparison.json"
+            lock_path.write_text(json.dumps(lock))
+            comparison_path.write_text(json.dumps(comparison))
+            cmd = [
+                sys.executable,
+                str(script),
+                "--data-root",
+                str(root),
+                "--lock",
+                str(lock_path),
+                "--validation-comparison",
+                str(comparison_path),
+                "--output",
+                str(root / "test.json"),
+            ]
+            env = dict(
+                os.environ,
+                CUDA_VISIBLE_DEVICES="",
+                OMP_NUM_THREADS="1",
+                OPENBLAS_NUM_THREADS="1",
+            )
+            failed = subprocess.run(cmd, env=env, capture_output=True, text=True)
+            self.assertNotEqual(failed.returncode, 0)
+            self.assertIn("Validation confirmation has not passed", failed.stderr)
+            self.assertFalse((root / "eval").exists())
+            rng = np.random.default_rng(12)
+            y = rng.normal(size=100) * 3
+            ids = np.array([f"id-{i}" for i in range(len(y))])
+            rows = [
+                {
+                    "id": str(id_),
+                    "label": float(y[i]),
+                    "split": "train" if i < 60 else "val" if i < 80 else "test",
+                    "latlon": [float(i), 0.0],
+                }
+                for i, id_ in enumerate(ids)
+            ]
+            labels = root / "eval/lfmc/labels.json"
+            labels.parent.mkdir(parents=True)
+            labels.write_text(json.dumps(rows))
+            names = [n for pair in pairs for n in pair] + ["large-raw"]
+            for name in names:
+                x = rng.normal(size=(len(y), 8))
+                if name.startswith("train-") or name == "large-raw":
+                    x[:, 0] = y
+                feature = root / "features" / f"{name}-lfmc" / "features.npz"
+                feature.parent.mkdir(parents=True)
+                np.savez(feature, ids=ids, features=x.astype(np.float32))
+                x = x.astype(np.float32).astype(np.float64)
+                model = make_pipeline(StandardScaler(), Ridge(alpha=1.0)).fit(
+                    x[:60], y[:60]
+                )
+                report = {
+                    "features": str(feature),
+                    "probe": {
+                        "selected_parameter": 1.0,
+                        "validation": {
+                            "mae": float(
+                                np.abs(model.predict(x[60:80]) - y[60:80]).mean()
+                            )
+                        },
+                    },
+                }
+                (root / "results" / f"{name}-lfmc.json").write_text(json.dumps(report))
+            for seed, loader, pair in zip(seeds, loader_seeds, pairs):
+                for index, name in enumerate(pair):
+                    package = root / "packages" / name
+                    package.mkdir(parents=True)
+                    (package / "encoder.pt").write_bytes(name.encode())
+                    sha = hashlib.sha256(name.encode()).hexdigest()
+                    provenance = {
+                        "origin": "random_initialization"
+                        if index == 0
+                        else "own_from_scratch_training",
+                        "initialization_seed": seed,
+                        "data_seed": loader if index else None,
+                        "training_recipe": recipe if index else None,
+                        "variant": "v1/large",
+                        "parameters": 307770368,
+                        "infer_sha256": "fixture",
+                        "encoder_sha256": sha,
+                    }
+                    if index == 0 and seed == seeds[0]:
+                        del provenance["origin"]
+                        provenance["checkpoint"] = None
+                    (package / "provenance.json").write_text(json.dumps(provenance))
+                    if name == lock["selected"]:
+                        lock["encoder_sha256"] = sha
+            lock_path.write_text(json.dumps(lock))
+            comparison["tasks"]["lfmc"]["three_seed_criterion_met"] = True
+            comparison["tasks"]["lfmc"].update(
+                per_seed_gain=[1.0, 1.0, 1.0],
+                mean_seed_gain=1.0,
+                spatial_bootstrap_95_percent_interval=[0.1, 2.0],
+                seed_and_spatial_bootstrap_95_percent_interval=[0.1, 2.0],
+            )
+            comparison["tasks"]["lfmc"][
+                "seed_and_spatial_bootstrap_95_percent_interval"
+            ][0] = -0.1
+            comparison_path.write_text(json.dumps(comparison))
+            failed = subprocess.run(cmd, env=env, capture_output=True, text=True)
+            self.assertNotEqual(failed.returncode, 0)
+            self.assertIn("flag disagrees", failed.stderr)
+            self.assertFalse((root / "test.json").exists())
+            comparison["tasks"]["lfmc"][
+                "seed_and_spatial_bootstrap_95_percent_interval"
+            ][0] = 0.1
+            comparison_path.write_text(json.dumps(comparison))
+            run = subprocess.run(cmd, env=env, capture_output=True, text=True)
+            self.assertEqual(run.returncode, 0, run.stderr)
+            first = json.loads((root / "test.json").read_text())
+            self.assertEqual(first["paired_random_comparison"]["rows"], 20)
+            self.assertEqual(first["paired_random_comparison"]["groups"], 20)
+            repeated = subprocess.run(cmd, env=env, capture_output=True, text=True)
+            self.assertNotEqual(repeated.returncode, 0)
+            for row in rows[80:]:
+                row["label"] += 100
+            labels.write_text(json.dumps(rows))
+            cmd[-1] = str(root / "changed-test-labels.json")
+            run = subprocess.run(cmd, env=env, capture_output=True, text=True)
+            self.assertEqual(run.returncode, 0, run.stderr)
+            altered = json.loads((root / "changed-test-labels.json").read_text())
+            for name in names:
+                self.assertEqual(
+                    first["models"][name]["selected_alpha_from_validation"],
+                    altered["models"][name]["selected_alpha_from_validation"],
+                )
+                self.assertEqual(
+                    first["models"][name]["validation_mae_check"],
+                    altered["models"][name]["validation_mae_check"],
+                )
+                self.assertNotEqual(
+                    first["models"][name]["test_mae"],
+                    altered["models"][name]["test_mae"],
+                )
+            changed = root / "packages" / pairs[1][1] / "provenance.json"
+            provenance = json.loads(changed.read_text())
+            provenance["training_recipe"] = {"different": True}
+            changed.write_text(json.dumps(provenance))
+            cmd[-1] = str(root / "bad-recipe.json")
+            run = subprocess.run(cmd, env=env, capture_output=True, text=True)
+            self.assertNotEqual(run.returncode, 0)
+            self.assertIn("Training recipe differs", run.stderr)
+            self.assertFalse((root / "bad-recipe.json").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()