Discover private tests by directory (part 4)

tasks/task_073/tests/Dockerfile

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

tasks/task_073/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_073/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_073"
+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_074/tests/Dockerfile

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

tasks/task_074/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_074/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_074"
+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_075/tests/Dockerfile

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

tasks/task_075/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_075/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_075"
+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_076/tests/Dockerfile

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

tasks/task_076/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_076/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_076"
+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_077/tests/Dockerfile

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

tasks/task_077/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_077/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_077"
+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_078/tests/Dockerfile

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

tasks/task_078/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_078/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_078"
+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_079/tests/Dockerfile

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

tasks/task_079/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_079/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_079"
+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_080/tests/Dockerfile

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

tasks/task_080/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_080/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_080"
+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_081/tests/Dockerfile

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

tasks/task_081/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_081/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_081"
+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_082/tests/Dockerfile

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

tasks/task_082/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_082/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_082"
+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_083/tests/Dockerfile

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

tasks/task_083/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_083/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_083"
+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_084/tests/Dockerfile

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

tasks/task_084/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_084/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_084"
+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_085/tests/Dockerfile

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

tasks/task_085/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_085/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_085"
+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_086/tests/Dockerfile

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

tasks/task_086/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_086/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_086"
+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_087/tests/Dockerfile

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

tasks/task_087/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_087/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_087"
+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_088/tests/Dockerfile

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

tasks/task_088/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_088/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_088"
+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_089/tests/Dockerfile

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

tasks/task_089/tests/docker-compose.yaml

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