Discover private tests by directory

docs/run-batch.md

@@ -138,6 +138,13 @@ verifier result therefore evaluates the agent workspace, not the untouched
 baseline. A missing `pre_artifacts.sh` is rejected by `run_batch.py`; rerun
 `materialize.py` with the current tools to regenerate the task selection.
 
+Private-test collection is directory-based. The verifier runs pytest on
+`/tests/private_tests`, so task authors may use names such as
+`test_res_export.py` or `test_scientific_invariants.py`; no
+`test_task_NNN.py` filename is required. The task's Compose override mounts the
+bundle's dynamic grader into an existing prebuilt verifier image, so correcting
+test discovery does not require rebuilding the image.
+
 ## Option Reference
 
 | Option | Default | Description |

tasks/task_001/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-001:v0.1.0@sha256:0d884c02831bea451e74ece1d7bce1eab7c799f34a50f4a434d23861dee53b43
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_001/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_001/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_001"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_002/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-002:v0.1.0@sha256:8cbc3c732b8b98f2715f99738209013c0caca2fb1ff9c0b7f5e211036b1e80eb
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_002/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_002/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_002"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_003/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-003:v0.1.0@sha256:a90cf7d8c7c309353c70c6868c6998871b950116d18cdcdb6430fb43eda4e08c
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_003/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_003/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_003"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_004/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-c-task-004:v0.1.0@sha256:2553def59dc88f1886ad281da1d561600560a6f8391f177d33bb9f4975e7cc4f
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_004/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_004/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_004"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_005/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-matlab-octave-task-005:v0.1.0@sha256:db56020a2e81fc2c4e260b63c282330da844c2d7c5ef9af7f8abad13e53e3c42
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_005/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_005/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_005"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_006/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-c-task-006:v0.1.0@sha256:0be098de5952eeccd310f68602f806dbe7c39b8dedd1c8965d2f98b299e243c0
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_006/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_006/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_006"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_007/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-007:v0.1.0@sha256:ba9b6eeba1b6ac397d7878bff2d920b1137caf4fda6909422fa9001aab26b24b
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_007/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_007/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_007"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_008/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-008:v0.1.0@sha256:5b1e0ed6c18402f96002a1f81b227490f66760d62e6aa2c1cbc06e298b01f0d1
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_008/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_008/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_008"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_009/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-009:v0.1.0@sha256:0c86818587e5f1c98083bfaac17dcadd18a387ea5a00652b56abd7643a4300b5
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_009/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_009/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_009"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_010/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-010:v0.1.0@sha256:03c655a61e9cedc38110b358a8513f1f988bac8f00a63af794806a53332cd2ec
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_010/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_010/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_010"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_011/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-011:v0.1.0@sha256:f368455b68e9aa7a13bb1961d2f9a93325626bce0e3ea1f7218b82401dff5568
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_011/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_011/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_011"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_012/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-012:v0.1.0@sha256:30a474abef9e920af0ebeb84d352a977571536f7f46ed36dd1c2e3d69904f367
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_012/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_012/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_012"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_013/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-013:v0.1.0@sha256:0313891e0ae671a89ca41299c724c36c0331f4b6ebec83979b2e0840a8564717
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_013/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_013/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_013"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_014/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-014:v0.1.0@sha256:5febf367b244f786ee2b6fcb2c9b56b7fe7271df98798daa3660a8fc7daf3324
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_014/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_014/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_014"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_015/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-matlab-octave-task-015:v0.1.1@sha256:1715bcb15924adee88f48c6c62ef62753f5a033f55f198dbbb9fcf83018661e8
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_015/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_015/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_015"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_016/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-cython-task-016:v0.1.1@sha256:0f5faca298805d01f881ef0b1dbf658995fc725b850452eb5832a1e627272248
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py

tasks/task_016/tests/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  main:
+    volumes:
+      - type: bind
+        source: ./grader.py
+        target: /tests/grader.py
+        read_only: true

tasks/task_016/tests/grader.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+TASK_ID = "task_016"
+TASK_ROOT = Path("/app") / TASK_ID
+LOG_ROOT = Path("/logs/verifier")
+LOG_ROOT.mkdir(parents=True, exist_ok=True)
+env = os.environ.copy()
+env.update(
+    {
+        "SCI_BENCH_TASK_ID": TASK_ID,
+        "SCI_BENCH_TASK_DIR": str(TASK_ROOT),
+        "PYTHONPATH": f"{TASK_ROOT}:{TASK_ROOT / 'source'}",
+    }
+)
+
+
+def execute(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+
+public = execute([sys.executable, "reproduce.py"], TASK_ROOT)
+junit = LOG_ROOT / "junit.xml"
+# Private tests are a task-owned directory. Their filenames are intentionally
+# unconstrained; pytest discovers every supported test module recursively.
+private = execute(
+    [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={junit}",
+        "/tests/private_tests",
+    ],
+    TASK_ROOT,
+)
+
+private_total = private_passed = private_failed = 0
+if junit.is_file():
+    root = ET.parse(junit).getroot()
+    suites = [root] if root.tag == "testsuite" else root.findall(".//testsuite")
+    private_total = sum(int(suite.attrib.get("tests", "0")) for suite in suites)
+    private_failed = sum(
+        int(suite.attrib.get("failures", "0"))
+        + int(suite.attrib.get("errors", "0"))
+        for suite in suites
+    )
+    private_passed = max(private_total - private_failed, 0)
+
+reward = int(public.returncode == 0 and private.returncode == 0)
+summary = {
+    "reward": reward,
+    "task_id": TASK_ID,
+    "public": {
+        "passed": int(public.returncode == 0),
+        "collected": 1,
+        "return_code": public.returncode,
+    },
+    "private": {
+        "passed": private_passed,
+        "collected": private_total,
+        "failed": private_failed,
+        "return_code": private.returncode,
+    },
+}
+(LOG_ROOT / "reward.json").write_text(json.dumps(summary, indent=2) + "\n")
+(LOG_ROOT / "reward.txt").write_text(f"{reward:.1f}\n")
+(LOG_ROOT / "ctrf.json").write_text(
+    json.dumps(
+        {
+            "reportFormat": "CTRF",
+            "specVersion": "0.0.0",
+            "results": {
+                "summary": {
+                    "tests": private_total,
+                    "passed": private_passed,
+                    "failed": private_failed,
+                },
+                "tests": [],
+            },
+        },
+        indent=2,
+    )
+    + "\n"
+)
+combined = (
+    "== public ==\n"
+    + (public.stdout or "")
+    + "\n== private ==\n"
+    + (private.stdout or "")
+)
+(LOG_ROOT / "test-stdout.txt").write_text(combined)
+(LOG_ROOT / "run.log").write_text(combined)
+print(json.dumps(summary, sort_keys=True))

tasks/task_017/tests/Dockerfile

@@ -1,2 +1,5 @@
 ARG VERIFIER_IMAGE=docker.io/kevinxulearning/swe-bench-science-verifier-python-task-017:v0.1.1@sha256:400c6aa09d0bf39b2af577ba203f9c194bef16d82420b9d79cabcde5a65a6bdf
 FROM ${VERIFIER_IMAGE}
+
+COPY grader.py /tests/grader.py
+RUN chmod 755 /tests/grader.py