Datasets:

d0rj
/

mathematics_dataset

@@ -152,6 +152,12 @@ and timeouts are recorded separately in traces.
 ## Verification and limitations
 Run the committed regression suite or bounded reference audit after installation:
 ```bash

 ## Verification and limitations
+Version **0.2.1** includes a reproducible local Docker check for all five framework
+integrations, using pinned SDKs, native clients/servers and actual Harbor agent
+and separate-verifier containers. See [Docker instructions](rl/DOCKER.md) and
+the [recorded container results](rl/DOCKER_VALIDATION.toml). The checks cover all
+70 modules in both languages with scripted answers; they do not measure model quality.
 Run the committed regression suite or bounded reference audit after installation:
 ```bash

rl/DOCKER.md ADDED Viewed

	@@ -0,0 +1,78 @@

+# Local Docker validation
+Run all five integrations from this package directory on a machine with a Linux
+Docker daemon and Python 3.11.4+ on the host:
+```bash
+python integrations/docker/run.py --output /absolute/path/to/new-validation-directory
+```
+The output directory must be new. The runner builds separate pinned SDK images,
+runs the regression suite in each, then exercises native framework protocols.
+It also builds the actual OpenEnv production Dockerfile and uses that image for
+both English and Russian servers. The host needs only Python's standard library
+and Docker CLI. Image builds need internet; scoring uses local committed fixtures.
+For an individual integration, add `--framework harbor` (or `verifiers`, `openenv`,
+`nemo`, `agentenv`). The flag is repeatable. Harbor's default covers 140 task
+directories; `--harbor-limit 2` is a shorter development check. `--skip-build` is
+for iterative development with existing images, not final release evidence.
+## What is exercised
+| Integration | Docker execution |
+| --- | --- |
+| Verifiers | Native plugin discovery and `Task.score` for 70 modules × 2 languages; real `vf-eval` with six scripted model responses |
+| Harbor | Real `harbor run`, agent containers, artifact collection, separate verifier containers, 140 oracle tasks, incorrect answers spanning all answer kinds, invalid-source and missing-output cases |
+| OpenEnv | Production server image plus native `EnvClient` in a different container; correct/incorrect answers for every module/language pair, reset/state and rejection of repeated submissions |
+| NeMo Gym | Real resource-server CLI, cross-container HTTP `/verify`, and supervisor-style entrypoint configuration; correct/incorrect answers for every module/language pair |
+| AgentEnv | Native `EpisodeSpec.start`, solver turn, response submission, grading, result and local stores inside the container; correct/incorrect answers for every module/language pair |
+The HTTP/episode matrices each cover 280 scripted submissions (140 correct, 140
+incorrect). These are deterministic engineering checks, not evaluation of a real
+model, model training or an independent audit of the entire published corpus.
+## Reproducibility and artifacts
+The validation images pin Python 3.13.14, uv 0.11.23 and Docker CLI 29.7.2;
+base-image manifest digests are in the Dockerfile. `uv sync --locked` preserves
+the five SDK pins and their separate MCP dependency graphs. No API credentials
+or host environment secrets are passed into the test containers.
+`report.json` records image IDs, source hashes, Docker versions, pytest results,
+case coverage and native protocol results. Per-phase logs and JUnit XML are
+retained. Harbor's native trial JSON, verifier logs and artifacts are copied out
+before its run volume is removed. Expected invalid-source errors are asserted
+separately and do not count as model rewards.
+The runner uses CPU limits, memory limits and a dedicated Docker network. It
+removes its own named containers, networks and scratch volume, retaining the
+built images and host reports. It never prunes Docker globally. Harbor alone
+receives the Docker socket to launch sibling task containers. A named volume is
+mounted at its daemon-side absolute path, so artifact mounts work on Docker
+Desktop as well as a local Linux daemon.
+## Fixes verified by container execution
+- Windows exports use LF for executable scripts. Earlier CRLF exports failed
+  inside Linux with `set: Illegal option -`; a native Windows export is also
+  executed directly in a Linux container as a regression check.
+- Harbor verifiers use an explicit Compose `network_mode: none`. This works on
+  Docker Desktop kernels without `CONFIG_NFT_FIB_INET`, where Harbor's dynamic
+  egress-control `network_mode="no-network"` policy rejects startup. The native
+  trials verify that the verifier has no IPv4 routes and the agent cannot read
+  the verifier's reference/checker paths.
+- Invalid Harbor references are checked before model artifacts. Source failures
+  leave no `reward.txt`; Harbor reports a verifier/source error. This prevents
+  malformed references and missing outputs from silently becoming zero model
+  rewards, and discards stale score files.
+- The production OpenEnv image uses the same lockfile and pinned Python base as
+  validation, rather than resolving a separate transitive dependency set.
+- Verifier inputs are snapshotted in a deterministic, content-addressed tar file,
+  with a unique source filename for Docker's `ADD`. A reference SHA-256 label
+  and build-time digest check supplement it. This replaces directory copying,
+  which mixed files between simultaneous task builds in the local Compose/BuildKit
+  run. Native tests also assert the task ID inside each verifier container.
+See [VALIDATION.md](VALIDATION.md) and [DOCKER_VALIDATION.toml](DOCKER_VALIDATION.toml)
+for release evidence. [FRAMEWORKS.md](FRAMEWORKS.md) describes normal use.

rl/DOCKER_VALIDATION.toml ADDED Viewed

	@@ -0,0 +1,134 @@

+date = 2026-10-19
+package_version = "0.2.1"
+status = "passed"
+modules = 70
+languages = ["en", "ru"]
+fixtures = 1434
+model_responses = "scripted/oracle"
+training_run = false
+gpu_used = false
+real_model_benchmark = false
+hosted_ci_run = false
+verified_source_scope = "shared runtime plus each exercised framework adapter"
+[runtime]
+python = "3.13.14"
+uv = "0.11.23"
+docker_engine = "29.7.2"
+docker_cli = "29.7.2"
+docker_desktop = "4.89.0 (238018)"
+platform = "linux/amd64"
+python_base = "python:3.13.14-slim@sha256:9662417aace5ae7b8e2609cce472b72a8958e134ba372808abe9cc1a0c0125e6"
+docker_cli_base = "docker:29.7.2-cli@sha256:3f4743208d2338c934d7b8bcfbe1bb54c0b2355c510ad5e0f31c0c4a54bd704e"
+[windows_regression]
+python = "3.13.13"
+passed = 1506
+skipped_sdk_modules = 5
+includes_source_publication_tests = 7
+[frameworks.verifiers]
+sdk = "0.4.0"
+passed = true
+image_id = "sha256:4aae609e6aebf86960e0ada14e50f9e46d47b3ff8d98a737cd5855c5ab38ca53"
+unit_passed = 1641
+unit_skipped_sdk_modules = 4
+unit_errors = 0
+unit_failures = 0
+module_language_pairs = 140
+relevant_source_hashes_verified = true
+native_task_score_cases = 140
+vf_eval_scripted_episodes = 6
+[frameworks.harbor]
+sdk = "0.24.0"
+passed = true
+image_id = "sha256:0e52b73c8aee3032b12a1b76af75716d9ac77f274aae84273592fe6aeb572436"
+unit_passed = 1500
+unit_skipped_sdk_modules = 4
+unit_errors = 0
+unit_failures = 0
+module_language_pairs = 140
+relevant_source_hashes_verified = true
+oracle_episodes = 140
+incorrect_episodes = 24
+negative_answer_kinds = 12
+separate_verifier = true
+agent_cannot_read_verifier_paths = true
+verifier_ipv4_routes = 0
+invalid_source_expected_errors = 1
+source_error_leaves_no_reward = true
+missing_output_episodes = 1
+missing_output_reward = 0
+private_payload = "content-addressed deterministic tar"
+native_payload_identity_checked = true
+[frameworks.openenv]
+sdk = "0.9.0"
+passed = true
+image_id = "sha256:35bd6d5af450a823df37d046d8001ce74b52c9948820efbf66a47a5afad71a09"
+unit_passed = 1502
+unit_skipped_sdk_modules = 4
+unit_errors = 0
+unit_failures = 0
+module_language_pairs = 140
+relevant_source_hashes_verified = true
+correct_submissions = 140
+incorrect_submissions = 140
+production_server_image_id = "sha256:ca6aabbb2e8fb8da16e8626af97366612fe425619a6d31d0cfc2365e78f26d20"
+native_cross_container_client = true
+[frameworks.nemo]
+sdk = "0.7.0"
+passed = true
+image_id = "sha256:2b9744ccda3edeb1040a5b9e0f598be0995a0c29d5ee752a3687c489d40a7b30"
+unit_passed = 1501
+unit_skipped_sdk_modules = 4
+unit_errors = 0
+unit_failures = 0
+module_language_pairs = 140
+relevant_source_hashes_verified = true
+correct_submissions = 140
+incorrect_submissions = 140
+supervisor_entrypoint_submissions = 280
+native_cross_container_http = true
+[frameworks.agentenv]
+sdk = "0.9.1334"
+passed = true
+image_id = "sha256:48e7070d8491b13f2851edd5e33dba9d260c2b2cfa01c2b3d490605f4e789a85"
+unit_passed = 1504
+unit_skipped_sdk_modules = 4
+unit_errors = 0
+unit_failures = 0
+module_language_pairs = 140
+relevant_source_hashes_verified = true
+correct_submissions = 140
+incorrect_submissions = 140
+[reports.run_1]
+path = ".cache/docker-release-protocols-021/report.json"
+run_id = "math-rl-9016b81692"
+sha256 = "ff73021e9ea5cdc6d7c348797516e642ca5843123a3724860b3c9ad2cb196284"
+[reports.run_2]
+path = ".cache/docker-release-harbor-021/report.json"
+run_id = "math-rl-4d94c6358e"
+sha256 = "9c55f312587d1eded901c355ec42797651aa130b243789479479685d775dea31"
+[release_source_python_sha256]
+"src/mathematics_rl/__init__.py" = "6e9f28df95bc7145360ea46ac61d97c3cbbd3b3584e769077c125268574d7e1d"
+"src/mathematics_rl/adapters/__init__.py" = "21029b465221f433a0c39cad0e613b30da4d6a8aaac2a6e35304f6675d47d898"
+"src/mathematics_rl/adapters/agentenv.py" = "8cea8a64066fea29048aced1269ee1e819b188abca1557dc6b7e26744b2f4ec9"
+"src/mathematics_rl/adapters/common.py" = "fb41ffb507dd6fe31370e6f3e96df1b25b540dd0203d1601207ad96ceac086db"
+"src/mathematics_rl/adapters/harbor.py" = "b7114340963622441d8dda339152c342596bcd287a026606c8b6c5c2fbda842e"
+"src/mathematics_rl/adapters/nemo.py" = "b3fb4c6e6dce2479d5676b6cb114a4f16db0599a3dea5d20c1382ef66397aaf5"
+"src/mathematics_rl/adapters/openenv.py" = "442e275810ed8de6b8eacb78aa5026f6b57ec1612e94aa127f26e38f45548356"
+"src/mathematics_rl/catalog.py" = "7f22e1fa95e818c08b8b605e632c954c3a10dc64b3a67a12d05c52a84fe39745"
+"src/mathematics_rl/cli.py" = "b0d5b9565a53a947e60e01959680e8a34a6c2ff3510038bb92c1eab28ae82605"
+"src/mathematics_rl/data.py" = "e3487755958973e903f4c33f87bec45d15f67edf3d51ffd3f3ae46e7215fbcc6"
+"src/mathematics_rl/grading.py" = "ee1bd0a0b48832833ea1d13497024109f33ee5a3b759d87443d618bf56d64d6e"
+"src/mathematics_rl/parsing.py" = "2d1bdfc68e3ca206422c4f45d076b5efe976d35898d4aefb206f7c44e6444699"
+"src/mathematics_rl/taskset.py" = "1a5080cf4f344907c3103bbfd75df7fe3a9431b8b7587a17d4f3f18a551d0c2a"
+"src/mathematics_rl/worker.py" = "0f96d77d294ab99f5f8cce114114e115143eb59e9ae6e55946e64d6e726a4fac"
+"src/mathematics_rl/worker_entry.py" = "ef046fe8285b4d903b79f6b02ee4f5e525ac0e6c412cea8d2ae1c785e4c44839"

rl/FRAMEWORKS.md CHANGED Viewed

@@ -55,8 +55,13 @@ contains `task.toml` schema 1.4, `instruction.md`, the agent environment,
 container**; references and checker code are present only there. Missing, oversized,
 non-UTF-8 or non-regular answer files earn zero. Checker source is bundled with
 the task; the verifier image installs pinned SymPy. Image build needs internet.
-The base `python:3.13-slim` image is a mutable tag; archive the built image/digest
-when reproducing an experiment. Do not switch to shared verification for an
 untrusted shell agent: it could read references or alter the checker.
 ## OpenEnv
@@ -92,7 +97,7 @@ after termination is rejected. Native `/schema`, `/health`, `/reset`, `/step`,
 `integrations/openenv/openenv.yaml`, `app.py` and `Dockerfile` are also provided.
 Build from this package root with
-`docker build -f integrations/openenv/Dockerfile -t mathematics-openenv:0.2.0 .`.
 This creates a runnable image, not a published Hugging Face Space.
 ## NeMo Gym
@@ -181,6 +186,10 @@ The external-episode path above supplies model responses directly.
 ## Verification boundaries and sources
 See [VALIDATION.md](VALIDATION.md) for measured checks and outstanding deployment
 boundaries. SDK/protocol tests and oracle trials do not measure a real model or
 an RL training gain. The HF card tags identify adapter compatibility; use the

 container**; references and checker code are present only there. Missing, oversized,
 non-UTF-8 or non-regular answer files earn zero. Checker source is bundled with
 the task; the verifier image installs pinned SymPy. Image build needs internet.
+Python 3.13.14 is pinned by its image manifest digest in the exporter.
+`tests/docker-compose.yaml` disables verifier networking with `network_mode: none`,
+including on Docker Desktop kernels without nftables FIB support. Exports use LF
+on Windows too. Invalid source references leave no reward file and fail the trial.
+The private checker/reference snapshot uses a content-addressed tar filename and
+a build-time reference checksum, protecting parallel task builds from mixed files.
+Do not switch to shared verification for an
 untrusted shell agent: it could read references or alter the checker.
 ## OpenEnv
 `integrations/openenv/openenv.yaml`, `app.py` and `Dockerfile` are also provided.
 Build from this package root with
+`docker build -f integrations/openenv/Dockerfile -t mathematics-openenv:0.2.1 .`.
 This creates a runnable image, not a published Hugging Face Space.
 ## NeMo Gym
 ## Verification boundaries and sources
+Use [DOCKER.md](DOCKER.md) to reproduce all five integrations locally with isolated
+SDK images, native protocols and real Harbor sibling containers. The production
+OpenEnv Dockerfile installs from the same lockfile used by these checks.
 See [VALIDATION.md](VALIDATION.md) for measured checks and outstanding deployment
 boundaries. SDK/protocol tests and oracle trials do not measure a real model or
 an RL training gain. The HF card tags identify adapter compatibility; use the

rl/README.md CHANGED Viewed

@@ -115,6 +115,10 @@ Keep both evaluation categories out of the training mixture.
 ## Tests and publication
 ```bash
 uv run pytest tests -q
 uv run ruff check src tests

 ## Tests and publication
+To check every framework with its pinned SDK in local Linux containers, run
+`python integrations/docker/run.py --output /absolute/path/to/new-results`.
+See [DOCKER.md](DOCKER.md) for requirements, native protocol coverage and logs.
 ```bash
 uv run pytest tests -q
 uv run ruff check src tests

rl/VALIDATION.md CHANGED Viewed

@@ -3,6 +3,51 @@
 Implementation and checks: 2026-10-18/19. Source data revision:
 `d9f78d0665b3a13dad21c6830b9b358c8a25ae74`.
 ## Scope
 - 1,434 generated fixtures: 717 EN and 717 RU. Each language covers all 70 modules,
@@ -36,7 +81,7 @@ publication report and generated release manifest. CI is configured for
 Ubuntu Python 3.11/3.13 and Windows Python 3.13; configuring CI is not evidence that
 hosted CI has executed.
-## Version 0.2.0: additional frameworks
 Checked on 2026-10-19 with actual installed SDKs, using the shared checker and
 the unchanged EN/RU regression fixtures:
@@ -50,7 +95,7 @@ the unchanged EN/RU regression fixtures:
 - Harbor 0.24.0's real `Task` loader validates exported task directories for all
   140 module/language pairs. Artifact checking covers correct, incorrect, missing
   and non-UTF-8 files. `environment_mode=separate` isolates references/checker code
-  from the shell agent. **No Docker trial or image build was completed**: the
   installed Docker Desktop daemon was unavailable (`dockerDesktopLinuxEngine`
   pipe missing), including after its normal start command. Run the documented
   `harbor run --agent oracle` once a Docker daemon is available.
@@ -101,5 +146,6 @@ for RL. The environment itself uses modern dependencies pinned in `uv.lock`.
 These fixtures are engineering regression data, not held-out model benchmarks.
 Accepting an official generator's answer does not independently validate its math.
 The full 125,409,832-row corpus has not been audited, deduplicated or used for an
-RL experiment here. The release preparation changes only the card and adds `rl/`;
-it neither rewrites Parquet nor performs a hosted publication.

 Implementation and checks: 2026-10-18/19. Source data revision:
 `d9f78d0665b3a13dad21c6830b9b358c8a25ae74`.
+## Version 0.2.1: local Docker execution
+The Docker runner builds separate SDK images on Docker Desktop 4.89.0,
+Engine/CLI 29.7.2, Linux amd64, Python 3.13.14. The measured image IDs,
+checksums and protocol results are recorded in [DOCKER_VALIDATION.toml](DOCKER_VALIDATION.toml).
+Run it using [DOCKER.md](DOCKER.md).
+| Pinned SDK in its own container | Package tests passed | Other SDK modules skipped |
+| --- | ---: | ---: |
+| Verifiers 0.4.0 | 1,641 | 4 |
+| Harbor 0.24.0 | 1,500 | 4 |
+| OpenEnv 0.9.0 | 1,502 | 4 |
+| NeMo Gym 0.7.0 | 1,501 | 4 |
+| AgentEnv 0.9.1334 | 1,504 | 4 |
+Windows Python 3.13.13 separately passes 1,506 tests, with five optional SDK
+modules skipped; this includes the seven source-repository publication checks.
+The package suites include all 1,434 mathematical fixtures.
+OpenEnv's actual production image and native cross-container client cover
+280 submissions across all 70 modules in both languages. NeMo Gym covers the
+same 280 submissions both through the standalone launcher and through the
+entrypoint receiving native supervisor configuration. AgentEnv completes 280
+native episode/turn/result cycles with local stores. Verifiers covers native
+`Task.score` for all 140 module/language pairs and six actual `vf-eval` episodes
+against the local scripted endpoint.
+Native Harbor trials exercise artifact collection and separate agent/verifier
+containers, oracle reference acceptance for all 140 module/language pairs,
+incorrect answers covering all 12 answer kinds in each language, a source error
+with no model reward, and missing output earning zero. The trials assert
+private reference/checker paths are absent from the agent and that the verifier
+has no IPv4 routes.
+Container execution found and corrected Windows CRLF shell exports, the
+Docker Desktop kernel incompatibility of Harbor's egress sidecar policy,
+invalid-source errors leaving a misleading reward, and mixed verifier build
+payloads during parallel Compose/BuildKit execution. Content-addressed tar
+snapshots and reference checksums now bind each verifier to its task's files.
+The OpenEnv production image also uses the checked lockfile and pinned base.
+All supplied model answers are scripted or oracle answers. No model training,
+GPU use, hosted CI run or real-model quality benchmark is claimed. The older
+Docker limitation below describes version 0.2.0 and is resolved in this release.
 ## Scope
 - 1,434 generated fixtures: 717 EN and 717 RU. Each language covers all 70 modules,
 Ubuntu Python 3.11/3.13 and Windows Python 3.13; configuring CI is not evidence that
 hosted CI has executed.
+## Version 0.2.0: historical SDK checks
 Checked on 2026-10-19 with actual installed SDKs, using the shared checker and
 the unchanged EN/RU regression fixtures:
 - Harbor 0.24.0's real `Task` loader validates exported task directories for all
   140 module/language pairs. Artifact checking covers correct, incorrect, missing
   and non-UTF-8 files. `environment_mode=separate` isolates references/checker code
+  from the shell agent. **Version 0.2.0 had no completed Docker trial or image build**: the
   installed Docker Desktop daemon was unavailable (`dockerDesktopLinuxEngine`
   pipe missing), including after its normal start command. Run the documented
   `harbor run --agent oracle` once a Docker daemon is available.
 These fixtures are engineering regression data, not held-out model benchmarks.
 Accepting an official generator's answer does not independently validate its math.
 The full 125,409,832-row corpus has not been audited, deduplicated or used for an
+RL experiment here. Release preparation changes only the card and `rl/`;
+it neither rewrites Parquet nor uploads files itself. The source repository's
+publication report records the actual Hub commit and post-upload verification.

rl/integrations/docker/Dockerfile ADDED Viewed

	@@ -0,0 +1,17 @@

+# syntax=docker/dockerfile:1
+FROM docker:29.7.2-cli@sha256:3f4743208d2338c934d7b8bcfbe1bb54c0b2355c510ad5e0f31c0c4a54bd704e AS docker-cli
+FROM python:3.13.14-slim@sha256:9662417aace5ae7b8e2609cce472b72a8958e134ba372808abe9cc1a0c0125e6
+ARG FRAMEWORK
+ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PYTHONUTF8=1
+ENV PATH=/opt/math/.venv/bin:$PATH
+ENV PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 CUDA_VISIBLE_DEVICES=""
+RUN pip install --no-cache-dir uv==0.11.23
+COPY --from=docker-cli /usr/local/bin/docker /usr/local/bin/docker
+COPY --from=docker-cli /usr/local/libexec/docker/cli-plugins /usr/local/libexec/docker/cli-plugins
+WORKDIR /opt/math
+COPY pyproject.toml uv.lock ./
+RUN --mount=type=cache,target=/root/.cache/uv uv sync --locked --extra "$FRAMEWORK" --no-install-project
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/uv uv sync --locked --extra "$FRAMEWORK"
+LABEL org.opencontainers.image.title="Mathematics RL local integration checks"
+CMD ["python", "-m", "pytest", "-p", "pytest_asyncio.plugin", "tests", "-q"]

rl/integrations/docker/harbor_trials.py ADDED Viewed

	@@ -0,0 +1,157 @@

+"""Run real Harbor oracle and negative trials using sibling Docker containers."""
+import argparse
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from scenarios import harbor_verify, representatives, rows, save
+from mathematics_rl.adapters.harbor import build_verifier_payload, export_tasks
+def prepare(tasks, path, prefix, negative=False):
+    manifest = export_tasks(tasks, path)
+    for item in manifest:
+        task_dir = path / item["directory"]
+        task_dir = task_dir.rename(task_dir.with_name(prefix + "-" + task_dir.name))
+        item["directory"] = task_dir.name
+        config_path = task_dir / "task.toml"
+        config = config_path.read_text().replace(
+            'name = "mathematics/', f'name = "mathematics/{prefix}-'
+        )
+        config_path.write_text(config, encoding="utf-8", newline="\n")
+        solve = task_dir / "solution/solve.sh"
+        text = solve.read_text()
+        # These paths are mounted by the verifier only, not by the agent image.
+        text = text.replace(
+            "set -eu\n",
+            "set -eu\ntest ! -e /tests/reference.json\ntest ! -d /tests/mathematics_rl\n",
+            1,
+        )
+        solve.write_text(text, encoding="utf-8", newline="\n")
+        check = task_dir / "tests/test.sh"
+        # Check the actual private build payload, not just the host export.
+        identity_check = (
+            "import json; from pathlib import Path; "
+            "r=json.loads(Path('/tests/reference.json').read_text()); "
+            f"assert r['id'] == {item['task_id']!r}, r; "
+            "print('Verifier task:', r['id'], 'reference:', repr(r['answer']))"
+        )
+        check.write_text(
+            check.read_text().replace(
+                "set -eu\n",
+                'set -eu\npython -c "from pathlib import Path; '
+                "assert len(Path('/proc/net/route').read_text().splitlines()) == 1\"\n"
+                f'python -c "{identity_check}"\n',
+                1,
+            ),
+            encoding="utf-8",
+            newline="\n",
+        )
+        build_verifier_payload(task_dir / "tests")
+        if negative:
+            save(task_dir / "solution/answer.json", "intentionally invalid mathematics answer")
+    return manifest
+def run(tasks, root, prefix, label, expected, invalid_source=False, agent="oracle"):
+    task_dir = root / label / "tasks"
+    manifest = prepare(tasks, task_dir, prefix + "-" + label, negative=not expected)
+    if invalid_source:
+        for item in manifest:
+            reference = task_dir / item["directory"] / "tests/reference.json"
+            value = json.loads(reference.read_text())
+            value["answer"] = "invalid source reference"
+            save(reference, value)
+            build_verifier_payload(reference.parent)
+    job_name = prefix + "-" + label
+    jobs_dir = root / "jobs"
+    command = [
+        "harbor",
+        "run",
+        "--path",
+        str(task_dir),
+        "--agent",
+        agent,
+        "--jobs-dir",
+        str(jobs_dir),
+        "--job-name",
+        job_name,
+        "--n-concurrent",
+        "4",
+        "--max-retries",
+        "0",
+        "--no-export-push",
+        "--yes",
+    ]
+    with (root / f"{label}.log").open("w", encoding="utf-8") as log:
+        subprocess.run(command, stdout=log, stderr=subprocess.STDOUT, check=True, timeout=3000)
+    if invalid_source:
+        results = [json.loads(p.read_text()) for p in (jobs_dir / job_name).glob("*/result.json")]
+        assert len(results) == len(manifest)
+        for result in results:
+            assert result["exception_info"]["exception_type"] == "RewardFileNotFoundError", result
+            assert result["verifier_result"] is None, result
+        return {"episodes": len(results), "source_errors_have_no_reward": True}
+    result = harbor_verify(jobs_dir / job_name, expected)
+    assert result["episodes"] == len(manifest)
+    return result
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--work", type=Path, required=True)
+    parser.add_argument("--prefix", required=True)
+    parser.add_argument("--limit", type=int, default=0)
+    args = parser.parse_args()
+    root = args.work / "run"
+    root.mkdir(exist_ok=False)
+    results = Path("/results")
+    results.mkdir(exist_ok=True)
+    tasks = [task for lang in ("en", "ru") for _, task in representatives(lang)]
+    if args.limit:
+        tasks = tasks[: args.limit]
+    try:
+        positive = run(tasks, root, args.prefix, "positive", 1)
+        print(f"Harbor accepted {positive['episodes']} oracle answers", flush=True)
+        negatives = []
+        seen = set()
+        for lang in ("en", "ru"):
+            for task in rows(lang):
+                if (lang, task.kind) not in seen:
+                    negatives.append(task)
+                    seen.add((lang, task.kind))
+        if args.limit:
+            negatives = negatives[: args.limit]
+        negative = run(negatives, root, args.prefix, "negative", 0)
+        print(f"Harbor rejected {negative['episodes']} wrong answers", flush=True)
+        source_error = run(tasks[:1], root, args.prefix, "invalid-source", 0, invalid_source=True)
+        missing_output = run(tasks[:1], root, args.prefix, "missing-output", 0, agent="nop")
+        save(
+            results / "report.json",
+            {
+                "framework": "harbor",
+                "passed": True,
+                "oracle_episodes": positive["episodes"],
+                "incorrect_episodes": negative["episodes"],
+                "module_language_cases": [
+                    {"module": t.module, "language": t.language} for t in tasks
+                ],
+                "negative_kinds": sorted({t.kind for t in negatives}),
+                "separate_verifier": True,
+                "agent_cannot_read_verifier_paths": True,
+                "source_error": source_error,
+                "missing_output": {"episodes": missing_output["episodes"], "reward": 0},
+                "positive": positive,
+                "negative": negative,
+            },
+        )
+    finally:
+        # Preserve native results even on error, before the runner removes its volume.
+        shutil.copytree(root, results / "native", dirs_exist_ok=True)
+if __name__ == "__main__":
+    main()

rl/integrations/docker/run.py ADDED Viewed

	@@ -0,0 +1,380 @@

+"""Build and verify each framework in Docker. Only this run's resources are removed."""
+import argparse
+import hashlib
+import json
+import shutil
+import subprocess
+import time
+import tomllib
+import uuid
+import xml.etree.ElementTree as ET
+from pathlib import Path
+PACKAGE = Path(__file__).absolute().parents[2]
+FRAMEWORKS = ("verifiers", "harbor", "openenv", "nemo", "agentenv")
+class DockerChecks:
+    def __init__(self, output, frameworks, skip_build=False, harbor_limit=0):
+        self.output = Path(output).absolute()
+        self.output.mkdir(parents=True, exist_ok=False)
+        self.frameworks = frameworks
+        self.version = tomllib.loads((PACKAGE / "pyproject.toml").read_text())["project"]["version"]
+        self.prefix = "math-rl-" + uuid.uuid4().hex[:10]
+        self.docker = (
+            shutil.which("docker") or r"C:\Program Files\Docker\Docker\resources\bin\docker.exe"
+        )
+        self.network = self.prefix + "-net"
+        self.volume = None
+        self.skip_build = skip_build
+        self.harbor_limit = harbor_limit
+        self.containers = []
+        self.production_openenv = None
+        self.report = {
+            "version": self.version,
+            "run_id": self.prefix,
+            "frameworks": {},
+            "model_responses": "scripted",
+            "training_run": False,
+            "gpu_used": False,
+            "source_python_sha256": {
+                p.relative_to(PACKAGE).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
+                for p in sorted((PACKAGE / "src").rglob("*.py"))
+            },
+        }
+    def call(self, *args, timeout=60, check=True):
+        return subprocess.run(
+            [self.docker, *map(str, args)],
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            capture_output=True,
+            check=check,
+            timeout=timeout,
+        )
+    def image(self, framework):
+        return f"mathematics-rl-check-{framework}:{self.version}"
+    def build(self, framework):
+        if not self.skip_build:
+            with (self.output / f"build-{framework}.log").open("w", encoding="utf-8") as log:
+                result = subprocess.run(
+                    [
+                        self.docker,
+                        "build",
+                        "--progress",
+                        "plain",
+                        "--build-arg",
+                        f"FRAMEWORK={framework}",
+                        "-f",
+                        str(PACKAGE / "integrations/docker/Dockerfile"),
+                        "-t",
+                        self.image(framework),
+                        str(PACKAGE),
+                    ],
+                    stdout=log,
+                    stderr=subprocess.STDOUT,
+                    timeout=1200,
+                )
+                if result.returncode:
+                    raise RuntimeError(f"Build failed: {framework}; see {log.name}")
+        info = json.loads(self.call("image", "inspect", self.image(framework)).stdout)[0]
+        self.report["frameworks"][framework] = {
+            "image_id": info["Id"],
+            "image": self.image(framework),
+        }
+        if framework == "openenv":
+            self.production_openenv = f"mathematics-openenv:{self.version}"
+            if not self.skip_build:
+                with (self.output / "build-openenv-production.log").open(
+                    "w", encoding="utf-8"
+                ) as log:
+                    subprocess.run(
+                        [
+                            self.docker,
+                            "build",
+                            "--progress",
+                            "plain",
+                            "-f",
+                            str(PACKAGE / "integrations/openenv/Dockerfile"),
+                            "-t",
+                            self.production_openenv,
+                            str(PACKAGE),
+                        ],
+                        stdout=log,
+                        stderr=subprocess.STDOUT,
+                        timeout=1200,
+                        check=True,
+                    )
+            info = json.loads(self.call("image", "inspect", self.production_openenv).stdout)[0]
+            self.report["frameworks"][framework]["production_server_image_id"] = info["Id"]
+    def create(self, framework, suffix, command, *, daemon=False, mounts=(), image=None):
+        name = self.prefix + "-" + suffix
+        self.containers.append(name)
+        args = [
+            "create",
+            "--name",
+            name,
+            "--label",
+            f"mathematics.rl.run={self.prefix}",
+            "--init",
+            "--cpus",
+            "2",
+            "--memory",
+            "4g",
+            "--network",
+            self.network,
+        ]
+        for mount in mounts:
+            args.extend(["--mount", mount])
+        args.extend([image or self.image(framework), *command])
+        self.call(*args)
+        if daemon:
+            self.call("start", name)
+        return name
+    def run(self, framework, suffix, command, *, timeout=600, mounts=()):
+        name = self.create(framework, suffix, command, mounts=mounts)
+        with (self.output / f"{suffix}.log").open("w", encoding="utf-8") as log:
+            proc = subprocess.run(
+                [self.docker, "start", "--attach", name],
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                timeout=timeout,
+            )
+        exit_code = json.loads(self.call("inspect", name).stdout)[0]["State"]["ExitCode"]
+        target = self.output / suffix
+        target.mkdir(exist_ok=True)
+        self.call("cp", name + ":/results/.", target, check=False)
+        if proc.returncode or exit_code:
+            raise RuntimeError(f"{suffix} failed (exit {exit_code}); see {suffix}.log")
+        return target
+    def ready(self, name, port, endpoint):
+        deadline = time.monotonic() + 90
+        code = (
+            "from urllib.request import urlopen; "
+            f"urlopen('http://127.0.0.1:{port}{endpoint}', timeout=2).read()"
+        )
+        while time.monotonic() < deadline:
+            if (
+                self.call("exec", name, "python", "-c", code, timeout=5, check=False).returncode
+                == 0
+            ):
+                return
+            state = json.loads(self.call("inspect", name).stdout)[0]["State"]
+            if not state["Running"]:
+                break
+            time.sleep(0.5)
+        raise RuntimeError(f"Server {name} did not become ready")
+    def unit(self, framework):
+        target = self.run(
+            framework, framework + "-unit", ["python", "integrations/docker/scenarios.py", "unit"]
+        )
+        suite = ET.parse(target / "pytest.xml").getroot().find("testsuite")
+        assert int(suite.attrib["failures"]) == int(suite.attrib["errors"]) == 0
+        passed = int(suite.attrib["tests"]) - int(suite.attrib["skipped"])
+        assert passed > 1400
+        self.report["frameworks"][framework]["unit"] = dict(suite.attrib)
+    def protocols(self, framework):
+        if framework == "openenv":
+            results = []
+            for language in ("en", "ru"):
+                suffix = "openenv-" + language
+                name = self.create(
+                    framework,
+                    suffix,
+                    [
+                        "python",
+                        "integrations/docker/scenarios.py",
+                        "serve-openenv",
+                        "--language",
+                        language,
+                    ],
+                    daemon=True,
+                    image=self.production_openenv,
+                )
+                self.ready(name, 8000, "/health")
+                target = self.run(
+                    framework,
+                    suffix + "-client",
+                    [
+                        "python",
+                        "integrations/docker/scenarios.py",
+                        "openenv",
+                        "--url",
+                        f"http://{name}:8000",
+                        "--language",
+                        language,
+                    ],
+                )
+                results.append(json.loads((target / "report.json").read_text()))
+                self.call("stop", "-t", "10", name)
+            self.report["frameworks"][framework]["protocol"] = results
+        elif framework == "nemo":
+            name = self.create(
+                framework,
+                "nemo-server",
+                ["mathematics-nemo", "--host", "0.0.0.0", "--port", "8001"],
+                daemon=True,
+            )
+            self.ready(name, 8001, "/reverify_mode")
+            target = self.run(
+                framework,
+                "nemo-client",
+                [
+                    "python",
+                    "integrations/docker/scenarios.py",
+                    "nemo",
+                    "--url",
+                    f"http://{name}:8001",
+                ],
+            )
+            self.report["frameworks"][framework]["protocol"] = json.loads(
+                (target / "report.json").read_text()
+            )
+            self.call("stop", "-t", "10", name)
+            name = self.create(
+                framework,
+                "nemo-native-server",
+                ["python", "integrations/docker/scenarios.py", "serve-nemo-native"],
+                daemon=True,
+            )
+            self.ready(name, 8001, "/reverify_mode")
+            target = self.run(
+                framework,
+                "nemo-native-client",
+                [
+                    "python",
+                    "integrations/docker/scenarios.py",
+                    "nemo",
+                    "--url",
+                    f"http://{name}:8001",
+                ],
+            )
+            self.report["frameworks"][framework]["supervisor_entrypoint_protocol"] = json.loads(
+                (target / "report.json").read_text()
+            )
+        elif framework == "agentenv":
+            target = self.run(
+                framework,
+                "agentenv-episodes",
+                ["python", "integrations/docker/scenarios.py", "agentenv"],
+                timeout=900,
+            )
+            self.report["frameworks"][framework]["protocol"] = json.loads(
+                (target / "report.json").read_text()
+            )
+        elif framework == "verifiers":
+            target = self.run(
+                framework,
+                "verifiers-rollout",
+                [
+                    "python",
+                    "integrations/docker/verifiers_smoke.py",
+                    "--output",
+                    "/results/rollout",
+                ],
+            )
+            self.report["frameworks"][framework]["protocol"] = json.loads(
+                (target / "rollout/report.json").read_text()
+            )
+        else:
+            self.harbor()
+    def harbor(self):
+        self.volume = self.prefix + "-harbor-data"
+        self.call("volume", "create", "--label", f"mathematics.rl.run={self.prefix}", self.volume)
+        # Sibling containers must see the same absolute paths as the runner.
+        mountpoint = json.loads(self.call("volume", "inspect", self.volume).stdout)[0]["Mountpoint"]
+        target = self.run(
+            "harbor",
+            "harbor-trials",
+            [
+                "python",
+                "integrations/docker/harbor_trials.py",
+                "--work",
+                mountpoint,
+                "--prefix",
+                self.prefix,
+                "--limit",
+                str(self.harbor_limit),
+            ],
+            timeout=3600,
+            mounts=[
+                "type=bind,source=/var/run/docker.sock,target=/var/run/docker.sock",
+                f"type=volume,source={self.volume},target={mountpoint}",
+            ],
+        )
+        self.report["frameworks"]["harbor"]["protocol"] = json.loads(
+            (target / "report.json").read_text()
+        )
+    def cleanup(self):
+        for name in self.containers:
+            captured = self.call("logs", name, check=False)
+            log = captured.stdout + captured.stderr
+            if log:
+                (self.output / (name + "-container.log")).write_text(log, encoding="utf-8")
+            self.call("rm", "-f", name, check=False)
+        # Harbor tasks are prefixed with this run's random identifier before launch.
+        ids = self.call(
+            "ps", "-aq", "--filter", f"name=^/?{self.prefix}-", check=False
+        ).stdout.split()
+        if ids:
+            self.call("rm", "-f", *ids, check=False)
+        networks = self.call(
+            "network", "ls", "-q", "--filter", f"name=^{self.prefix}", check=False
+        ).stdout.split()
+        if networks:
+            self.call("network", "rm", *networks, check=False)
+        if self.volume:
+            self.call("volume", "rm", self.volume, check=False)
+    def execute(self):
+        self.report["docker"] = json.loads(self.call("version", "--format", "{{json .}}").stdout)
+        self.call("network", "create", "--label", f"mathematics.rl.run={self.prefix}", self.network)
+        try:
+            for framework in self.frameworks:
+                print(f"[{framework}] build, unit tests, native protocol", flush=True)
+                self.build(framework)
+                self.unit(framework)
+                self.protocols(framework)
+                self.report["frameworks"][framework]["passed"] = True
+                print(f"[{framework}] passed", flush=True)
+            self.report["passed"] = True
+        except Exception as error:
+            self.report["passed"] = False
+            self.report["error"] = str(error)
+            raise
+        finally:
+            self.cleanup()
+            (self.output / "report.json").write_text(
+                json.dumps(self.report, indent=2) + "\n", encoding="utf-8"
+            )
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--framework", choices=FRAMEWORKS, action="append")
+    parser.add_argument(
+        "--skip-build", action="store_true", help="Development only: reuse already built images"
+    )
+    parser.add_argument(
+        "--harbor-limit", type=int, default=0, help="0 verifies all 140 module/language tasks"
+    )
+    args = parser.parse_args()
+    DockerChecks(
+        args.output, args.framework or FRAMEWORKS, args.skip_build, args.harbor_limit
+    ).execute()
+if __name__ == "__main__":
+    main()

rl/integrations/docker/scenarios.py ADDED Viewed

	@@ -0,0 +1,293 @@

+"""Native framework checks for the Docker runner; all model responses are scripted."""
+import argparse
+import asyncio
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import asdict
+from pathlib import Path
+from urllib.request import Request, urlopen
+PACKAGE = Path(__file__).absolute().parents[2]
+FIXTURES = PACKAGE / "tests" / "fixtures"
+WRONG = "intentionally invalid mathematics answer"
+def rows(language):
+    from mathematics_rl.adapters.common import select_tasks
+    return select_tasks(
+        source=str(FIXTURES / f"generated_{language}.ndjson"),
+        language=language,
+        mode="all",
+        limit=10_000,
+    )
+def representatives(language):
+    seen = set()
+    result = []
+    for index, task in enumerate(rows(language)):
+        if task.module not in seen:
+            seen.add(task.module)
+            result.append((index, task))
+    assert len(result) == 70
+    return result
+def save(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+def serve_openenv(language):
+    config = {
+        "source": str(FIXTURES / f"generated_{language}.ndjson"),
+        "language": language,
+        "mode": "all",
+        "limit": 10_000,
+    }
+    path = Path(tempfile.mkdtemp()) / "config.json"
+    save(path, config)
+    os.execvp(
+        "mathematics-openenv",
+        ["mathematics-openenv", "--config", str(path), "--host", "0.0.0.0", "--port", "8000"],
+    )
+def serve_nemo_native():
+    # Match the config injected by Gym's supervisor; exercise the shipped shim.
+    os.environ["NEMO_GYM_CONFIG_PATH"] = "mathematics"
+    os.environ["NEMO_GYM_CONFIG_DICT"] = json.dumps(
+        {
+            "dry_run": False,
+            "head_server": {"host": "127.0.0.1", "port": 11000},
+            "mathematics": {
+                "resources_servers": {
+                    "mathematics": {
+                        "entrypoint": str(PACKAGE / "integrations/nemo/app.py"),
+                        "host": "0.0.0.0",
+                        "port": 8001,
+                        "domain": "math",
+                    }
+                }
+            },
+        }
+    )
+    os.execvp("mathematics-nemo", ["mathematics-nemo"])
+def openenv_check(url, language):
+    from mathematics_rl.adapters.openenv import MathematicsAction, MathematicsClient
+    checks = []
+    with MathematicsClient(base_url=url, connect_timeout_s=10, message_timeout_s=30) as client:
+        for index, task in representatives(language):
+            for answer, expected in ((task.answer, 1), (WRONG, 0)):
+                initial = client.reset(task_index=index)
+                assert initial.observation.prompt == task.prompt, (task.module, index)
+                state = client.state().model_dump()
+                assert "answer" not in state and "content_hash" not in state
+                result = client.step(MathematicsAction(answer=answer))
+                assert result.done and result.reward == expected, (task.module, result)
+                assert client.state().step_count == 1
+            checks.append(
+                {"module": task.module, "language": language, "correct": 1, "incorrect": 0}
+            )
+        try:
+            client.step(MathematicsAction(answer=task.answer))
+        except Exception as error:
+            assert "terminal" in str(error).lower(), str(error)
+        else:
+            raise AssertionError("OpenEnv accepted a second submission")
+    return {
+        "framework": "openenv",
+        "cases": checks,
+        "episodes": 140,
+        "transport": "native EnvClient over Docker network",
+        "passed": True,
+    }
+def response(text):
+    return {
+        "id": "scripted",
+        "object": "response",
+        "created_at": 0,
+        "model": "scripted",
+        "parallel_tool_calls": False,
+        "tool_choice": "auto",
+        "tools": [],
+        "output": [
+            {
+                "id": "msg",
+                "type": "message",
+                "role": "assistant",
+                "status": "completed",
+                "content": [{"type": "output_text", "text": text, "annotations": []}],
+            }
+        ],
+    }
+def request(url, body=None):
+    data = json.dumps(body, ensure_ascii=False).encode() if body is not None else None
+    with urlopen(
+        Request(url, data=data, headers={"Content-Type": "application/json"}), timeout=30
+    ) as reply:
+        return json.load(reply)
+def nemo_check(url):
+    checks = []
+    for language in ("en", "ru"):
+        for _, task in representatives(language):
+            row = {
+                "responses_create_params": {"input": [{"role": "user", "content": task.prompt}]},
+                "math_example": asdict(task),
+            }
+            for answer, expected in ((task.answer, 1), (WRONG, 0)):
+                result = request(url + "/verify", {**row, "response": response(answer)})
+                assert result["reward"] == expected and not result["mask_sample"], result
+                assert "math_example" not in result and result["task_id"] == task.id
+            checks.append(
+                {"module": task.module, "language": language, "correct": 1, "incorrect": 0}
+            )
+    assert request(url + "/reverify_mode") == "stateless"
+    return {
+        "framework": "nemo",
+        "cases": checks,
+        "episodes": 280,
+        "transport": "native resource server HTTP over Docker network",
+        "passed": True,
+    }
+async def agentenv_check():
+    # The trainer supplies each answer through AgentEnv's real turn protocol.
+    from agent_env.config import configure
+    from agent_env.task import EpisodeSpec
+    from mathematics_rl.adapters.agentenv import make_task
+    state = tempfile.mkdtemp(prefix="mathematics-agentenv-")
+    os.environ["XDG_STATE_HOME"] = state
+    os.environ["AGENT_ENV_CONFIG"] = str(Path(state) / "config.toml")
+    Path(os.environ["AGENT_ENV_CONFIG"]).write_text("")
+    configure()
+    checks = []
+    for language in ("en", "ru"):
+        for _, task in representatives(language):
+            for answer, expected in ((task.answer, 1), (WRONG, 0)):
+                episode = await EpisodeSpec.from_task(make_task(task), turn_timeout=30).start()
+                try:
+                    turn = await asyncio.wait_for(episode.next_turn(), 30)
+                    assert turn.prompt == task.prompt
+                    await turn.end(response=answer)
+                    assert await asyncio.wait_for(episode.next_turn(), 30) is None
+                    assert await asyncio.wait_for(episode.result(), 30) == {"grade": expected}
+                finally:
+                    await episode.abandon("Docker check finished")
+            checks.append(
+                {"module": task.module, "language": language, "correct": 1, "incorrect": 0}
+            )
+    return {
+        "framework": "agentenv",
+        "cases": checks,
+        "episodes": 280,
+        "transport": "native EpisodeSpec, turn, result and local stores",
+        "passed": True,
+    }
+def harbor_prepare(output, limit):
+    from mathematics_rl.adapters.harbor import export_tasks
+    tasks = [task for lang in ("en", "ru") for _, task in representatives(lang)]
+    return export_tasks(tasks[:limit] if limit else tasks, output)
+def harbor_verify(job, expected=1):
+    trials = []
+    for path in Path(job).glob("*/result.json"):
+        result = json.loads(path.read_text())
+        assert not result["exception_info"], (path, result["exception_info"])
+        assert result["verifier_environment_mode"] == "separate", path
+        assert result["verifier_result"]["rewards"]["reward"] == expected, (path, result)
+        trials.append(
+            {"task_name": result["task_name"], "reward": expected, "separate_verifier": True}
+        )
+    assert trials, job
+    return {"framework": "harbor", "trials": trials, "episodes": len(trials), "passed": True}
+def unit_tests(output):
+    command = [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-p",
+        "pytest_asyncio.plugin",
+        "tests",
+        "-q",
+        "--junitxml",
+        str(Path(output) / "pytest.xml"),
+    ]
+    Path(output).mkdir(parents=True, exist_ok=True)
+    subprocess.run(command, check=True, timeout=300)
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "scenario",
+        choices=(
+            "serve-openenv",
+            "serve-nemo-native",
+            "openenv",
+            "nemo",
+            "agentenv",
+            "harbor-prepare",
+            "harbor-verify",
+            "unit",
+        ),
+    )
+    parser.add_argument("--language", choices=("en", "ru"), default="en")
+    parser.add_argument("--url")
+    parser.add_argument("--output", type=Path, default=Path("/results"))
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--expected", type=int, default=1)
+    args = parser.parse_args()
+    started = time.monotonic()
+    if args.scenario == "serve-openenv":
+        serve_openenv(args.language)
+    elif args.scenario == "serve-nemo-native":
+        serve_nemo_native()
+    elif args.scenario == "unit":
+        unit_tests(args.output)
+        return
+    elif args.scenario == "openenv":
+        result = openenv_check(args.url, args.language)
+    elif args.scenario == "nemo":
+        result = nemo_check(args.url)
+    elif args.scenario == "agentenv":
+        result = asyncio.run(agentenv_check())
+    elif args.scenario == "harbor-prepare":
+        result = harbor_prepare(args.output, args.limit)
+    else:
+        result = harbor_verify(args.output, args.expected)
+    if isinstance(result, dict):
+        result["elapsed_seconds"] = round(time.monotonic() - started, 3)
+        save(args.output / "report.json", result)
+        print(json.dumps({k: v for k, v in result.items() if k not in ("cases", "trials")}))
+    else:
+        print(json.dumps({"exported": len(result), "output": str(args.output)}))
+if __name__ == "__main__":
+    main()

rl/integrations/docker/verifiers_smoke.py ADDED Viewed

	@@ -0,0 +1,213 @@

+"""Run real vf-eval against a local scripted endpoint; this is not a model benchmark."""
+import argparse
+import json
+import os
+import signal
+import subprocess
+import sys
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+CASES = [
+    ("arithmetic__add_or_sub", "Compute 1+1.", "2", "2", 1),
+    ("comparison__sort", "Sort 3, 1, 2.", "1, 2, 3", "3, 2, 1", 0),
+    ("algebra__polynomial_roots", "Factor x**2-1.", "(x-1)*(x+1)", "x**2-1", 0),
+    (
+        "polynomials__simplify_power",
+        "Simplify x**(2/4), assuming x is positive.",
+        "x**(1/2)",
+        r"\sqrt{x}",
+        1,
+    ),
+    ("numbers__is_prime", "Is 7 prime?", "True", "False", 0),
+    ("arithmetic__simplify_surd", "Simplify sqrt(12).", "2*sqrt(3)", "sqrt(12)", 0),
+]
+def verify_trace_files(output):
+    episodes = [
+        json.loads(line)
+        for path in (output / "runs").rglob("traces.jsonl")
+        for line in path.read_text().splitlines()
+        if line.strip()
+    ]
+    assert len(episodes) == len(CASES), f"Expected {len(CASES)} episodes, got {len(episodes)}"
+    expected = {case[1]: case[4] for case in CASES}
+    rewards = {}
+    for episode in episodes:
+        assert episode["ok"] and not episode["errors"], episode
+        assert len(episode["traces"]) == 1, episode
+        trace = episode["traces"][0]
+        question = episode["task"]["data"]["question"]
+        assert trace["task"]["data"]["question"] == question
+        reward = trace["rewards"]["correct"]
+        actual = reward["score"] * reward["weight"]
+        assert not trace["errors"] and trace["ok"] and len(trace["calls"]) == 1, trace
+        assert actual == expected[question], trace
+        rewards[question] = actual
+    assert set(rewards) == set(expected)
+    report = {
+        "type": "scripted_endpoint_real_verifiers_transport_smoke",
+        "not_a_model_benchmark": True,
+        "traces": len(episodes),
+        "rewards": rewards,
+        "no_remote_result_upload": True,
+        "gpu_used": False,
+    }
+    (output / "report.json").write_text(json.dumps(report, indent=2) + "\n")
+    return report
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        required=True,
+        help="A new, empty output directory (never cleans existing runs)",
+    )
+    parser.add_argument(
+        "--verify-existing",
+        action="store_true",
+        help="Only verify traces already produced by this smoke test",
+    )
+    args = parser.parse_args()
+    if args.verify_existing:
+        print(json.dumps(verify_trace_files(args.output), indent=2))
+        return
+    args.output.mkdir(parents=True, exist_ok=False)
+    rows = [
+        {
+            "module": module,
+            "question": question,
+            "answer": answer,
+            "language": "en",
+            "category": "interpolate",
+        }
+        for module, question, answer, _, _ in CASES
+    ]
+    source = args.output / "source.ndjson"
+    source.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
+    received = []
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            request = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+            content = str(request["messages"][-1]["content"])
+            case = next(case for case in CASES if content.endswith(case[1]))
+            received.append(case[1])
+            response = {
+                "id": "chatcmpl-local-smoke",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": "scripted-smoke",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {"role": "assistant", "content": case[3]},
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 32,
+                    "completion_tokens": 8,
+                    "total_tokens": 40,
+                },
+            }
+            if request.get("stream"):
+                self.send_response(200)
+                self.send_header("Content-Type", "text/event-stream")
+                self.end_headers()
+                chunk = {
+                    "id": response["id"],
+                    "object": "chat.completion.chunk",
+                    "created": response["created"],
+                    "model": "scripted-smoke",
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {"role": "assistant", "content": case[3]},
+                            "finish_reason": None,
+                        }
+                    ],
+                }
+                self.wfile.write(("data: " + json.dumps(chunk) + "\n\n").encode())
+                chunk["choices"] = [{"index": 0, "delta": {}, "finish_reason": "stop"}]
+                chunk["usage"] = response["usage"]
+                self.wfile.write(("data: " + json.dumps(chunk) + "\n\ndata: [DONE]\n\n").encode())
+            else:
+                payload = json.dumps(response).encode()
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(payload)))
+                self.end_headers()
+                self.wfile.write(payload)
+        def log_message(self, *_):
+            pass
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    command = [
+        str(Path(sys.executable).parent / "vf-eval"),
+        "mathematics-rl",
+        "--env.taskset.language",
+        "en",
+        "--env.taskset.source",
+        str(source.absolute()),
+        "--client.base-url",
+        f"http://127.0.0.1:{server.server_port}/v1",
+        "--client.api-key-var",
+        "MATHEMATICS_UNUSED_SMOKE_KEY",
+        "--model",
+        "scripted-smoke",
+        "--env.agent.runtime.type",
+        "subprocess",
+        "--env.agent.harness.id",
+        "null",
+        "--env.agent.timeout.rollout",
+        "60",
+        "--client.timeout.read",
+        "30",
+        "--max-concurrent",
+        "2",
+        "-n",
+        str(len(CASES)),
+        "--no-push",
+        "--no-rich",
+        "--output-dir",
+        str((args.output / "runs").absolute()),
+    ]
+    try:
+        with (args.output / "vf-eval.log").open("w", encoding="utf-8") as log:
+            process = subprocess.Popen(
+                command, stdout=log, stderr=subprocess.STDOUT, start_new_session=True
+            )
+            try:
+                code = process.wait(timeout=300)
+            except (subprocess.TimeoutExpired, KeyboardInterrupt):
+                os.killpg(process.pid, signal.SIGTERM)
+                try:
+                    process.wait(timeout=10)
+                except subprocess.TimeoutExpired:
+                    os.killpg(process.pid, signal.SIGKILL)
+                    process.wait(timeout=5)
+                raise
+            if code:
+                raise subprocess.CalledProcessError(code, command)
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+    expected = {case[1]: case[4] for case in CASES}
+    assert set(received) == set(expected)
+    report = verify_trace_files(args.output)
+    print(json.dumps(report, indent=2))
+if __name__ == "__main__":
+    main()

rl/integrations/openenv/Dockerfile CHANGED Viewed

@@ -1,6 +1,11 @@
-FROM python:3.13-slim
 WORKDIR /opt/mathematics
 COPY . .
-RUN pip install --no-cache-dir '.[openenv]'
 EXPOSE 8000
 CMD ["mathematics-openenv", "--host", "0.0.0.0", "--port", "8000"]

+FROM python:3.13.14-slim@sha256:9662417aace5ae7b8e2609cce472b72a8958e134ba372808abe9cc1a0c0125e6
+ENV PATH=/opt/mathematics/.venv/bin:$PATH
+ENV PYTHONUNBUFFERED=1 PYTHONUTF8=1
 WORKDIR /opt/mathematics
+RUN pip install --no-cache-dir uv==0.11.23
+COPY pyproject.toml uv.lock ./
+RUN --mount=type=cache,target=/root/.cache/uv uv sync --locked --no-dev --extra openenv --no-install-project
 COPY . .
+RUN --mount=type=cache,target=/root/.cache/uv uv sync --locked --no-dev --extra openenv
 EXPOSE 8000
 CMD ["mathematics-openenv", "--host", "0.0.0.0", "--port", "8000"]

rl/integrations/openenv/openenv.yaml CHANGED Viewed

@@ -1,6 +1,6 @@
 spec_version: 1
 name: mathematics
-version: 0.2.0
 type: space
 runtime: fastapi
 app: app:app

 spec_version: 1
 name: mathematics
+version: 0.2.1
 type: space
 runtime: fastapi
 app: app:app

rl/pyproject.toml CHANGED Viewed

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "mathematics-rl"
-version = "0.2.0"
 description = "Bilingual mathematics RL environments for Verifiers, Harbor, OpenEnv, NeMo Gym and AgentEnv"
 readme = "README.md"
 requires-python = ">=3.11.4,<3.15"
@@ -39,7 +39,7 @@ packages = ["src/mathematics_rl"]
 only-include = [
   "src", "tests", "integrations", "pyproject.toml", "uv.lock", "README.md",
   "FRAMEWORKS.md", "GRADING.md", "MODULES.md", "VALIDATION.md", "LICENSE", "NOTICE",
-  ".dockerignore",
 ]
 [tool.hatch.build.targets.sdist.force-include]

 [project]
 name = "mathematics-rl"
+version = "0.2.1"
 description = "Bilingual mathematics RL environments for Verifiers, Harbor, OpenEnv, NeMo Gym and AgentEnv"
 readme = "README.md"
 requires-python = ">=3.11.4,<3.15"
 only-include = [
   "src", "tests", "integrations", "pyproject.toml", "uv.lock", "README.md",
   "FRAMEWORKS.md", "GRADING.md", "MODULES.md", "VALIDATION.md", "LICENSE", "NOTICE",
+  ".dockerignore", "DOCKER.md", "DOCKER_VALIDATION.toml",
 ]
 [tool.hatch.build.targets.sdist.force-include]

rl/src/mathematics_rl/__init__.py CHANGED Viewed

@@ -1,7 +1,7 @@
 """Verifiers plugin entry point, loaded lazily so the checker also works on Windows."""
 __all__ = ["MathematicsTaskset", "MathematicsEnv"]
-__version__ = "0.2.0"
 def __getattr__(name):

 """Verifiers plugin entry point, loaded lazily so the checker also works on Windows."""
 __all__ = ["MathematicsTaskset", "MathematicsEnv"]
+__version__ = "0.2.1"
 def __getattr__(name):

rl/src/mathematics_rl/adapters/common.py CHANGED Viewed

@@ -52,7 +52,9 @@ def checked_grade(grader, task, completion):
 def write_json(path, value):
     path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
 def private_record(task):

 def write_json(path, value):
     path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8", newline="\n"
+    )
 def private_record(task):

rl/src/mathematics_rl/adapters/harbor.py CHANGED Viewed

@@ -1,7 +1,9 @@
 """Harbor 0.24 task-directory export with a separate trusted verifier environment."""
 import json
 import stat
 from pathlib import Path
 from .. import __version__
@@ -10,6 +12,10 @@ from ..grading import MAX_COMPLETION
 from ..worker import Grader
 from .common import checked_grade, private_record, write_json
 TASK_TOML = """schema_version = "1.4"
 artifacts = ["/app/answer.txt"]
 [task]
@@ -35,10 +41,39 @@ cpus = 1
 memory_mb = 512
 storage_mb = 1024
 gpus = 0
-network_mode = "no-network"
 """
 def export_tasks(tasks, output):
     output = Path(output)
     output.mkdir(parents=True, exist_ok=False)
@@ -65,14 +100,16 @@ def export_tasks(tasks, output):
         (root / "task.toml").write_text(
             TASK_TOML.format(name=name, version=__version__, **private_record(task)),
             encoding="utf-8",
         )
         (root / "instruction.md").write_text(
             task.prompt + "\n\nWrite your final answer to /app/answer.txt (UTF-8).\n",
             encoding="utf-8",
         )
         (root / "environment").mkdir()
         (root / "environment" / "Dockerfile").write_text(
-            "FROM python:3.13-slim\nWORKDIR /app\n", encoding="utf-8"
         )
         write_json(tests / "reference.json", private_record(task))
         # Package source is bundled only into the trusted verifier build context.
@@ -80,16 +117,18 @@ def export_tasks(tasks, output):
             target = tests / "mathematics_rl" / relative
             target.parent.mkdir(parents=True, exist_ok=True)
             target.write_bytes(content)
-        (tests / "Dockerfile").write_text(
-            "FROM python:3.13-slim\nRUN pip install --no-cache-dir sympy==1.14.0\n"
-            "COPY . /tests\nENV PYTHONPATH=/tests\nWORKDIR /tests\n",
-            encoding="utf-8",
         )
         (tests / "test.sh").write_text(
             "#!/bin/sh\nset -eu\nexport PYTHONPATH=/tests\n"
             "python -m mathematics_rl.adapters.harbor\n",
             encoding="utf-8",
         )
         solution = root / "solution"
         solution.mkdir()
         write_json(solution / "answer.json", task.answer)
@@ -99,6 +138,7 @@ def export_tasks(tasks, output):
             "Path('/app/answer.txt').write_text(json.loads("
             "Path('/solution/answer.json').read_text(encoding='utf-8')), encoding='utf-8')\nPY\n",
             encoding="utf-8",
         )
         manifest.append({"directory": root.name, "task_id": task.id, "module": task.module})
     write_json(output / "selection.json", {"framework": "harbor", "tasks": manifest})
@@ -110,21 +150,26 @@ def verify_task(reference, answer, log_dir):
     log_dir = Path(log_dir)
     log_dir.mkdir(parents=True, exist_ok=True)
     reward_file = log_dir / "reward.txt"
-    reward_file.write_text("0\n", encoding="utf-8")
     task = Example(**json.loads(Path(reference).read_text(encoding="utf-8")))
     answer = Path(answer)
-    try:
-        info = answer.lstat()
-        if not stat.S_ISREG(info.st_mode) or info.st_size > MAX_COMPLETION * 4:
-            raise ValueError("Invalid answer artifact")
-        completion = answer.read_bytes()[: MAX_COMPLETION * 4 + 1].decode("utf-8")
-    except (OSError, ValueError):
-        write_json(log_dir / "grading.json", {"reward": 0.0, "status": "invalid_artifact"})
-        return 0.0
     with Grader() as grader:
         result = checked_grade(grader, task, completion)
     write_json(log_dir / "grading.json", result.to_dict())
-    reward_file.write_text(f"{result.reward}\n", encoding="utf-8")
     return result.reward

 """Harbor 0.24 task-directory export with a separate trusted verifier environment."""
+import hashlib
 import json
 import stat
+import tarfile
 from pathlib import Path
 from .. import __version__
 from ..worker import Grader
 from .common import checked_grade, private_record, write_json
+BASE_IMAGE = (
+    "python:3.13.14-slim@sha256:9662417aace5ae7b8e2609cce472b72a8958e134ba372808abe9cc1a0c0125e6"
+)
 TASK_TOML = """schema_version = "1.4"
 artifacts = ["/app/answer.txt"]
 [task]
 memory_mb = 512
 storage_mb = 1024
 gpus = 0
+# Docker network isolation is configured in tests/docker-compose.yaml.
 """
+def build_verifier_payload(tests):
+    """Snapshot private inputs into one content-addressed build-context file."""
+    tests = Path(tests)
+    archive = tests / "payload.tar"
+    with tarfile.open(archive, "w", format=tarfile.PAX_FORMAT) as output:
+        paths = [tests / "reference.json", tests / "test.sh"]
+        paths.extend(sorted((tests / "mathematics_rl").rglob("*.py")))
+        for path in paths:
+            info = output.gettarinfo(str(path), arcname=path.relative_to(tests).as_posix())
+            info.mtime = info.uid = info.gid = 0
+            info.uname = info.gname = ""
+            info.pax_headers = {}
+            with path.open("rb") as source:
+                output.addfile(info, source)
+    digest = hashlib.sha256(archive.read_bytes()).hexdigest()
+    archive.replace(tests / f"payload-{digest}.tar")
+    reference_sha = hashlib.sha256((tests / "reference.json").read_bytes()).hexdigest()
+    (tests / "Dockerfile").write_text(
+        f"FROM {BASE_IMAGE}\nRUN pip install --no-cache-dir sympy==1.14.0\n"
+        f'LABEL mathematics.rl.reference.sha256="{reference_sha}"\n'
+        # Unique source names avoid cross-task directory transfer/cache reuse.
+        f"ADD payload-{digest}.tar /tests/\n"
+        f"RUN echo '{reference_sha}  /tests/reference.json' | sha256sum -c -\n"
+        "ENV PYTHONPATH=/tests\nWORKDIR /tests\n",
+        encoding="utf-8",
+        newline="\n",
+    )
 def export_tasks(tasks, output):
     output = Path(output)
     output.mkdir(parents=True, exist_ok=False)
         (root / "task.toml").write_text(
             TASK_TOML.format(name=name, version=__version__, **private_record(task)),
             encoding="utf-8",
+            newline="\n",
         )
         (root / "instruction.md").write_text(
             task.prompt + "\n\nWrite your final answer to /app/answer.txt (UTF-8).\n",
             encoding="utf-8",
+            newline="\n",
         )
         (root / "environment").mkdir()
         (root / "environment" / "Dockerfile").write_text(
+            f"FROM {BASE_IMAGE}\nWORKDIR /app\n", encoding="utf-8", newline="\n"
         )
         write_json(tests / "reference.json", private_record(task))
         # Package source is bundled only into the trusted verifier build context.
             target = tests / "mathematics_rl" / relative
             target.parent.mkdir(parents=True, exist_ok=True)
             target.write_bytes(content)
+        # Docker Desktop kernels may lack nftables FIB_INET. Native Compose
+        # network_mode:none enforces isolation without Harbor's egress sidecar.
+        (tests / "docker-compose.yaml").write_text(
+            "services:\n  main:\n    network_mode: none\n", encoding="utf-8", newline="\n"
         )
         (tests / "test.sh").write_text(
             "#!/bin/sh\nset -eu\nexport PYTHONPATH=/tests\n"
             "python -m mathematics_rl.adapters.harbor\n",
             encoding="utf-8",
+            newline="\n",
         )
+        build_verifier_payload(tests)
         solution = root / "solution"
         solution.mkdir()
         write_json(solution / "answer.json", task.answer)
             "Path('/app/answer.txt').write_text(json.loads("
             "Path('/solution/answer.json').read_text(encoding='utf-8')), encoding='utf-8')\nPY\n",
             encoding="utf-8",
+            newline="\n",
         )
         manifest.append({"directory": root.name, "task_id": task.id, "module": task.module})
     write_json(output / "selection.json", {"framework": "harbor", "tasks": manifest})
     log_dir = Path(log_dir)
     log_dir.mkdir(parents=True, exist_ok=True)
     reward_file = log_dir / "reward.txt"
+    # Harbor consumes a reward file even when test.sh exits nonzero. Source and
+    # infrastructure failures must leave no score, including stale ones.
+    reward_file.unlink(missing_ok=True)
     task = Example(**json.loads(Path(reference).read_text(encoding="utf-8")))
     answer = Path(answer)
     with Grader() as grader:
+        # Validate the source even if the model produced no artifact.
+        checked_grade(grader, task, task.answer)
+        try:
+            info = answer.lstat()
+            if not stat.S_ISREG(info.st_mode) or info.st_size > MAX_COMPLETION * 4:
+                raise ValueError("Invalid answer artifact")
+            completion = answer.read_bytes()[: MAX_COMPLETION * 4 + 1].decode("utf-8")
+        except (OSError, ValueError):
+            write_json(log_dir / "grading.json", {"reward": 0.0, "status": "invalid_artifact"})
+            reward_file.write_text("0\n", encoding="utf-8", newline="\n")
+            return 0.0
         result = checked_grade(grader, task, completion)
     write_json(log_dir / "grading.json", result.to_dict())
+    reward_file.write_text(f"{result.reward}\n", encoding="utf-8", newline="\n")
     return result.reward

rl/tests/test_adapters.py CHANGED Viewed

@@ -1,6 +1,8 @@
 """Shared episode and artifact boundaries, independent of optional framework SDKs."""
 import json
 from dataclasses import replace
 from pathlib import Path
@@ -80,14 +82,27 @@ def test_harbor_export_and_artifact_verification(tmp_path, all_module_examples):
     output = tmp_path / "harbor"
     manifest = export_tasks([task], output)
     root = output / manifest[0]["directory"]
     with pytest.raises(FileExistsError):
         export_tasks([task], output)
     assert "separate" in (root / "task.toml").read_text()
     assert "reference" not in (root / "environment/Dockerfile").read_text()
     assert not list((root / "environment").glob("*.json"))
     answer = tmp_path / "answer.txt"
     logs = tmp_path / "logs"
     reference = root / "tests/reference.json"
     assert verify_task(reference, answer, logs) == 0
     answer.write_text(task.answer, encoding="utf-8")
     assert verify_task(reference, answer, logs) == 1
@@ -97,3 +112,18 @@ def test_harbor_export_and_artifact_verification(tmp_path, all_module_examples):
     answer.write_bytes(b"\xff")
     assert verify_task(reference, answer, logs) == 0
     assert json.loads((logs / "grading.json").read_text())["status"] == "invalid_artifact"

 """Shared episode and artifact boundaries, independent of optional framework SDKs."""
+import hashlib
 import json
+import tarfile
 from dataclasses import replace
 from pathlib import Path
     output = tmp_path / "harbor"
     manifest = export_tasks([task], output)
     root = output / manifest[0]["directory"]
+    for script in (root / "solution/solve.sh", root / "tests/test.sh"):
+        assert b"\r" not in script.read_bytes(), "Linux executable exports must use LF on Windows"
     with pytest.raises(FileExistsError):
         export_tasks([task], output)
     assert "separate" in (root / "task.toml").read_text()
+    assert "network_mode: none" in (root / "tests/docker-compose.yaml").read_text()
     assert "reference" not in (root / "environment/Dockerfile").read_text()
     assert not list((root / "environment").glob("*.json"))
     answer = tmp_path / "answer.txt"
     logs = tmp_path / "logs"
     reference = root / "tests/reference.json"
+    reference_sha = hashlib.sha256(reference.read_bytes()).hexdigest()
+    verifier_image = (root / "tests/Dockerfile").read_text()
+    assert f'mathematics.rl.reference.sha256="{reference_sha}"' in verifier_image
+    assert f"{reference_sha}  /tests/reference.json" in verifier_image
+    archive = next((root / "tests").glob("payload-*.tar"))
+    assert archive.stem == "payload-" + hashlib.sha256(archive.read_bytes()).hexdigest()
+    assert f"ADD {archive.name} /tests/" in verifier_image
+    with tarfile.open(archive) as payload:
+        assert payload.extractfile("reference.json").read() == reference.read_bytes()
+        assert payload.extractfile("test.sh").read() == (root / "tests/test.sh").read_bytes()
     assert verify_task(reference, answer, logs) == 0
     answer.write_text(task.answer, encoding="utf-8")
     assert verify_task(reference, answer, logs) == 1
     answer.write_bytes(b"\xff")
     assert verify_task(reference, answer, logs) == 0
     assert json.loads((logs / "grading.json").read_text())["status"] == "invalid_artifact"
+def test_harbor_source_errors_never_leave_a_model_reward(tmp_path, all_module_examples):
+    task = replace(all_module_examples[0], answer="invalid reference")
+    output = tmp_path / "export"
+    manifest = export_tasks([task], output)
+    reference = output / manifest[0]["directory"] / "tests/reference.json"
+    logs = tmp_path / "logs"
+    logs.mkdir()
+    reward = logs / "reward.txt"
+    reward.write_text("1\n")
+    # Missing model output must not hide an invalid source reference either.
+    with pytest.raises(ValueError, match="source"):
+        verify_task(reference, tmp_path / "missing-answer.txt", logs)
+    assert not reward.exists()

rl/uv.lock CHANGED Viewed

@@ -708,7 +708,7 @@ name = "cffi"
 version = "2.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pycparser", marker = "implementation_name != 'PyPy' or (extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" }
 wheels = [
@@ -933,7 +933,7 @@ name = "connectrpc"
 version = "0.11.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "protobuf-py", marker = "extra == 'extra-14-mathematics-rl-agentenv' or extra == 'extra-14-mathematics-rl-verifiers'" },
     { name = "pyqwest", version = "0.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-14-mathematics-rl-agentenv' or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
     { name = "pyqwest", version = "0.12.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-14-mathematics-rl-verifiers'" },
 ]
@@ -1004,7 +1004,7 @@ name = "cryptography"
 version = "50.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9d/af/182eb91b0df3fe75c4d9f26fe70684569566745f6ba7e5c9c73a862c5252/cryptography-50.0.2.tar.gz", hash = "sha256:7b46165bb56eb4704e2eaaf86f3c940d19154535d9b0ca7d6d590b04060e00d5", size = 880623, upload-time = "2026-09-30T15:30:04.884Z" }
 wheels = [
@@ -2778,7 +2778,7 @@ wheels = [
 [[package]]
 name = "mathematics-rl"
-version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "datasets" },
@@ -4381,7 +4381,7 @@ name = "protobuf-py"
 version = "0.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "protobuf-py-ext", marker = "(platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'arm64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-agentenv') or (platform_machine == 'arm64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-agentenv') or (platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-agentenv') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-agentenv') or (platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-agentenv') or (platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'arm64' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'arm64' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'arm64' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine != 'arm64' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_machine == 'ARM64' and sys_platform == 'win32' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_python_implementation != 'CPython' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_python_implementation != 'CPython' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_python_implementation != 'CPython' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (platform_python_implementation != 'CPython' and sys_platform == 'darwin' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/72/ed/02fd902d9c51b7ff53dfc9a745eb11490722edfd30073af889e171f07b8e/protobuf_py-0.1.1.tar.gz", hash = "sha256:6bd08ac4d8f1661965bbe2685429d79043704cdd1ee720a7a89617331742240b", size = 133525, upload-time = "2026-06-24T19:02:15.271Z" }
 wheels = [
@@ -5334,7 +5334,7 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
     { name = "rpds-py" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
 wheels = [
@@ -5964,7 +5964,7 @@ version = "1.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ad/eb/4e197bf26b023abafc5e9043ec8710d7de0fcb032d0969045236d72aa0b1/starlette-1.9.0.tar.gz", hash = "sha256:3d931de246ed870e35ce605974440816ef895e592f255d1396cfdf191d4c4318", size = 2732466, upload-time = "2026-10-18T15:50:33.189Z" }
 wheels = [
@@ -6293,7 +6293,7 @@ version = "0.27.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-doc" },
-    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-14-mathematics-rl-agentenv' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
     { name = "rich" },
     { name = "shellingham" },
 ]

 version = "2.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" }
 wheels = [
 version = "0.11.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "protobuf-py" },
     { name = "pyqwest", version = "0.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-14-mathematics-rl-agentenv' or (extra == 'extra-14-mathematics-rl-harbor' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-nemo' and extra == 'extra-14-mathematics-rl-verifiers') or (extra == 'extra-14-mathematics-rl-openenv' and extra == 'extra-14-mathematics-rl-verifiers')" },
     { name = "pyqwest", version = "0.12.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-14-mathematics-rl-verifiers'" },
 ]
 version = "50.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9d/af/182eb91b0df3fe75c4d9f26fe70684569566745f6ba7e5c9c73a862c5252/cryptography-50.0.2.tar.gz", hash = "sha256:7b46165bb56eb4704e2eaaf86f3c940d19154535d9b0ca7d6d590b04060e00d5", size = 880623, upload-time = "2026-09-30T15:30:04.884Z" }
 wheels = [
 [[package]]
 name = "mathematics-rl"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "datasets" },
 version = "0.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "protobuf-py-ext", marker = "(platform_machine == 'arm64' and platform_python_implementation == 'CPython' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/72/ed/02fd902d9c51b7ff53dfc9a745eb11490722edfd30073af889e171f07b8e/protobuf_py-0.1.1.tar.gz", hash = "sha256:6bd08ac4d8f1661965bbe2685429d79043704cdd1ee720a7a89617331742240b", size = 133525, upload-time = "2026-06-24T19:02:15.271Z" }
 wheels = [
 dependencies = [
     { name = "attrs" },
     { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
 wheels = [
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ad/eb/4e197bf26b023abafc5e9043ec8710d7de0fcb032d0969045236d72aa0b1/starlette-1.9.0.tar.gz", hash = "sha256:3d931de246ed870e35ce605974440816ef895e592f255d1396cfdf191d4c4318", size = 2732466, upload-time = "2026-10-18T15:50:33.189Z" }
 wheels = [
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-doc" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
     { name = "rich" },
     { name = "shellingham" },
 ]