Discover private tests by directory (part 5)

tasks/task_098/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_098"
+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_099/tests/Dockerfile

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

tasks/task_099/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_099/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_099"
+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_100/tests/Dockerfile

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

tasks/task_100/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_100/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_100"
+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_101/tests/Dockerfile

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

tasks/task_101/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_101/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_101"
+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_102/tests/Dockerfile

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

tasks/task_102/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_102/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_102"
+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_103/tests/Dockerfile

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

tasks/task_103/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_103/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_103"
+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_104/tests/Dockerfile

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

tasks/task_104/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_104/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_104"
+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_105/tests/Dockerfile

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

tasks/task_105/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_105/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_105"
+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_106/tests/Dockerfile

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

tasks/task_106/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_106/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_106"
+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_107/tests/Dockerfile

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

tasks/task_107/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_107/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_107"
+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_108/tests/Dockerfile

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

tasks/task_108/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_108/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_108"
+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_109/tests/Dockerfile

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

tasks/task_109/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_109/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_109"
+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_110/tests/Dockerfile

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

tasks/task_110/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_110/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_110"
+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_111/tests/Dockerfile

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

tasks/task_111/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_111/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_111"
+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_112/tests/Dockerfile

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

tasks/task_112/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_112/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_112"
+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_113/tests/Dockerfile

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

tasks/task_113/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_113/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_113"
+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_114/tests/Dockerfile

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

tasks/task_114/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_114/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_114"
+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_115/tests/Dockerfile

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