Discover private tests by directory (part 2)

tasks/task_027/tests/Dockerfile

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

tasks/task_027/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_027/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_027"
+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_028/tests/Dockerfile

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

tasks/task_028/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_028/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_028"
+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_029/tests/Dockerfile

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

tasks/task_029/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_029/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_029"
+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_030/tests/Dockerfile

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

tasks/task_030/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_030/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_030"
+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_031/tests/Dockerfile

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

tasks/task_031/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_031/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_031"
+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_032/tests/Dockerfile

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

tasks/task_032/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_032/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_032"
+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_033/tests/Dockerfile

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

tasks/task_033/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_033/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_033"
+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_034/tests/Dockerfile

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

tasks/task_034/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_034/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_034"
+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_035/tests/Dockerfile

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

tasks/task_035/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_035/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_035"
+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_036/tests/Dockerfile

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

tasks/task_036/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_036/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_036"
+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_037/tests/Dockerfile

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

tasks/task_037/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_037/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_037"
+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_038/tests/Dockerfile

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

tasks/task_038/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_038/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_038"
+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_039/tests/Dockerfile

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

tasks/task_039/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_039/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_039"
+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_040/tests/Dockerfile

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

tasks/task_040/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_040/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_040"
+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_041/tests/Dockerfile

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

tasks/task_041/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_041/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_041"
+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_042/tests/Dockerfile

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

tasks/task_042/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_042/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_042"
+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_043/tests/Dockerfile

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

tasks/task_043/tests/docker-compose.yaml

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