AutoResearchExam v1.1: run on Harbor main with any agent harness (part 5)

tasks/shortest-valid-ci-l2-ece/environment/docker-compose.yaml

@@ -0,0 +1,76 @@
+# ARE 1.1: grading lives in sidecars. Harbor configures `main` (build, limits, network).
+services:
+  main:
+    depends_on:
+      grader:
+        condition: service_healthy
+    volumes:
+      - are-deliverable-0:/app/output
+
+  grader:
+    build:
+      context: ./are-grader-ctx
+      dockerfile: Dockerfile.are
+      args:
+        ARE_ROLE: val
+    platform: linux/amd64
+    environment:
+      ARE_ROLE: val
+      ARE_PORT: "8000"
+      ARE_BUDGET_SEC: "86400"
+      ARE_ARTIFACT_PATHS: "/app/output"
+      ARE_AGENT_UID: "1001"
+      ARE_GRADE_TIMEOUT_SEC: "1800"
+    volumes:
+      - are-deliverable-0:/run/are-deliverable/app/output
+      - are-secret:/run/are-secret
+    expose:
+      - "8000"
+    cap_add: [SYS_ADMIN]
+    networks: [default, are-private]
+    cpus: 8
+    mem_limit: 14336m
+    depends_on:
+      test-grader:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health', timeout=2)"]
+      interval: 2s
+      timeout: 5s
+      retries: 60
+      start_period: 5s
+
+  test-grader:
+    build:
+      context: ./are-grader-ctx
+      dockerfile: Dockerfile.are
+      args:
+        ARE_ROLE: test
+    platform: linux/amd64
+    environment:
+      ARE_ROLE: test
+      ARE_PORT: "8001"
+      ARE_ARTIFACT_PATHS: "/app/output"
+      ARE_GRADE_TIMEOUT_SEC: "1800"
+    expose:
+      - "8001"
+    volumes:
+      - are-secret:/run/are-secret
+    cap_add: [SYS_ADMIN]
+    networks: [are-private]
+    cpus: 8
+    mem_limit: 14336m
+    healthcheck:
+      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8001/health', timeout=2)"]
+      interval: 2s
+      timeout: 5s
+      retries: 60
+      start_period: 5s
+
+volumes:
+  are-deliverable-0: {}
+  are-secret: {}
+
+networks:
+  are-private:
+    internal: true

tasks/shortest-valid-ci-l2-ece/task.toml

@@ -1,56 +1,70 @@
 schema_version = "1.4"
-artifacts = [ "/app/output",]
+artifacts = [
+    { source = "/var/lib/are", service = "grader" },
+]
 
 [task]
 name = "bespokelabs/shortest-valid-ci-l2-ece"
-version = "1.0.0"
+version = "1.1.0"
 description = ""
-keywords = [ "autoresearch", "machine-learning", "benchmark",]
-[[task.authors]]
-name = "Bespoke Labs"
+keywords = [
+    "autoresearch",
+    "machine-learning",
+    "benchmark",
+]
+authors = [
+    { name = "Bespoke Labs" },
+]
 
 [metadata]
 category = "Machine Learning and AI"
 subcategory = "Model evaluation and benchmarking"
-task_objective = [ "Implement", "Optimize",]
-artifact_type = [ "Single script or program",]
+task_objective = [
+    "Implement",
+    "Optimize",
+]
+artifact_type = [
+    "Single script or program",
+]
 expert_time_estimate_hours = 6.0
+are_version = "1.1"
+budget_seconds = 86400
 
 [verifier]
-timeout_sec = 1800.0
+timeout_sec = 600.0
 environment_mode = "separate"
-collect = []
 
-[verifier.env]
+[[verifier.collect]]
+service = "grader"
+command = "/opt/are/venv/bin/python /opt/are/drain.py"
+timeout_sec = 3600.0
 
 [verifier.environment]
 network_mode = "no-network"
-build_timeout_sec = 3600.0
-os = "linux"
-cpus = 8
-memory_mb = 14336
-storage_mb = 153600
+build_timeout_sec = 600.0
+cpus = 1
+memory_mb = 1024
 gpus = 0
-mcp_servers = []
-
-[verifier.environment.env]
 
 [agent]
 network_mode = "allowlist"
-allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
-timeout_sec = 21600.0
+allowed_hosts = [
+    "api.openai.com",
+    "api.anthropic.com",
+    "grader",
+]
+timeout_sec = 86400.0
 
 [environment]
-network_mode = "allowlist"
-allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+network_mode = "public"
 build_timeout_sec = 3600.0
 os = "linux"
 cpus = 8
 memory_mb = 14336
 storage_mb = 153600
 gpus = 0
-mcp_servers = []
+mcp_servers = [
+    { name = "are", transport = "streamable-http", url = "http://grader:8000/mcp" },
+]
 
 [environment.env]
-
-[solution.env]

tasks/shortest-valid-ci-l2-ece/tests/Dockerfile

@@ -1,41 +1,2 @@
-FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:3.13-slim-bookworm@sha256:01f42367a0a94ad4bc17111776fd66e3500c1d87c15bbd6055b7371d39c124fb
-
-ENTRYPOINT []
-ENV PYTHONPATH=
-ENV PYTHONSAFEPATH=1
-ENV DEBIAN_FRONTEND=noninteractive \
-    PYTHONHASHSEED=0 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    OMP_NUM_THREADS=1 \
-    MKL_NUM_THREADS=1 \
-    OPENBLAS_NUM_THREADS=1 \
-    NUMEXPR_NUM_THREADS=1
-
-RUN useradd --create-home --uid 1001 agent
-
-COPY ./requirements.txt /tmp/requirements.txt
-COPY ./requirements-verifier.txt /tmp/requirements-verifier.txt
-RUN /usr/local/bin/python3 -m pip install --no-cache-dir \
-        -r /tmp/requirements.txt -r /tmp/requirements-verifier.txt \
-    && rm /tmp/requirements.txt /tmp/requirements-verifier.txt
-
-RUN mkdir -p /app/output /logs/verifier /opt/candrun
-
-COPY . /tests
-
-RUN cp /tests/run_call.py /opt/candrun/run_call.py \
-    && chown root:root /opt/candrun /opt/candrun/run_call.py \
-    && chmod 755 /opt/candrun \
-    && chmod 444 /opt/candrun/run_call.py \
-    && chown -R root:root /tests /home/agent \
-    && chmod 755 /home/agent \
-    && chmod 755 /tmp /var/tmp \
-    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
-    && chmod +x /tests/test.sh /tests/intermediate.sh \
-    && find /tests -exec touch -d @1700000000 {} +
-
-WORKDIR /tests
-
-ENV HF_HUB_OFFLINE=1
-ENV TRANSFORMERS_OFFLINE=1
+FROM python:3.12-slim
+COPY . /tests/

tasks/shortest-valid-ci-l2-ece/tests/finalize.py

@@ -0,0 +1,59 @@
+"""Final verifier: score the run from the grader ledger.
+
+reward      hidden test score of the submission with the best validation score
+            (ties go to the earlier submission); 0 if nothing was submitted.
+auarc       area under the curve of that same quantity over the wall-clock budget,
+            using the time each validation score became available, divided by the
+            budget. 0 before the first graded submission.
+"""
+
+import json
+from pathlib import Path
+
+STATE = Path("/var/lib/are")
+OUT = Path("/logs/verifier")
+OUT.mkdir(parents=True, exist_ok=True)
+
+meta = json.loads((STATE / "meta.json").read_text()) if (STATE / "meta.json").exists() else {}
+budget = float(meta.get("budget_seconds") or 1.0)
+
+subs: dict[int, dict] = {}
+ledger = STATE / "ledger.jsonl"
+for line in (ledger.read_text().splitlines() if ledger.exists() else []):
+    ev = json.loads(line)
+    s = subs.setdefault(ev["id"], {"id": ev["id"]})
+    if ev["event"] == "submitted":
+        s["submitted_t"] = ev["t"]
+    elif ev["event"] == "val":
+        s["val"] = ev["score"]
+        s["val_t"] = ev["t"]
+    elif ev["event"] == "test":
+        s["test"] = ev["score"]
+
+graded = sorted((s for s in subs.values() if "val" in s), key=lambda s: s["val_t"])
+
+# Step function of the hidden score of the best-validation pick over time.
+auc, best, last_t, cur = 0.0, None, 0.0, 0.0
+timeline = []
+for s in graded:
+    t = min(s["val_t"], budget)
+    auc += cur * (t - last_t)
+    last_t = t
+    if best is None or s["val"] > best["val"] or (s["val"] == best["val"] and s["id"] < best["id"]):
+        best = s
+        cur = float(best.get("test") or 0.0)
+    timeline.append({"t": s["val_t"], "id": s["id"], "val": s["val"], "test": s.get("test"),
+                     "pick": best["id"]})
+auc += cur * (budget - last_t) if last_t < budget else 0.0
+
+reward = {
+    "reward": float(best.get("test") or 0.0) if best else 0.0,
+    "auarc": auc / budget,
+    "best_val": float(best["val"]) if best else 0.0,
+    "n_submissions": float(len(subs)),
+    "n_test_graded": float(sum(s.get("test") is not None for s in subs.values())),
+}
+(OUT / "reward.json").write_text(json.dumps(reward))
+(OUT / "timeline.json").write_text(json.dumps({"budget": budget, "selected": best and best["id"],
+                                               "submissions": timeline}, indent=1))
+print(json.dumps(reward, indent=1))

tasks/shortest-valid-ci-l2-ece/tests/test.sh

@@ -1,18 +1,2 @@
 #!/bin/bash
-set -u
-
-mkdir -p /logs/verifier
-chown root:root /logs/verifier 2>/dev/null || true
-chmod 755 /logs/verifier 2>/dev/null || true
-rm -f /logs/verifier/reward.txt /logs/verifier/ctrf.json /logs/verifier/metric.json
-
-trap 'if [ ! -s /logs/verifier/reward.txt ]; then echo "0" > /logs/verifier/reward.txt; fi' EXIT
-
-chmod -R go-rwx /tests
-
-export GRADE_SPLIT=final
-cd /tests
-/usr/local/bin/python3 -m pytest --ctrf /logs/verifier/ctrf.json /tests/test_state.py -rA
-/usr/local/bin/python3 /tests/compute_reward.py
-
-exit 0
+python3 /tests/finalize.py

tasks/sketched-newton-cov-estimator/environment/.dockerignore

@@ -0,0 +1 @@
+are-grader-ctx

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/Dockerfile

@@ -0,0 +1,31 @@
+FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:3.13-slim-bookworm@sha256:01f42367a0a94ad4bc17111776fd66e3500c1d87c15bbd6055b7371d39c124fb
+
+ENTRYPOINT []
+ENV PYTHONPATH=
+ENV PYTHONSAFEPATH=1
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONHASHSEED=0 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    OMP_NUM_THREADS=1 \
+    OPENBLAS_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1
+
+RUN useradd --create-home --uid 1001 agent
+
+COPY ./requirements.txt /tmp/requirements.txt
+COPY ./requirements-verifier.txt /tmp/requirements-verifier.txt
+RUN /usr/local/bin/python3 -m pip install --no-cache-dir \
+        -r /tmp/requirements.txt -r /tmp/requirements-verifier.txt \
+    && rm /tmp/requirements.txt /tmp/requirements-verifier.txt
+
+RUN mkdir -p /app/output /logs/verifier
+
+COPY . /tests
+
+RUN chown -R root:root /tests \
+    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
+    && chmod +x /tests/test.sh /tests/intermediate.sh \
+    && find /tests -exec touch -d @1700000000 {} +
+
+WORKDIR /tests

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/Dockerfile.are

@@ -0,0 +1,49 @@
+FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:3.13-slim-bookworm@sha256:01f42367a0a94ad4bc17111776fd66e3500c1d87c15bbd6055b7371d39c124fb
+
+ENTRYPOINT []
+ENV PYTHONPATH=
+ENV PYTHONSAFEPATH=1
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONHASHSEED=0 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    OMP_NUM_THREADS=1 \
+    OPENBLAS_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1
+
+RUN useradd --create-home --uid 1001 agent
+
+COPY ./requirements.txt /tmp/requirements.txt
+COPY ./requirements-verifier.txt /tmp/requirements-verifier.txt
+RUN /usr/local/bin/python3 -m pip install --no-cache-dir \
+        -r /tmp/requirements.txt -r /tmp/requirements-verifier.txt \
+    && rm /tmp/requirements.txt /tmp/requirements-verifier.txt
+
+RUN mkdir -p /app/output /logs/verifier
+
+COPY . /tests
+
+RUN chown -R root:root /tests \
+    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
+    && chmod +x /tests/test.sh /tests/intermediate.sh \
+    && find /tests -exec touch -d @1700000000 {} +
+
+WORKDIR /tests
+
+
+# ---- ARE 1.1 grader layer (appended to the task's own verifier Dockerfile) ----
+ARG ARE_ROLE
+# python.org images ship /usr/local/bin/python3; distro-python bases (kaggle GPU) lack
+# ensurepip, so fall back to a pip-less venv filled by the base interpreter's pip.
+RUN PY=$(command -v /usr/local/bin/python3 || command -v python3) \
+    && if "$PY" -m venv /opt/are/venv; then \
+         /opt/are/venv/bin/pip install --no-cache-dir "fastmcp==2.14.7"; \
+       else rm -rf /opt/are/venv && "$PY" -m venv --without-pip /opt/are/venv \
+         && "$PY" -m pip --python /opt/are/venv/bin/python install --no-cache-dir "fastmcp==2.14.7"; fi
+COPY are/ /opt/are/
+# The val grader, whose output reaches the agent, never holds the private grader or its
+# data. The test grader keeps everything; nothing from it reaches the agent.
+RUN rm -rf /tests/are /tests/Dockerfile.are \
+    && if [ "$ARE_ROLE" = "val" ]; then rm -rf /tests/test.sh /tests/hidden_data/final; fi
+ENV ARE_ROLE=$ARE_ROLE
+CMD ["/opt/are/venv/bin/python", "/opt/are/server.py"]

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/are/drain.py

@@ -0,0 +1,25 @@
+"""Verifier collect hook, run after the agent stops.
+
+Grades the final workspace as one last submission (unless it equals the last one),
+then waits until every submission has both grades recorded.
+"""
+
+import json
+import time
+import urllib.request
+from pathlib import Path
+
+TOKEN = Path("/run/are-secret/token").read_text().strip()
+H = {"x-are-token": TOKEN}
+
+req = urllib.request.Request("http://localhost:8000/final", method="POST", headers=H)
+with urllib.request.urlopen(req, timeout=120) as resp:
+    print("final:", json.loads(resp.read()), flush=True)
+
+while True:
+    with urllib.request.urlopen(urllib.request.Request("http://localhost:8000/drain", headers=H), timeout=30) as resp:
+        state = json.loads(resp.read())
+    print(state, flush=True)
+    if state["val_pending"] == 0 and state["test_pending"] == 0:
+        break
+    time.sleep(5)

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/are/server.py

@@ -0,0 +1,538 @@
+"""ARE 1.1 grader sidecar.
+
+One image, two roles:
+
+- ARE_ROLE=val  ("grader" service). Reachable from the agent. Serves MCP tools and a
+  REST fallback. On submit it snapshots the shared deliverable volume, grades the
+  snapshot with the task's public grader (intermediate.sh), and returns only that
+  score. Every snapshot is also sent to the test grader; the hidden score goes to a
+  root-only ledger and never back to the agent.
+- ARE_ROLE=test ("test-grader" service). On a private network that only the val
+  grader can reach. Grades snapshots with the task's private grader (test.sh).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import gzip
+import hashlib
+import io
+import secrets
+import json
+import os
+import queue
+import shutil
+import subprocess
+import tarfile
+import threading
+import time
+import urllib.request
+from pathlib import Path
+
+from fastmcp import FastMCP
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+ROLE = os.environ.get("ARE_ROLE", "val")
+PORT = int(os.environ.get("ARE_PORT", "8000"))
+STATE = Path(os.environ.get("ARE_STATE_DIR", "/var/lib/are"))
+ARTIFACT_PATHS = [p for p in os.environ.get("ARE_ARTIFACT_PATHS", "/app/output").split(":") if p]
+# The shared deliverable volume. Its parent is root-only, so submitted code (which every
+# task grader runs as the unprivileged agent user) cannot reach it to write back to the agent.
+SUBMISSION_ROOT = Path(os.environ.get("ARE_SUBMISSION_ROOT", "/run/are-deliverable"))
+AGENT_UID = int(os.environ.get("ARE_AGENT_UID", "1001"))
+BUDGET_SEC = float(os.environ.get("ARE_BUDGET_SEC", "14400"))
+GRADE_TIMEOUT_SEC = float(os.environ.get("ARE_GRADE_TIMEOUT_SEC", "1800"))
+TEST_GRADER_URL = os.environ.get("ARE_TEST_GRADER_URL", "http://test-grader:8001")
+FEEDBACK_TAIL = int(os.environ.get("ARE_FEEDBACK_TAIL_CHARS", "8192"))
+SCRIPT = "/tests/intermediate.sh" if ROLE == "val" else "/tests/test.sh"
+# Shared only by the two graders (a volume the agent's container never mounts). The test
+# grader writes a fresh token at startup; every internal request must carry it, so the
+# agent cannot reach the test grader or the internal endpoints even on a shared network.
+TOKEN_FILE = Path(os.environ.get("ARE_TOKEN_FILE", "/run/are-secret/token"))
+TOKEN = ""
+
+
+def _authorized(request: Request) -> bool:
+    """Internal endpoints need the graders' token; an unset token never matches."""
+    return bool(TOKEN) and secrets.compare_digest(request.headers.get("x-are-token", ""), TOKEN)
+
+
+def _net_isolation_available() -> bool:
+    try:
+        return subprocess.run(["unshare", "-n", "true"], capture_output=True, timeout=10).returncode == 0
+    except Exception:
+        return False
+
+
+NET_ISOLATED = False  # set at startup: grader scripts run in an empty network namespace
+
+T0 = time.time()
+_lock = threading.Lock()
+
+
+def _elapsed() -> float:
+    return round(time.time() - T0, 1)
+
+
+def _ledger(event: dict) -> None:
+    event = {"t": _elapsed(), "wall": time.time(), **event}
+    for attempt in range(3):
+        try:
+            with _lock, open(STATE / "ledger.jsonl", "a") as fh:
+                fh.write(json.dumps(event) + "\n")
+            return
+        except OSError:
+            if attempt == 2:
+                raise
+            time.sleep(1)
+
+
+def _kill_grading_processes(proc: subprocess.Popen) -> None:
+    """Kill everything a timed-out grade started, including processes that left its group."""
+    try:
+        os.killpg(proc.pid, 9)
+    except ProcessLookupError:
+        pass
+    _kill_other_processes()
+
+
+def _kill_other_processes() -> None:
+    """Kill every process run by the agent user. Every task grader runs submitted code as
+    that user, so this stops all graded code (detached or not) and nothing else: the grader
+    server, the task's own grader and Harbor's hooks run as root."""
+    for entry in Path("/proc").iterdir():
+        if not entry.name.isdigit():
+            continue
+        try:
+            if entry.stat().st_uid == AGENT_UID:
+                os.kill(int(entry.name), 9)
+        except (ProcessLookupError, PermissionError, FileNotFoundError):
+            pass
+
+
+# Places the agent user (who runs submitted code inside every task grader) can write.
+_BASELINE: set[str] = set()  # every path that existed when the grader started (its image)
+
+
+def _walk_one_fs(base: Path):
+    """Every path under base on base's own filesystem (skips /proc, /sys and other mounts)."""
+    dev = base.stat().st_dev
+    for root, dirs, files in os.walk(base):
+        dirs[:] = [d for d in dirs if os.lstat(os.path.join(root, d)).st_dev == dev]
+        for name in dirs + files:
+            yield Path(root) / name
+
+
+def _all_paths() -> set[str]:
+    out = set()
+    for base in (Path("/"), Path("/dev/shm")):
+        if base.is_dir():
+            out.update(str(q) for q in _walk_one_fs(base))
+    return out
+
+
+def _protected(path: str) -> bool:
+    keep = [str(STATE), "/opt/are", str(TOKEN_FILE.parent)]
+    return any(path == k or path.startswith(k + "/") for k in keep)
+
+
+def _fresh_state() -> None:
+    """Start every grade from the grader image's own files, as ARE 1.0's fresh verifier
+    container did. The grader container lives for the whole run, so before each grade
+    stop anything an earlier grade left running and delete every file it created,
+    whoever wrote it. The deliverable volume and the token are separate mounts and are
+    never walked; the grader's own state is kept."""
+    _kill_other_processes()
+    # System V shared memory, semaphores and queues outlive processes; this server uses none.
+    subprocess.run(["ipcrm", "--all"], capture_output=True)
+    for path in sorted(_all_paths() - _BASELINE, key=lambda q: q.count("/"), reverse=True):
+        if _protected(path):
+            continue
+        try:
+            q = Path(path)
+            if q.is_dir() and not q.is_symlink():
+                shutil.rmtree(q, ignore_errors=True)
+            else:
+                q.unlink()
+        except OSError:
+            pass
+
+
+def grade_snapshot(tar_bytes: bytes, tag: str) -> dict:
+    """Extract a snapshot over the artifact paths and run this role's grader script."""
+    _fresh_state()
+    for path in ARTIFACT_PATHS:
+        p = Path(path)
+        if p.exists():
+            shutil.rmtree(p)
+        p.mkdir(parents=True)
+    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:gz") as tf:
+        tf.extractall("/", filter="tar")
+    logs = Path("/logs/verifier")
+    if logs.exists():
+        shutil.rmtree(logs)
+    logs.mkdir(parents=True)
+    started = time.time()
+    # Submitted code runs with no network, as in ARE 1.0's verifier.
+    cmd = (["unshare", "-n"] if NET_ISOLATED else []) + ["bash", SCRIPT]
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+                            cwd="/tests", start_new_session=True)
+    try:
+        out, err = proc.communicate(timeout=GRADE_TIMEOUT_SEC)
+        error = None
+    except subprocess.TimeoutExpired:
+        _kill_grading_processes(proc)
+        out, err = proc.communicate()
+        error = f"grader timed out after {GRADE_TIMEOUT_SEC:.0f}s"
+    output = (out or "") + (err or "")
+    # Nothing a grade started may keep running after it, not even detached processes.
+    _kill_other_processes()
+    score = 0.0
+    reward_file = logs / "reward.txt"
+    if reward_file.exists():
+        try:
+            score = float(reward_file.read_text().strip() or 0)
+        except ValueError:
+            error = error or "unparseable reward"
+    metric = None
+    if (logs / "metric.json").exists():
+        try:
+            metric = json.loads((logs / "metric.json").read_text())
+        except ValueError:
+            pass
+    (STATE / "logs").mkdir(exist_ok=True)
+    (STATE / "logs" / f"{tag}.log").write_text(output)
+    return {
+        "score": score,
+        "metric": metric,
+        "error": error,
+        "net_isolated": NET_ISOLATED,
+        "seconds": round(time.time() - started, 1),
+        # What the agent sees, as in ARE 1.0: the grader's stdout tail (not stderr).
+        "output_tail": (out or "")[-FEEDBACK_TAIL:],
+    }
+
+
+mcp = FastMCP("are")
+
+
+# ---------------------------------------------------------------- test role
+
+
+_grade_lock = threading.Lock()
+
+
+def _grade_one_at_a_time(tar_bytes: bytes, tag: str) -> dict:
+    # A request that timed out on the caller's side may still be grading; the next one
+    # waits for it rather than sharing /app/output and /logs/verifier with it.
+    with _grade_lock:
+        return grade_snapshot(tar_bytes, tag)
+
+
+if ROLE == "test":
+
+    @mcp.custom_route("/grade", methods=["POST"])
+    async def http_grade(request: Request) -> Response:
+        if not _authorized(request):
+            return JSONResponse({"error": "forbidden"}, status_code=403)
+        tag = request.query_params.get("tag", "x")
+        body = await request.body()
+        result = await asyncio.to_thread(_grade_one_at_a_time, body, f"{tag}-test")
+        return JSONResponse(result)
+
+
+# ----------------------------------------------------------------- val role
+
+
+class Board:
+    """Submissions and their grading state. Hidden scores are never stored here."""
+
+    def __init__(self) -> None:
+        self.subs: dict[int, dict] = {}
+        self.val_q: queue.Queue[int] = queue.Queue()
+        self.next_id = 1
+        self.test_pending = 0
+        self.last_digest: str | None = None
+
+    def public(self, sid: int) -> dict:
+        s = self.subs[sid]
+        out = {k: s[k] for k in ("id", "note", "submitted_at_s", "status")}
+        if s["status"] == "graded":
+            v = s["val"]
+            out.update(
+                validation_score=v["score"],
+                error=v["error"],
+                grading_seconds=v["seconds"],
+                grader_output_tail=v["output_tail"],
+            )
+        return out
+
+    def best(self) -> dict | None:
+        graded = [s for s in self.subs.values() if s["status"] == "graded"]
+        if not graded:
+            return None
+        b = max(graded, key=lambda s: (s["val"]["score"], -s["id"]))
+        return {"id": b["id"], "validation_score": b["val"]["score"]}
+
+
+board = Board()
+
+
+def snapshot() -> bytes:
+    """Deterministic tar.gz of the deliverable: same content, same bytes (gzip mtime 0)."""
+    raw = io.BytesIO()
+    with tarfile.open(fileobj=raw, mode="w") as tf:
+        for path in ARTIFACT_PATHS:
+            src = SUBMISSION_ROOT / path.lstrip("/")
+            tf.add(str(src), arcname=path.lstrip("/"))
+    out = io.BytesIO()
+    with gzip.GzipFile(fileobj=out, mode="wb", mtime=0) as gz:
+        gz.write(raw.getvalue())
+    return out.getvalue()
+
+
+def do_submit(note: str, final: bool = False) -> dict:
+    with _lock:
+        pending = [s["id"] for s in board.subs.values() if s["status"] != "graded"]
+        if pending and not final:
+            return {
+                "error": f"Submission {pending[0]} is still being graded. One submission is "
+                         f"graded at a time: check result({pending[0]}) and submit again "
+                         "once it has its score.",
+                "pending_id": pending[0],
+            }
+        sid = board.next_id
+        board.next_id += 1
+        board.subs[sid] = {"id": sid, "note": note[:500], "submitted_at_s": _elapsed(),
+                           "status": "queued"}
+    try:
+        data = snapshot()
+        digest = hashlib.sha256(data).hexdigest()
+        (STATE / "snapshots" / f"{sid:04d}.tar.gz").write_bytes(data)
+        _ledger({"event": "submitted", "id": sid, "note": note[:500], "bytes": len(data),
+                 "sha256": digest, "final": final})
+    except Exception as exc:
+        with _lock:
+            board.subs.pop(sid, None)  # release the slot; the id is not reused
+        return {"error": f"Could not snapshot the deliverable ({exc}). Nothing was submitted. "
+                         "Make sure nothing is writing to it, then submit again."}
+    board.last_digest = digest
+    with _lock:
+        board.test_pending += 1
+    board.val_q.put(sid)
+    return {"id": sid, "status": "queued",
+            "hint": "Grading has started. Check result(id) for the validation score."}
+
+
+def final_submit() -> dict:
+    """After the agent stops: grade the final workspace unless it was already submitted."""
+    try:
+        data = snapshot()
+    except Exception as exc:
+        return {"error": f"final snapshot failed: {exc}"}
+    if board.subs and hashlib.sha256(data).hexdigest() == board.last_digest:
+        return {"skipped": "final workspace equals the last submission"}
+    return do_submit("final workspace (automatic)", final=True)
+
+
+def grade_worker() -> None:
+    """Grade each submission on val, then on test, one submission at a time.
+
+    The val score is published as soon as it is ready. The next submission's val grade
+    waits until this test grade is done, so the two graders never run at the same time.
+    """
+    while True:
+        sid = board.val_q.get()
+        board.subs[sid]["status"] = "grading"
+        data = b""
+        try:
+            data = (STATE / "snapshots" / f"{sid:04d}.tar.gz").read_bytes()
+            res = grade_snapshot(data, f"{sid:04d}-val")
+        except Exception as exc:
+            res = {"score": 0.0, "metric": None, "error": f"grader failed: {exc}",
+                   "net_isolated": NET_ISOLATED, "seconds": 0.0, "output_tail": ""}
+        board.subs[sid]["val"] = res
+        board.subs[sid]["status"] = "graded"
+        try:
+            _ledger({"event": "val", "id": sid, **{k: res[k] for k in ("score", "metric", "error", "seconds", "net_isolated")}})
+        except OSError as exc:  # keep grading later submissions
+            print(f"ARE grader: ledger write failed for {sid}: {exc}", flush=True)
+        test_grade(sid, data)
+
+
+def test_grade(sid: int, data: bytes) -> None:
+    try:
+        _test_grade(sid, data)
+    finally:
+        with _lock:
+            board.test_pending -= 1
+
+
+def _test_grade(sid: int, data: bytes) -> None:
+    """Send one snapshot to the test grader. A failed request is retried (the same snapshot
+    is graded again, so a retry can only recover the honest score); a request that ran
+    past its timeout is not, since the grade itself already took the full time."""
+    started = time.time()
+    for attempt in range(3):
+        try:
+            req = urllib.request.Request(
+                f"{TEST_GRADER_URL}/grade?tag={sid:04d}", data=data, method="POST",
+                headers={"x-are-token": TOKEN},
+            )
+            with urllib.request.urlopen(req, timeout=2 * GRADE_TIMEOUT_SEC + 300) as resp:
+                res = json.loads(resp.read())
+            break
+        except Exception as exc:  # recorded, never shown to the agent
+            res = {"score": None, "metric": None, "error": f"test grader: {exc}",
+                   "seconds": round(time.time() - started, 1)}
+            if attempt == 2 or isinstance(exc, TimeoutError) or isinstance(getattr(exc, "reason", None), TimeoutError):
+                break
+            time.sleep(5)
+    try:
+        _ledger({"event": "test", "id": sid, **{k: res.get(k) for k in ("score", "metric", "error", "seconds", "net_isolated")}})
+    except OSError as exc:  # keep grading later submissions
+        print(f"ARE grader: ledger write failed for {sid}: {exc}", flush=True)
+
+
+def with_time(out: dict) -> dict:
+    """Wall-clock accounting on every reply, as the v1 harness gave each phase."""
+    out["total_budget_seconds"] = BUDGET_SEC
+    out["time_remaining_seconds"] = round(max(0.0, BUDGET_SEC - _elapsed()), 1)
+    return out
+
+
+def status_dict() -> dict:
+    return {
+        "submissions": len(board.subs),
+        "queued_or_grading": sum(s["status"] != "graded" for s in board.subs.values()),
+        "best": board.best(),
+    }
+
+
+def current_result(sid: int) -> dict:
+    return board.public(sid)
+
+
+if ROLE == "val":
+
+    @mcp.tool
+    async def submit(note: str = "") -> dict:
+        """Submit the current deliverable for grading.
+
+        Snapshots the deliverable directory right now (later edits do not affect this
+        submission) and starts grading it on the public validation split. Returns at
+        once with a submission id. One submission is graded at a time: check `result`
+        and submit again once the previous submission has its score. `note` is a short
+        description of what changed.
+        """
+        return with_time(await asyncio.to_thread(do_submit, note))
+
+    @mcp.tool
+    async def result(id: int) -> dict:
+        """The current state of a submission: queued, grading, or graded with its
+        validation score and grader output. Returns immediately."""
+        if id not in board.subs:
+            return {"error": f"unknown submission id {id}"}
+        return with_time(current_result(id))
+
+    @mcp.tool
+    async def status() -> dict:
+        """Submission count, whether one is being graded, the best validation score,
+        and the time budget and time remaining."""
+        return with_time(status_dict())
+
+    @mcp.custom_route("/submit", methods=["POST"])
+    async def http_submit(request: Request) -> Response:
+        note = request.query_params.get("note", "")
+        return JSONResponse(with_time(await asyncio.to_thread(do_submit, note)))
+
+    @mcp.custom_route("/result/{sid}", methods=["GET"])
+    async def http_result(request: Request) -> Response:
+        sid = int(request.path_params["sid"])
+        if sid not in board.subs:
+            return JSONResponse({"error": f"unknown submission id {sid}"}, status_code=404)
+        return JSONResponse(with_time(current_result(sid)))
+
+    @mcp.custom_route("/status", methods=["GET"])
+    async def http_status(request: Request) -> Response:
+        return JSONResponse(with_time(status_dict()))
+
+    @mcp.custom_route("/final", methods=["POST"])
+    async def http_final(request: Request) -> Response:
+        if not _authorized(request):
+            return JSONResponse({"error": "forbidden"}, status_code=403)
+        # Collect hook, after the agent has stopped.
+        return JSONResponse(await asyncio.to_thread(final_submit))
+
+    @mcp.custom_route("/drain", methods=["GET"])
+    async def http_drain(request: Request) -> Response:
+        if not _authorized(request):
+            return JSONResponse({"error": "forbidden"}, status_code=403)
+        # Used by the verifier collect hook after the agent has stopped.
+        pending = sum(s["status"] != "graded" for s in board.subs.values())
+        return JSONResponse({"val_pending": pending, "test_pending": board.test_pending})
+
+
+def _gpus() -> list[str]:
+    try:
+        out = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True, timeout=20)
+        return [l for l in out.stdout.splitlines() if l.strip()]
+    except Exception:
+        return []
+
+
+@mcp.custom_route("/health", methods=["GET"])
+async def health(request: Request) -> Response:
+    return JSONResponse({"ok": True, "role": ROLE, "gpus": await asyncio.to_thread(_gpus)})
+
+
+def _setup_token() -> None:
+    global TOKEN
+    if ROLE == "test":
+        TOKEN_FILE.parent.mkdir(parents=True, exist_ok=True)
+        os.chmod(TOKEN_FILE.parent, 0o700)
+        TOKEN = secrets.token_hex(32)
+        TOKEN_FILE.write_text(TOKEN)
+        os.chmod(TOKEN_FILE, 0o600)
+    else:
+        for _ in range(300):  # the test grader is healthy before this one starts
+            if TOKEN_FILE.exists() and TOKEN_FILE.read_text().strip():
+                break
+            time.sleep(1)
+        TOKEN = TOKEN_FILE.read_text().strip()
+    if not TOKEN:
+        raise SystemExit("ARE: empty internal token; refusing to start")
+
+
+def main() -> None:
+    global NET_ISOLATED
+    NET_ISOLATED = _net_isolation_available()
+    if not NET_ISOLATED:
+        # Graded code must never have a network path (for example back through /submit).
+        raise SystemExit("ARE grader: cannot run grades without network access "
+                         "(needs `unshare -n`, i.e. CAP_SYS_ADMIN); refusing to start")
+    STATE.mkdir(parents=True, exist_ok=True)
+    _BASELINE.update(_all_paths())
+    _setup_token()
+    STATE.mkdir(parents=True, exist_ok=True)
+    os.chmod(STATE, 0o700)
+    (STATE / "snapshots").mkdir(exist_ok=True)
+    if ROLE == "val":
+        # The deliverable volume starts empty and root-owned; hand it to the agent user.
+        SUBMISSION_ROOT.mkdir(parents=True, exist_ok=True)
+        os.chmod(SUBMISSION_ROOT, 0o700)
+        for path in ARTIFACT_PATHS:
+            src = SUBMISSION_ROOT / path.lstrip("/")
+            src.mkdir(parents=True, exist_ok=True)
+            os.chown(src, AGENT_UID, AGENT_UID)
+        (STATE / "meta.json").write_text(json.dumps(
+            {"t0_wall": T0, "budget_seconds": BUDGET_SEC, "artifact_paths": ARTIFACT_PATHS}
+        ))
+        threading.Thread(target=grade_worker, daemon=True).start()
+    mcp.run(transport="http", host="0.0.0.0", port=PORT, show_banner=False,
+            uvicorn_config={"timeout_keep_alive": 86400})
+
+
+if __name__ == "__main__":
+    main()

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/compute_reward.py

@@ -0,0 +1,19 @@
+import json
+import math
+from pathlib import Path
+
+REWARD_PATH = Path("/logs/verifier/reward.txt")
+METRIC_PATH = Path("/logs/verifier/metric.json")
+
+try:
+    REWARD_PATH.parent.mkdir(parents=True, exist_ok=True)
+    value = float(json.loads(METRIC_PATH.read_text())["reward"])
+    if not math.isfinite(value):
+        raise ValueError("non-finite reward")
+    reward = f"{min(1.0, max(0.0, value)):.12g}"
+    REWARD_PATH.write_text(reward + "\n")
+    print(f"reward={reward}")
+except Exception as exc:
+    REWARD_PATH.parent.mkdir(parents=True, exist_ok=True)
+    REWARD_PATH.write_text("0\n")
+    print(f"reward=0 (fallback: {exc})")

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/grader_core.py

@@ -0,0 +1,268 @@
+import json
+import math
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import oracle
+
+TESTS_DIR = Path(__file__).resolve().parent
+
+ENTRY_POINT = "estimator.py"
+REPLICATIONS = int(os.environ.get("GRADER_REPLICATIONS", "20"))
+REPLICATION_TIMEOUT_S = 90.0
+TRIVIAL_ERROR = 1.0
+RUN_AS_UID = int(os.environ.get("GRADER_RUN_AS_UID", "1001"))
+WORKERS = int(os.environ.get("GRADER_WORKERS", "8"))
+GLOBAL_DEADLINE_S = float(os.environ.get("GRADER_DEADLINE_S", "1200"))
+
+M0 = 1.0
+BASELINE_SCORE = 0.013
+
+
+def reward_from_metric(metric):
+    """log-ratio squash: 0 at the trivial baseline, 0.5 at the reference, -> 1, no cutoff."""
+    if metric is None:
+        return 0.0
+    m = float(metric)
+    if not math.isfinite(m) or m < 0.0:
+        return 0.0
+    if m == 0.0:
+        return 1.0
+    u = math.log(M0 / m) / math.log(M0 / BASELINE_SCORE)
+    if u <= 0.0:
+        return 0.0
+    return u / (1.0 + u)
+
+
+def load_instances(split_dir):
+    paths = sorted(Path(split_dir).glob("inst_*.json"))
+    if not paths:
+        raise RuntimeError(f"no instances under {split_dir}")
+    return [json.loads(p.read_text()) for p in paths]
+
+
+def instance_covariance(inst):
+    d = int(inst["d"])
+    Sigma = np.full((d, d), float(inst["equi_r"]))
+    np.fill_diagonal(Sigma, 1.0)
+    return Sigma
+
+
+def true_functional(inst):
+    """w' Xi* w for one instance, from the closed form. Never leaves this process."""
+    d = int(inst["d"])
+    Xi = oracle.xi_star(instance_covariance(inst), float(inst["sigma"]) ** 2, int(inst["tau"]))
+    w = np.full(d, 1.0 / d)
+    return float(w @ Xi @ w)
+
+
+def draw_samples(inst, seed):
+    """The realized samples of one replication. The only thing the child is given."""
+    d, T = int(inst["d"]), int(inst["T"])
+    L = np.linalg.cholesky(instance_covariance(inst))
+    rng = np.random.default_rng(seed)
+    A = rng.standard_normal((T, d)) @ L.T
+    b = A @ np.asarray(inst["x_star"], dtype=np.float64) + rng.standard_normal(T) * float(inst["sigma"])
+    return A, b
+
+
+def _launch(workdir, timeout_s):
+    """Run the deliverable in its own session as an unprivileged uid, hard-killed on time.
+
+    Output goes to a file rather than a pipe, so an agent that prints without bound cannot
+    grow the trusted process's memory; only the last 2 kB is ever read back.
+    """
+    py = sys.executable
+    script = str(workdir / "run_one.py")
+    argv = [py, script, "--workdir", str(workdir)]
+    kwargs = dict(cwd=str(workdir / "out"), start_new_session=True,
+                  user=RUN_AS_UID, group=RUN_AS_UID, env={
+                      "PATH": "/usr/local/bin:/usr/bin:/bin",
+                      "HOME": str(workdir / "out"), "TMPDIR": str(workdir / "out"),
+                      "OMP_NUM_THREADS": "1", "OPENBLAS_NUM_THREADS": "1",
+                      "MKL_NUM_THREADS": "1", "NUMEXPR_NUM_THREADS": "1",
+                      "PYTHONHASHSEED": "0", "PYTHONDONTWRITEBYTECODE": "1"})
+
+    log = workdir / "child.log"
+    with open(log, "wb") as fh:
+        proc = subprocess.Popen(argv, stdout=fh, stderr=subprocess.STDOUT, **kwargs)
+        try:
+            proc.communicate(timeout=timeout_s)
+            rc = proc.returncode
+        except subprocess.TimeoutExpired:
+            try:
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            except Exception:
+                proc.kill()
+            proc.communicate()
+            rc = "timeout"
+    tail = ""
+    try:
+        with open(log, "rb") as fh:
+            fh.seek(max(0, log.stat().st_size - 2000))
+            tail = fh.read().decode("utf-8", "replace")
+    except Exception:
+        pass
+    return rc, tail
+
+
+def run_replication(inst, rep, solution_dir, workroot, timeout_s):
+    """Prepare a scratch dir, run one replication, return the raw functional or a failure."""
+    out = {"instance": inst["name"], "rep": rep, "status": "error", "v_hat": None, "detail": ""}
+    if timeout_s <= 1.0:
+        out["status"] = "deadline"
+        return out
+    work = Path(tempfile.mkdtemp(dir=workroot, prefix=f"{inst['name']}_r{rep}_"))
+    try:
+        shutil.copy2(TESTS_DIR / "run_one.py", work / "run_one.py")
+        shutil.copytree(TESTS_DIR / "harness", work / "harness")
+        shutil.copytree(solution_dir, work / "solution", symlinks=True)
+        seed = int(inst["seed_base"]) + 2 * rep
+        A, b = draw_samples(inst, seed)
+        np.save(work / "samples_a.npy", A, allow_pickle=False)
+        np.save(work / "samples_b.npy", b, allow_pickle=False)
+        (work / "job.json").write_text(json.dumps(
+            {"d": int(inst["d"]), "T": int(inst["T"]), "tau": int(inst["tau"]),
+             "alg_seed": seed + 1}))
+        del A, b
+        for p in [work] + list(work.rglob("*")):
+            os.chmod(p, 0o755 if p.is_dir() else 0o644)
+        (work / "out").mkdir()
+        os.chown(work / "out", RUN_AS_UID, RUN_AS_UID)
+        os.chmod(work / "out", 0o700)
+
+        rc, err = _launch(work, timeout_s)
+        if rc == "timeout":
+            out["status"] = "timeout"
+            out["detail"] = f"exceeded {timeout_s:.0f}s"
+            return out
+        if rc != 0:
+            out["status"] = "crashed"
+            out["detail"] = err.strip()[-600:]
+            return out
+
+        res = work / "out" / "result.npy"
+        if not res.exists():
+            out["status"] = "no_output"
+            return out
+        try:
+            M = np.load(res, allow_pickle=False)
+        except Exception as exc:
+            out["status"] = "unparseable"
+            out["detail"] = str(exc)[:200]
+            return out
+        d = int(inst["d"])
+        if M.shape != (d, d) or M.dtype != np.float64:
+            out["status"] = "bad_shape"
+            out["detail"] = f"got shape {M.shape} dtype {M.dtype}"
+            return out
+        if not np.all(np.isfinite(M)):
+            out["status"] = "non_finite"
+            return out
+        w = np.full(d, 1.0 / d)
+        out["v_hat"] = float(w @ M @ w)
+        out["status"] = "ok"
+        return out
+    except Exception as exc:
+        out["status"] = "infra_error"
+        out["detail"] = f"{type(exc).__name__}: {exc}"[:300]
+        return out
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+
+
+def grade(split_dir, deliverable_dir, workroot=None, replications=REPLICATIONS):
+    t0 = time.time()
+    instances = load_instances(split_dir)
+    truth = {i["name"]: true_functional(i) for i in instances}
+
+    entry = Path(deliverable_dir) / ENTRY_POINT
+    have_entry = entry.is_file() and entry.stat().st_size > 0
+    results = []
+
+    if have_entry:
+        workroot = workroot or tempfile.mkdtemp(prefix="grade_")
+        os.chmod(workroot, 0o711)
+        staged = Path(workroot) / "solution"
+        shutil.rmtree(staged, ignore_errors=True)
+        src = Path(deliverable_dir)
+        for p in [src] + list(src.rglob("*")):
+            if p.is_symlink():
+                raise RuntimeError(f"symlink in deliverable is not allowed: {p}")
+        shutil.copytree(deliverable_dir, staged, symlinks=True)
+        for p in [staged] + list(staged.rglob("*")):
+            os.chmod(p, 0o755 if p.is_dir() else 0o644)
+
+        jobs = [(i, r) for i in instances for r in range(replications)]
+
+        def work(job):
+            inst, rep = job
+            left = GLOBAL_DEADLINE_S - (time.time() - t0)
+            return run_replication(inst, rep, staged, workroot,
+                                   min(REPLICATION_TIMEOUT_S, left))
+
+        with ThreadPoolExecutor(max_workers=WORKERS) as pool:
+            results = list(pool.map(work, jobs))
+    else:
+        for inst in instances:
+            for rep in range(replications):
+                results.append({"instance": inst["name"], "rep": rep,
+                                "status": "missing_entry_point", "v_hat": None, "detail": ""})
+
+    per_instance = {}
+    for inst in instances:
+        name = inst["name"]
+        rows = [r for r in results if r["instance"] == name]
+        bad = [r for r in rows if r["status"] != "ok"]
+        if bad or len(rows) != replications:
+            per_instance[name] = {"error": TRIVIAL_ERROR, "failed": len(bad) + replications - len(rows)}
+            continue
+        v = truth[name]
+        rel = np.array([r["v_hat"] for r in rows], dtype=np.float64) / v - 1.0
+        sd = float(rel.std(ddof=1)) if len(rel) > 1 else float("nan")
+        per_instance[name] = {"error": float(abs(rel.mean())), "failed": 0,
+                              "signed_mean": float(rel.mean()),
+                              "sd_per_replication": sd,
+                              "mc_error": sd / math.sqrt(len(rel))}
+
+    metric = float(np.mean([per_instance[i["name"]]["error"] for i in instances]))
+    n_failed = sum(1 for r in results if r["status"] != "ok")
+    statuses = {}
+    for r in results:
+        statuses[r["status"]] = statuses.get(r["status"], 0) + 1
+    first_detail = next((r["detail"] for r in results if r["status"] != "ok" and r["detail"]), "")
+
+    return {
+        "metric": metric,
+        "reward": reward_from_metric(metric),
+        "replications_per_instance": replications,
+        "replications_failed": n_failed,
+        "replication_status_counts": statuses,
+        "first_failure_detail": first_detail,
+        "per_instance": per_instance,
+        "wall_clock_s": round(time.time() - t0, 1),
+    }
+
+
+def summary_lines(report):
+    """The only thing printed to stdout. Aggregates only -- no per-instance detail."""
+    return [
+        f"replications per instance : {report['replications_per_instance']}",
+        f"replications failed       : {report['replications_failed']}"
+        + (f" {report['replication_status_counts']}" if report["replications_failed"] else ""),
+        f"first failure             : {report['first_failure_detail'][:600]}"
+        if report["first_failure_detail"] else "first failure             : -",
+        f"metric (lower is better)  : {report['metric']:.6f}",
+        f"reward                    : {report['reward']:.6f}",
+        f"grading wall clock (s)    : {report['wall_clock_s']}",
+    ]

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/harness/runner.py

@@ -0,0 +1,116 @@
+import numpy as np
+from scipy.linalg import solve_triangular
+
+_BLOCK = 8192
+
+
+def make_config(d, T, tau, w=None):
+    """The `config` dict handed to `estimate`. Contains no instance secrets."""
+    if w is None:
+        w = np.full(d, 1.0 / d)
+    return {
+        "d": int(d),
+        "T": int(T),
+        "tau": int(tau),
+        "q": 1,
+        "sketch": "kaczmarz",
+        "beta": 0.505,
+        "c_beta": 1.0,
+        "loss": "squared_error_linear_regression",
+        "x0": np.zeros(d),
+        "B0": np.eye(d),
+        "w": np.asarray(w, dtype=np.float64),
+    }
+
+
+def draw_samples(instance, seed):
+    """Draw the T samples of one replication from an instance's parameters.
+
+    `instance` needs the keys d, T, sigma, x_star and either Sigma_a or (equi_r).
+    Returns (A, b) with A of shape (T, d) and b of shape (T,).
+    """
+    d, T = int(instance["d"]), int(instance["T"])
+    Sigma_a = instance_covariance(instance)
+    L = np.linalg.cholesky(Sigma_a)
+    rng = np.random.default_rng(seed)
+    A = rng.standard_normal((T, d)) @ L.T
+    eps = rng.standard_normal(T) * float(instance["sigma"])
+    b = A @ np.asarray(instance["x_star"], dtype=np.float64) + eps
+    return A, b
+
+
+def instance_covariance(instance):
+    """Equi-correlation design: [Sigma_a]_ii = 1, [Sigma_a]_ij = r for i != j."""
+    d = int(instance["d"])
+    r = float(instance["equi_r"])
+    Sigma = np.full((d, d), r)
+    np.fill_diagonal(Sigma, 1.0)
+    return Sigma
+
+
+def stream_from_samples(A, b, config, alg_seed):
+    """Yield one record per iteration. `A` is (T, d), `b` is (T,).
+
+    Each record is a fresh dict holding read-only arrays. The runner never writes into an
+    array it has already yielded, so a record stays valid for as long as you keep it.
+        t            int, the iteration index
+        x            (d,)   x_{t+1}, the iterate AFTER this step's update
+        alpha        float  the realized stepsize alpha_t
+        g            (d,)   the stochastic gradient at x_t
+        H            (d, d) the sample Hessian at x_t
+        B            (d, d) the Hessian average B_t used by this step's inner solve
+        sketch_idx   (tau,) the Kaczmarz indices used by this step's inner solve
+    """
+    d = int(config["d"])
+    T = int(config["T"])
+    tau = int(config["tau"])
+    beta = float(config["beta"])
+    c_beta = float(config["c_beta"])
+
+    x = np.array(config["x0"], dtype=np.float64)
+    B = np.array(config["B0"], dtype=np.float64)
+    rng = np.random.default_rng(alg_seed)
+
+    idx_block = None
+    u_block = None
+    for t in range(T):
+        k = t % _BLOCK
+        if k == 0:
+            n = min(_BLOCK, T - t)
+            idx_block = rng.integers(0, d, size=(n, tau))
+            u_block = rng.random(n)
+
+        a = A[t]
+        g = a * (a @ x - b[t])
+
+        idx = idx_block[k]
+        sel = B[:, idx]
+        nrm = np.sqrt(np.einsum("ij,ij->j", sel, sel))
+        F = sel / nrm
+        dx = F @ solve_triangular(np.tril(F.T @ F), -g[idx] / nrm, lower=True,
+                                  unit_diagonal=True, check_finite=False, overwrite_b=True)
+
+        beta_t = c_beta / (t + 1.0) ** beta
+        alpha = beta_t + u_block[k] * beta_t * beta_t
+        x = x + alpha * dx
+
+        H = np.outer(a, a)
+        for arr in (x, g, H, B, idx):
+            arr.flags.writeable = False
+        yield {
+            "t": t,
+            "x": x,
+            "alpha": float(alpha),
+            "g": g,
+            "H": H,
+            "B": B,
+            "sketch_idx": idx,
+        }
+
+        B = ((t + 1.0) * B + H) / (t + 2.0)
+
+
+def make_stream(instance, config, sample_seed, alg_seed):
+    """Convenience wrapper: draw an instance's samples, then stream one replication."""
+    A, b = draw_samples(instance, sample_seed)
+    return stream_from_samples(A, b, config, alg_seed)

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/final/inst_0.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealF0",
+ "d": 20,
+ "T": 300000,
+ "tau": 20,
+ "equi_r": 0.132076,
+ "sigma": 1.035163,
+ "x_star": [
+  -0.019722108888,
+  -0.043768990181,
+  -0.016978953849,
+  -0.041987901786,
+  -0.027223042407,
+  0.006300373844,
+  0.013943979186,
+  -0.019059026608,
+  0.008421650997,
+  -0.079513148397,
+  -0.071653297202,
+  0.053201419509,
+  -0.060378806686,
+  -0.085022153445,
+  -0.005837723371,
+  0.101380431414,
+  0.047635755492,
+  7.7076412e-05,
+  -0.07658615567,
+  0.025033501465
+ ],
+ "seed_base": 841200185
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/final/inst_1.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealF1",
+ "d": 20,
+ "T": 300000,
+ "tau": 40,
+ "equi_r": 0.222325,
+ "sigma": 0.805114,
+ "x_star": [
+  -0.082932808961,
+  0.038545870624,
+  0.004312618402,
+  -0.055654625394,
+  0.020893374205,
+  -0.124393736972,
+  0.057071827706,
+  0.043785304794,
+  -0.042946668716,
+  0.019317748747,
+  0.002910150262,
+  -0.037568440259,
+  -0.055793184577,
+  0.056245388685,
+  -0.031427430157,
+  0.008295253253,
+  0.053125175571,
+  -0.040845921657,
+  -0.040308878577,
+  -0.018703000051
+ ],
+ "seed_base": 939721810
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/final/inst_2.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealF2",
+ "d": 20,
+ "T": 300000,
+ "tau": 10,
+ "equi_r": 0.151511,
+ "sigma": 0.874065,
+ "x_star": [
+  0.095956898049,
+  -0.004996400008,
+  0.006311228453,
+  0.011112538622,
+  -0.009496748634,
+  -0.015015359292,
+  -0.005287695998,
+  0.048944383801,
+  -0.062397368507,
+  0.00238404898,
+  -0.100809118235,
+  0.028671325467,
+  -0.068214488049,
+  -0.023500778765,
+  0.056537806242,
+  -0.033217168108,
+  -0.030644999212,
+  0.011702616777,
+  -0.048161361361,
+  -0.100400192593
+ ],
+ "seed_base": 755664261
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/final/inst_3.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealF3",
+ "d": 20,
+ "T": 300000,
+ "tau": 20,
+ "equi_r": 0.271258,
+ "sigma": 1.751414,
+ "x_star": [
+  0.024972636039,
+  0.03533280065,
+  0.093659428727,
+  -0.041126527796,
+  -0.024346355273,
+  -0.083137388327,
+  -0.037750722609,
+  0.066469180419,
+  -0.003471314605,
+  0.091974410156,
+  -0.010119253259,
+  -0.010260004657,
+  -0.053269325588,
+  0.047791864094,
+  0.04810807302,
+  -0.004704687523,
+  0.003928567812,
+  0.006460957598,
+  0.03196080178,
+  -0.084265993839
+ ],
+ "seed_base": 996720305
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/intermediate/inst_0.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealI0",
+ "d": 20,
+ "T": 300000,
+ "tau": 10,
+ "equi_r": 0.242438,
+ "sigma": 1.987579,
+ "x_star": [
+  0.035973464612,
+  0.027253032917,
+  -0.031596861933,
+  -0.018343116487,
+  -0.020911424013,
+  -0.1491477536,
+  0.013498660293,
+  0.006200096616,
+  -0.015070425319,
+  0.022844567177,
+  -0.077994643809,
+  -0.003851103026,
+  -0.032669570035,
+  0.041203220648,
+  -0.007091550034,
+  0.00811292529,
+  0.065859152925,
+  0.046109225502,
+  -0.04484870205,
+  -0.07431256495
+ ],
+ "seed_base": 801608310
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/intermediate/inst_1.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealI1",
+ "d": 20,
+ "T": 300000,
+ "tau": 40,
+ "equi_r": 0.112021,
+ "sigma": 1.160481,
+ "x_star": [
+  -0.03426103133,
+  0.01757527391,
+  -0.114675095472,
+  -0.03974628369,
+  -0.057236905083,
+  0.005505864975,
+  0.044311780829,
+  -0.017366965234,
+  -0.040559344461,
+  -0.045404460944,
+  -0.002066011218,
+  -0.071839758821,
+  -0.05194956085,
+  -0.05814472584,
+  -0.021194042223,
+  -0.029639640005,
+  -0.038732120007,
+  0.098609447255,
+  0.026606893038,
+  -0.00214245734
+ ],
+ "seed_base": 942125480
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/intermediate/inst_2.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealI2",
+ "d": 20,
+ "T": 300000,
+ "tau": 20,
+ "equi_r": 0.150641,
+ "sigma": 1.9847,
+ "x_star": [
+  0.061912698266,
+  -0.011329243664,
+  0.001349428686,
+  -0.033716256102,
+  -0.066686683827,
+  -0.040736213303,
+  0.055910365725,
+  -0.023177050316,
+  0.037218968578,
+  -0.038877559169,
+  0.071259066126,
+  0.022718553147,
+  0.075966470665,
+  -0.009292402812,
+  -0.116543497448,
+  0.017304237725,
+  -0.038278283045,
+  -0.044425847335,
+  -0.057455316556,
+  0.012664324105
+ ],
+ "seed_base": 462111903
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/hidden_data/intermediate/inst_3.json

@@ -0,0 +1,31 @@
+{
+ "name": "sealI3",
+ "d": 20,
+ "T": 300000,
+ "tau": 40,
+ "equi_r": 0.265884,
+ "sigma": 0.501666,
+ "x_star": [
+  -0.00495812216,
+  0.057794303105,
+  -0.132022500532,
+  5.8374263e-05,
+  0.011778313649,
+  -0.067304320932,
+  0.053298500444,
+  -0.00069184491,
+  0.031638710103,
+  -0.067837987423,
+  -0.002114095999,
+  -0.05050766958,
+  0.040031360963,
+  -0.028814842159,
+  0.037268534752,
+  -0.018590979209,
+  0.016295358434,
+  -0.07212676206,
+  0.008673464269,
+  -0.061859333449
+ ],
+ "seed_base": 385455181
+}

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/intermediate.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -u
+
+mkdir -p /logs/verifier
+chown root:root /logs/verifier 2>/dev/null || true
+chmod 755 /logs/verifier 2>/dev/null || true
+rm -f /logs/verifier/reward.txt /logs/verifier/ctrf.json /logs/verifier/metric.json
+
+printf '0\n' > /logs/verifier/reward.txt
+trap 'if [ ! -s /logs/verifier/reward.txt ]; then printf "0\n" > /logs/verifier/reward.txt; fi' EXIT
+
+chmod -R go-rwx /tests
+
+export GRADE_SPLIT=intermediate
+cd /tests
+/usr/local/bin/python3 -m pytest --ctrf /logs/verifier/ctrf.json /tests/test_state.py -rA
+/usr/local/bin/python3 /tests/compute_reward.py
+
+exit 0

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/oracle.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+
+def _projectors(B):
+    """P[i] = b_i b_i^T / ||b_i||^2 for every column b_i of B."""
+    nrm2 = np.einsum("ij,ij->j", B, B)
+    return np.einsum("ik,jk->kij", B, B) / nrm2[:, None, None]
+
+
+def xi_star(Sigma_a, sigma2, tau):
+    """The limiting covariance of the last iterate, exactly."""
+    Sigma_a = np.asarray(Sigma_a, dtype=np.float64)
+    d = Sigma_a.shape[0]
+    Omega = float(sigma2) * np.linalg.inv(Sigma_a)
+
+    Q = np.eye(d)[None, :, :] - _projectors(Sigma_a)
+    C = np.linalg.matrix_power(Q.mean(axis=0), int(tau))
+
+    A = Omega.copy()
+    for _ in range(int(tau)):
+        A = np.einsum("kij,jl,kml->im", Q, A, Q) / d
+
+    RHS = Omega - C @ Omega - Omega @ C + A
+    RHS = 0.5 * (RHS + RHS.T)
+
+    M = np.eye(d) - C
+    M = 0.5 * (M + M.T)
+    s, U = np.linalg.eigh(M)
+    if s.min() <= 1e-12:
+        raise ValueError("I - C* is singular; Xi* does not exist for this instance")
+    Theta = 1.0 / (s[:, None] + s[None, :])
+    Xi = U @ (Theta * (U.T @ RHS @ U)) @ U.T
+    return 0.5 * (Xi + Xi.T)
+
+
+def sandwich(Sigma_a, sigma2):
+    """Omega*/2, the exact-solver (tau -> infinity) limit. Used only by build-time checks."""
+    return 0.5 * float(sigma2) * np.linalg.inv(np.asarray(Sigma_a, dtype=np.float64))

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/requirements-verifier.txt

@@ -0,0 +1,2 @@
+pytest==8.3.5
+pytest-json-ctrf==0.3.5

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/requirements.txt

@@ -0,0 +1,2 @@
+numpy==2.5.2
+scipy==1.18.0

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/run_one.py

@@ -0,0 +1,35 @@
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--workdir", required=True)
+    args = ap.parse_args()
+    work = Path(args.workdir)
+
+    sys.path.insert(0, str(work / "harness"))
+    import runner
+
+    spec = json.loads((work / "job.json").read_text())
+    config = runner.make_config(spec["d"], spec["T"], spec["tau"])
+
+    A = np.load(work / "samples_a.npy", mmap_mode="r", allow_pickle=False)
+    b = np.load(work / "samples_b.npy", mmap_mode="r", allow_pickle=False)
+    stream = runner.stream_from_samples(A, b, config, spec["alg_seed"])
+
+    sys.path.insert(0, str(work / "solution"))
+    import estimator
+
+    out = estimator.estimate(stream, config)
+    out = np.asarray(out, dtype=np.float64)
+    np.save(work / "out" / "result.npy", out, allow_pickle=False)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -u
+
+mkdir -p /logs/verifier
+chown root:root /logs/verifier 2>/dev/null || true
+chmod 755 /logs/verifier 2>/dev/null || true
+rm -f /logs/verifier/reward.txt /logs/verifier/ctrf.json /logs/verifier/metric.json
+
+printf '0\n' > /logs/verifier/reward.txt
+trap 'if [ ! -s /logs/verifier/reward.txt ]; then printf "0\n" > /logs/verifier/reward.txt; fi' EXIT
+
+chmod -R go-rwx /tests
+
+export GRADE_SPLIT=final
+cd /tests
+/usr/local/bin/python3 -m pytest --ctrf /logs/verifier/ctrf.json /tests/test_state.py -rA
+/usr/local/bin/python3 /tests/compute_reward.py
+
+exit 0

tasks/sketched-newton-cov-estimator/environment/are-grader-ctx/test_state.py

@@ -0,0 +1,39 @@
+import json
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import grader_core
+
+DELIVERABLE = Path(os.environ.get("GRADER_DELIVERABLE", "/app/output"))
+SPLIT = os.environ.get("GRADE_SPLIT", "final")
+SPLIT_DIR = Path(os.environ.get(
+    "GRADER_SPLIT_DIR", str(Path(__file__).resolve().parent / "hidden_data" / SPLIT)))
+METRIC_PATH = Path(os.environ.get("GRADER_METRIC_PATH", "/logs/verifier/metric.json"))
+
+
+def test_limiting_covariance_estimator():
+    """Run the submitted estimator over every sealed instance and score its variance error.
+
+    The agent's code runs only in per-replication subprocesses launched by grader_core, as a
+    non-root uid, with no access to the instance parameters or to the true covariance. This
+    process recomputes the metric from verifier-owned ground truth; nothing the submission
+    reports about itself is read.
+    """
+    report = {"metric": None, "reward": 0.0, "split": SPLIT}
+    try:
+        report = grader_core.grade(str(SPLIT_DIR), str(DELIVERABLE))
+        report["split"] = SPLIT
+    except Exception as exc:
+        report["error"] = f"{type(exc).__name__}: {exc}"
+    finally:
+        METRIC_PATH.parent.mkdir(parents=True, exist_ok=True)
+        METRIC_PATH.write_text(json.dumps(report, indent=1, sort_keys=True) + "\n")
+
+    print("")
+    for line in grader_core.summary_lines(report) if "error" not in report else \
+            [f"grading failed: {report['error']}", "metric (lower is better)  : n/a",
+             "reward                    : 0.000000"]:
+        print(line)
+    assert "error" not in report, report.get("error")

tasks/sketched-newton-cov-estimator/environment/docker-compose.yaml

@@ -0,0 +1,76 @@
+# ARE 1.1: grading lives in sidecars. Harbor configures `main` (build, limits, network).
+services:
+  main:
+    depends_on:
+      grader:
+        condition: service_healthy
+    volumes:
+      - are-deliverable-0:/app/output
+
+  grader:
+    build:
+      context: ./are-grader-ctx
+      dockerfile: Dockerfile.are
+      args:
+        ARE_ROLE: val
+    platform: linux/amd64
+    environment:
+      ARE_ROLE: val
+      ARE_PORT: "8000"
+      ARE_BUDGET_SEC: "86400"
+      ARE_ARTIFACT_PATHS: "/app/output"
+      ARE_AGENT_UID: "1001"
+      ARE_GRADE_TIMEOUT_SEC: "1500"
+    volumes:
+      - are-deliverable-0:/run/are-deliverable/app/output
+      - are-secret:/run/are-secret
+    expose:
+      - "8000"
+    cap_add: [SYS_ADMIN]
+    networks: [default, are-private]
+    cpus: 8
+    mem_limit: 14336m
+    depends_on:
+      test-grader:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health', timeout=2)"]
+      interval: 2s
+      timeout: 5s
+      retries: 60
+      start_period: 5s
+
+  test-grader:
+    build:
+      context: ./are-grader-ctx
+      dockerfile: Dockerfile.are
+      args:
+        ARE_ROLE: test
+    platform: linux/amd64
+    environment:
+      ARE_ROLE: test
+      ARE_PORT: "8001"
+      ARE_ARTIFACT_PATHS: "/app/output"
+      ARE_GRADE_TIMEOUT_SEC: "1500"
+    expose:
+      - "8001"
+    volumes:
+      - are-secret:/run/are-secret
+    cap_add: [SYS_ADMIN]
+    networks: [are-private]
+    cpus: 8
+    mem_limit: 14336m
+    healthcheck:
+      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8001/health', timeout=2)"]
+      interval: 2s
+      timeout: 5s
+      retries: 60
+      start_period: 5s
+
+volumes:
+  are-deliverable-0: {}
+  are-secret: {}
+
+networks:
+  are-private:
+    internal: true

tasks/sketched-newton-cov-estimator/task.toml

@@ -1,57 +1,71 @@
 schema_version = "1.4"
-artifacts = [ "/app/output",]
+artifacts = [
+    { source = "/var/lib/are", service = "grader" },
+]
 
 [task]
 name = "bespokelabs/sketched-newton-cov-estimator"
-version = "1.0.0"
+version = "1.1.0"
 description = ""
-keywords = [ "autoresearch", "machine-learning", "benchmark",]
-[[task.authors]]
-name = "Bespoke Labs"
+keywords = [
+    "autoresearch",
+    "machine-learning",
+    "benchmark",
+]
+authors = [
+    { name = "Bespoke Labs" },
+]
 
 [metadata]
 category = "Model Training and ML Infrastructure"
 subcategory = "Evaluation infrastructure"
-task_objective = [ "Implement", "Optimize",]
-artifact_type = [ "Single script or program",]
+task_objective = [
+    "Implement",
+    "Optimize",
+]
+artifact_type = [
+    "Single script or program",
+]
 expert_time_estimate_hours = 6.0
+are_version = "1.1"
+budget_seconds = 86400
 
 [verifier]
-timeout_sec = 1500.0
+timeout_sec = 600.0
 environment_mode = "separate"
-collect = []
 
-[verifier.env]
+[[verifier.collect]]
+service = "grader"
+command = "/opt/are/venv/bin/python /opt/are/drain.py"
+timeout_sec = 3600.0
 
 [verifier.environment]
 network_mode = "no-network"
-build_timeout_sec = 3600.0
-os = "linux"
-cpus = 8
-memory_mb = 14336
-storage_mb = 153600
+build_timeout_sec = 600.0
+cpus = 1
+memory_mb = 1024
 gpus = 0
-mcp_servers = []
-
-[verifier.environment.env]
 
 [agent]
 network_mode = "allowlist"
-allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
-timeout_sec = 14400.0
+allowed_hosts = [
+    "api.openai.com",
+    "api.anthropic.com",
+    "grader",
+]
+timeout_sec = 86400.0
 user = "agent"
 
 [environment]
-network_mode = "allowlist"
-allowed_hosts = [ "api.openai.com", "api.anthropic.com",]
+network_mode = "public"
 build_timeout_sec = 3600.0
 os = "linux"
 cpus = 8
 memory_mb = 14336
 storage_mb = 153600
 gpus = 0
-mcp_servers = []
+mcp_servers = [
+    { name = "are", transport = "streamable-http", url = "http://grader:8000/mcp" },
+]
 
 [environment.env]
-
-[solution.env]

tasks/sketched-newton-cov-estimator/tests/Dockerfile

@@ -1,31 +1,2 @@
-FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:3.13-slim-bookworm@sha256:01f42367a0a94ad4bc17111776fd66e3500c1d87c15bbd6055b7371d39c124fb
-
-ENTRYPOINT []
-ENV PYTHONPATH=
-ENV PYTHONSAFEPATH=1
-ENV DEBIAN_FRONTEND=noninteractive \
-    PYTHONHASHSEED=0 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    OMP_NUM_THREADS=1 \
-    OPENBLAS_NUM_THREADS=1 \
-    MKL_NUM_THREADS=1
-
-RUN useradd --create-home --uid 1001 agent
-
-COPY ./requirements.txt /tmp/requirements.txt
-COPY ./requirements-verifier.txt /tmp/requirements-verifier.txt
-RUN /usr/local/bin/python3 -m pip install --no-cache-dir \
-        -r /tmp/requirements.txt -r /tmp/requirements-verifier.txt \
-    && rm /tmp/requirements.txt /tmp/requirements-verifier.txt
-
-RUN mkdir -p /app/output /logs/verifier
-
-COPY . /tests
-
-RUN chown -R root:root /tests \
-    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
-    && chmod +x /tests/test.sh /tests/intermediate.sh \
-    && find /tests -exec touch -d @1700000000 {} +
-
-WORKDIR /tests
+FROM python:3.12-slim
+COPY . /tests/

tasks/sketched-newton-cov-estimator/tests/finalize.py

@@ -0,0 +1,59 @@
+"""Final verifier: score the run from the grader ledger.
+
+reward      hidden test score of the submission with the best validation score
+            (ties go to the earlier submission); 0 if nothing was submitted.
+auarc       area under the curve of that same quantity over the wall-clock budget,
+            using the time each validation score became available, divided by the
+            budget. 0 before the first graded submission.
+"""
+
+import json
+from pathlib import Path
+
+STATE = Path("/var/lib/are")
+OUT = Path("/logs/verifier")
+OUT.mkdir(parents=True, exist_ok=True)
+
+meta = json.loads((STATE / "meta.json").read_text()) if (STATE / "meta.json").exists() else {}
+budget = float(meta.get("budget_seconds") or 1.0)
+
+subs: dict[int, dict] = {}
+ledger = STATE / "ledger.jsonl"
+for line in (ledger.read_text().splitlines() if ledger.exists() else []):
+    ev = json.loads(line)
+    s = subs.setdefault(ev["id"], {"id": ev["id"]})
+    if ev["event"] == "submitted":
+        s["submitted_t"] = ev["t"]
+    elif ev["event"] == "val":
+        s["val"] = ev["score"]
+        s["val_t"] = ev["t"]
+    elif ev["event"] == "test":
+        s["test"] = ev["score"]
+
+graded = sorted((s for s in subs.values() if "val" in s), key=lambda s: s["val_t"])
+
+# Step function of the hidden score of the best-validation pick over time.
+auc, best, last_t, cur = 0.0, None, 0.0, 0.0
+timeline = []
+for s in graded:
+    t = min(s["val_t"], budget)
+    auc += cur * (t - last_t)
+    last_t = t
+    if best is None or s["val"] > best["val"] or (s["val"] == best["val"] and s["id"] < best["id"]):
+        best = s
+        cur = float(best.get("test") or 0.0)
+    timeline.append({"t": s["val_t"], "id": s["id"], "val": s["val"], "test": s.get("test"),
+                     "pick": best["id"]})
+auc += cur * (budget - last_t) if last_t < budget else 0.0
+
+reward = {
+    "reward": float(best.get("test") or 0.0) if best else 0.0,
+    "auarc": auc / budget,
+    "best_val": float(best["val"]) if best else 0.0,
+    "n_submissions": float(len(subs)),
+    "n_test_graded": float(sum(s.get("test") is not None for s in subs.values())),
+}
+(OUT / "reward.json").write_text(json.dumps(reward))
+(OUT / "timeline.json").write_text(json.dumps({"budget": budget, "selected": best and best["id"],
+                                               "submissions": timeline}, indent=1))
+print(json.dumps(reward, indent=1))

tasks/sketched-newton-cov-estimator/tests/test.sh

@@ -1,19 +1,2 @@
 #!/bin/bash
-set -u
-
-mkdir -p /logs/verifier
-chown root:root /logs/verifier 2>/dev/null || true
-chmod 755 /logs/verifier 2>/dev/null || true
-rm -f /logs/verifier/reward.txt /logs/verifier/ctrf.json /logs/verifier/metric.json
-
-printf '0\n' > /logs/verifier/reward.txt
-trap 'if [ ! -s /logs/verifier/reward.txt ]; then printf "0\n" > /logs/verifier/reward.txt; fi' EXIT
-
-chmod -R go-rwx /tests
-
-export GRADE_SPLIT=final
-cd /tests
-/usr/local/bin/python3 -m pytest --ctrf /logs/verifier/ctrf.json /tests/test_state.py -rA
-/usr/local/bin/python3 /tests/compute_reward.py
-
-exit 0
+python3 /tests/finalize.py

tasks/sopcc-online-chance-constrained-policy/environment/.dockerignore

@@ -0,0 +1 @@
+are-grader-ctx

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/Dockerfile

@@ -0,0 +1,34 @@
+FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:3.13-slim-bookworm@sha256:01f42367a0a94ad4bc17111776fd66e3500c1d87c15bbd6055b7371d39c124fb
+
+ENTRYPOINT []
+ENV PYTHONPATH=
+ENV PYTHONSAFEPATH=1
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONHASHSEED=0 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    OMP_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1 \
+    OPENBLAS_NUM_THREADS=1
+
+RUN useradd --create-home --uid 1001 agent
+
+COPY ./requirements.txt /tmp/requirements.txt
+COPY ./requirements-verifier.txt /tmp/requirements-verifier.txt
+RUN /usr/local/bin/python3 -m pip install --no-cache-dir \
+        -r /tmp/requirements.txt -r /tmp/requirements-verifier.txt \
+    && rm /tmp/requirements.txt /tmp/requirements-verifier.txt
+
+RUN mkdir -p /app/solution /logs/verifier
+
+COPY . /tests
+
+RUN chown -R root:root /tests \
+    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
+    && chmod +x /tests/test.sh /tests/intermediate.sh \
+    && find /tests -exec touch -d @1700000000 {} +
+
+WORKDIR /tests
+
+ENV HF_HUB_OFFLINE=1
+ENV TRANSFORMERS_OFFLINE=1

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/Dockerfile.are

@@ -0,0 +1,52 @@
+FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:3.13-slim-bookworm@sha256:01f42367a0a94ad4bc17111776fd66e3500c1d87c15bbd6055b7371d39c124fb
+
+ENTRYPOINT []
+ENV PYTHONPATH=
+ENV PYTHONSAFEPATH=1
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONHASHSEED=0 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    OMP_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1 \
+    OPENBLAS_NUM_THREADS=1
+
+RUN useradd --create-home --uid 1001 agent
+
+COPY ./requirements.txt /tmp/requirements.txt
+COPY ./requirements-verifier.txt /tmp/requirements-verifier.txt
+RUN /usr/local/bin/python3 -m pip install --no-cache-dir \
+        -r /tmp/requirements.txt -r /tmp/requirements-verifier.txt \
+    && rm /tmp/requirements.txt /tmp/requirements-verifier.txt
+
+RUN mkdir -p /app/solution /logs/verifier
+
+COPY . /tests
+
+RUN chown -R root:root /tests \
+    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
+    && chmod +x /tests/test.sh /tests/intermediate.sh \
+    && find /tests -exec touch -d @1700000000 {} +
+
+WORKDIR /tests
+
+ENV HF_HUB_OFFLINE=1
+ENV TRANSFORMERS_OFFLINE=1
+
+
+# ---- ARE 1.1 grader layer (appended to the task's own verifier Dockerfile) ----
+ARG ARE_ROLE
+# python.org images ship /usr/local/bin/python3; distro-python bases (kaggle GPU) lack
+# ensurepip, so fall back to a pip-less venv filled by the base interpreter's pip.
+RUN PY=$(command -v /usr/local/bin/python3 || command -v python3) \
+    && if "$PY" -m venv /opt/are/venv; then \
+         /opt/are/venv/bin/pip install --no-cache-dir "fastmcp==2.14.7"; \
+       else rm -rf /opt/are/venv && "$PY" -m venv --without-pip /opt/are/venv \
+         && "$PY" -m pip --python /opt/are/venv/bin/python install --no-cache-dir "fastmcp==2.14.7"; fi
+COPY are/ /opt/are/
+# The val grader, whose output reaches the agent, never holds the private grader or its
+# data. The test grader keeps everything; nothing from it reaches the agent.
+RUN rm -rf /tests/are /tests/Dockerfile.are \
+    && if [ "$ARE_ROLE" = "val" ]; then rm -rf /tests/test.sh /tests/hidden_data/final; fi
+ENV ARE_ROLE=$ARE_ROLE
+CMD ["/opt/are/venv/bin/python", "/opt/are/server.py"]

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/are/drain.py

@@ -0,0 +1,25 @@
+"""Verifier collect hook, run after the agent stops.
+
+Grades the final workspace as one last submission (unless it equals the last one),
+then waits until every submission has both grades recorded.
+"""
+
+import json
+import time
+import urllib.request
+from pathlib import Path
+
+TOKEN = Path("/run/are-secret/token").read_text().strip()
+H = {"x-are-token": TOKEN}
+
+req = urllib.request.Request("http://localhost:8000/final", method="POST", headers=H)
+with urllib.request.urlopen(req, timeout=120) as resp:
+    print("final:", json.loads(resp.read()), flush=True)
+
+while True:
+    with urllib.request.urlopen(urllib.request.Request("http://localhost:8000/drain", headers=H), timeout=30) as resp:
+        state = json.loads(resp.read())
+    print(state, flush=True)
+    if state["val_pending"] == 0 and state["test_pending"] == 0:
+        break
+    time.sleep(5)

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/are/server.py

@@ -0,0 +1,538 @@
+"""ARE 1.1 grader sidecar.
+
+One image, two roles:
+
+- ARE_ROLE=val  ("grader" service). Reachable from the agent. Serves MCP tools and a
+  REST fallback. On submit it snapshots the shared deliverable volume, grades the
+  snapshot with the task's public grader (intermediate.sh), and returns only that
+  score. Every snapshot is also sent to the test grader; the hidden score goes to a
+  root-only ledger and never back to the agent.
+- ARE_ROLE=test ("test-grader" service). On a private network that only the val
+  grader can reach. Grades snapshots with the task's private grader (test.sh).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import gzip
+import hashlib
+import io
+import secrets
+import json
+import os
+import queue
+import shutil
+import subprocess
+import tarfile
+import threading
+import time
+import urllib.request
+from pathlib import Path
+
+from fastmcp import FastMCP
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+ROLE = os.environ.get("ARE_ROLE", "val")
+PORT = int(os.environ.get("ARE_PORT", "8000"))
+STATE = Path(os.environ.get("ARE_STATE_DIR", "/var/lib/are"))
+ARTIFACT_PATHS = [p for p in os.environ.get("ARE_ARTIFACT_PATHS", "/app/output").split(":") if p]
+# The shared deliverable volume. Its parent is root-only, so submitted code (which every
+# task grader runs as the unprivileged agent user) cannot reach it to write back to the agent.
+SUBMISSION_ROOT = Path(os.environ.get("ARE_SUBMISSION_ROOT", "/run/are-deliverable"))
+AGENT_UID = int(os.environ.get("ARE_AGENT_UID", "1001"))
+BUDGET_SEC = float(os.environ.get("ARE_BUDGET_SEC", "14400"))
+GRADE_TIMEOUT_SEC = float(os.environ.get("ARE_GRADE_TIMEOUT_SEC", "1800"))
+TEST_GRADER_URL = os.environ.get("ARE_TEST_GRADER_URL", "http://test-grader:8001")
+FEEDBACK_TAIL = int(os.environ.get("ARE_FEEDBACK_TAIL_CHARS", "8192"))
+SCRIPT = "/tests/intermediate.sh" if ROLE == "val" else "/tests/test.sh"
+# Shared only by the two graders (a volume the agent's container never mounts). The test
+# grader writes a fresh token at startup; every internal request must carry it, so the
+# agent cannot reach the test grader or the internal endpoints even on a shared network.
+TOKEN_FILE = Path(os.environ.get("ARE_TOKEN_FILE", "/run/are-secret/token"))
+TOKEN = ""
+
+
+def _authorized(request: Request) -> bool:
+    """Internal endpoints need the graders' token; an unset token never matches."""
+    return bool(TOKEN) and secrets.compare_digest(request.headers.get("x-are-token", ""), TOKEN)
+
+
+def _net_isolation_available() -> bool:
+    try:
+        return subprocess.run(["unshare", "-n", "true"], capture_output=True, timeout=10).returncode == 0
+    except Exception:
+        return False
+
+
+NET_ISOLATED = False  # set at startup: grader scripts run in an empty network namespace
+
+T0 = time.time()
+_lock = threading.Lock()
+
+
+def _elapsed() -> float:
+    return round(time.time() - T0, 1)
+
+
+def _ledger(event: dict) -> None:
+    event = {"t": _elapsed(), "wall": time.time(), **event}
+    for attempt in range(3):
+        try:
+            with _lock, open(STATE / "ledger.jsonl", "a") as fh:
+                fh.write(json.dumps(event) + "\n")
+            return
+        except OSError:
+            if attempt == 2:
+                raise
+            time.sleep(1)
+
+
+def _kill_grading_processes(proc: subprocess.Popen) -> None:
+    """Kill everything a timed-out grade started, including processes that left its group."""
+    try:
+        os.killpg(proc.pid, 9)
+    except ProcessLookupError:
+        pass
+    _kill_other_processes()
+
+
+def _kill_other_processes() -> None:
+    """Kill every process run by the agent user. Every task grader runs submitted code as
+    that user, so this stops all graded code (detached or not) and nothing else: the grader
+    server, the task's own grader and Harbor's hooks run as root."""
+    for entry in Path("/proc").iterdir():
+        if not entry.name.isdigit():
+            continue
+        try:
+            if entry.stat().st_uid == AGENT_UID:
+                os.kill(int(entry.name), 9)
+        except (ProcessLookupError, PermissionError, FileNotFoundError):
+            pass
+
+
+# Places the agent user (who runs submitted code inside every task grader) can write.
+_BASELINE: set[str] = set()  # every path that existed when the grader started (its image)
+
+
+def _walk_one_fs(base: Path):
+    """Every path under base on base's own filesystem (skips /proc, /sys and other mounts)."""
+    dev = base.stat().st_dev
+    for root, dirs, files in os.walk(base):
+        dirs[:] = [d for d in dirs if os.lstat(os.path.join(root, d)).st_dev == dev]
+        for name in dirs + files:
+            yield Path(root) / name
+
+
+def _all_paths() -> set[str]:
+    out = set()
+    for base in (Path("/"), Path("/dev/shm")):
+        if base.is_dir():
+            out.update(str(q) for q in _walk_one_fs(base))
+    return out
+
+
+def _protected(path: str) -> bool:
+    keep = [str(STATE), "/opt/are", str(TOKEN_FILE.parent)]
+    return any(path == k or path.startswith(k + "/") for k in keep)
+
+
+def _fresh_state() -> None:
+    """Start every grade from the grader image's own files, as ARE 1.0's fresh verifier
+    container did. The grader container lives for the whole run, so before each grade
+    stop anything an earlier grade left running and delete every file it created,
+    whoever wrote it. The deliverable volume and the token are separate mounts and are
+    never walked; the grader's own state is kept."""
+    _kill_other_processes()
+    # System V shared memory, semaphores and queues outlive processes; this server uses none.
+    subprocess.run(["ipcrm", "--all"], capture_output=True)
+    for path in sorted(_all_paths() - _BASELINE, key=lambda q: q.count("/"), reverse=True):
+        if _protected(path):
+            continue
+        try:
+            q = Path(path)
+            if q.is_dir() and not q.is_symlink():
+                shutil.rmtree(q, ignore_errors=True)
+            else:
+                q.unlink()
+        except OSError:
+            pass
+
+
+def grade_snapshot(tar_bytes: bytes, tag: str) -> dict:
+    """Extract a snapshot over the artifact paths and run this role's grader script."""
+    _fresh_state()
+    for path in ARTIFACT_PATHS:
+        p = Path(path)
+        if p.exists():
+            shutil.rmtree(p)
+        p.mkdir(parents=True)
+    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:gz") as tf:
+        tf.extractall("/", filter="tar")
+    logs = Path("/logs/verifier")
+    if logs.exists():
+        shutil.rmtree(logs)
+    logs.mkdir(parents=True)
+    started = time.time()
+    # Submitted code runs with no network, as in ARE 1.0's verifier.
+    cmd = (["unshare", "-n"] if NET_ISOLATED else []) + ["bash", SCRIPT]
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+                            cwd="/tests", start_new_session=True)
+    try:
+        out, err = proc.communicate(timeout=GRADE_TIMEOUT_SEC)
+        error = None
+    except subprocess.TimeoutExpired:
+        _kill_grading_processes(proc)
+        out, err = proc.communicate()
+        error = f"grader timed out after {GRADE_TIMEOUT_SEC:.0f}s"
+    output = (out or "") + (err or "")
+    # Nothing a grade started may keep running after it, not even detached processes.
+    _kill_other_processes()
+    score = 0.0
+    reward_file = logs / "reward.txt"
+    if reward_file.exists():
+        try:
+            score = float(reward_file.read_text().strip() or 0)
+        except ValueError:
+            error = error or "unparseable reward"
+    metric = None
+    if (logs / "metric.json").exists():
+        try:
+            metric = json.loads((logs / "metric.json").read_text())
+        except ValueError:
+            pass
+    (STATE / "logs").mkdir(exist_ok=True)
+    (STATE / "logs" / f"{tag}.log").write_text(output)
+    return {
+        "score": score,
+        "metric": metric,
+        "error": error,
+        "net_isolated": NET_ISOLATED,
+        "seconds": round(time.time() - started, 1),
+        # What the agent sees, as in ARE 1.0: the grader's stdout tail (not stderr).
+        "output_tail": (out or "")[-FEEDBACK_TAIL:],
+    }
+
+
+mcp = FastMCP("are")
+
+
+# ---------------------------------------------------------------- test role
+
+
+_grade_lock = threading.Lock()
+
+
+def _grade_one_at_a_time(tar_bytes: bytes, tag: str) -> dict:
+    # A request that timed out on the caller's side may still be grading; the next one
+    # waits for it rather than sharing /app/output and /logs/verifier with it.
+    with _grade_lock:
+        return grade_snapshot(tar_bytes, tag)
+
+
+if ROLE == "test":
+
+    @mcp.custom_route("/grade", methods=["POST"])
+    async def http_grade(request: Request) -> Response:
+        if not _authorized(request):
+            return JSONResponse({"error": "forbidden"}, status_code=403)
+        tag = request.query_params.get("tag", "x")
+        body = await request.body()
+        result = await asyncio.to_thread(_grade_one_at_a_time, body, f"{tag}-test")
+        return JSONResponse(result)
+
+
+# ----------------------------------------------------------------- val role
+
+
+class Board:
+    """Submissions and their grading state. Hidden scores are never stored here."""
+
+    def __init__(self) -> None:
+        self.subs: dict[int, dict] = {}
+        self.val_q: queue.Queue[int] = queue.Queue()
+        self.next_id = 1
+        self.test_pending = 0
+        self.last_digest: str | None = None
+
+    def public(self, sid: int) -> dict:
+        s = self.subs[sid]
+        out = {k: s[k] for k in ("id", "note", "submitted_at_s", "status")}
+        if s["status"] == "graded":
+            v = s["val"]
+            out.update(
+                validation_score=v["score"],
+                error=v["error"],
+                grading_seconds=v["seconds"],
+                grader_output_tail=v["output_tail"],
+            )
+        return out
+
+    def best(self) -> dict | None:
+        graded = [s for s in self.subs.values() if s["status"] == "graded"]
+        if not graded:
+            return None
+        b = max(graded, key=lambda s: (s["val"]["score"], -s["id"]))
+        return {"id": b["id"], "validation_score": b["val"]["score"]}
+
+
+board = Board()
+
+
+def snapshot() -> bytes:
+    """Deterministic tar.gz of the deliverable: same content, same bytes (gzip mtime 0)."""
+    raw = io.BytesIO()
+    with tarfile.open(fileobj=raw, mode="w") as tf:
+        for path in ARTIFACT_PATHS:
+            src = SUBMISSION_ROOT / path.lstrip("/")
+            tf.add(str(src), arcname=path.lstrip("/"))
+    out = io.BytesIO()
+    with gzip.GzipFile(fileobj=out, mode="wb", mtime=0) as gz:
+        gz.write(raw.getvalue())
+    return out.getvalue()
+
+
+def do_submit(note: str, final: bool = False) -> dict:
+    with _lock:
+        pending = [s["id"] for s in board.subs.values() if s["status"] != "graded"]
+        if pending and not final:
+            return {
+                "error": f"Submission {pending[0]} is still being graded. One submission is "
+                         f"graded at a time: check result({pending[0]}) and submit again "
+                         "once it has its score.",
+                "pending_id": pending[0],
+            }
+        sid = board.next_id
+        board.next_id += 1
+        board.subs[sid] = {"id": sid, "note": note[:500], "submitted_at_s": _elapsed(),
+                           "status": "queued"}
+    try:
+        data = snapshot()
+        digest = hashlib.sha256(data).hexdigest()
+        (STATE / "snapshots" / f"{sid:04d}.tar.gz").write_bytes(data)
+        _ledger({"event": "submitted", "id": sid, "note": note[:500], "bytes": len(data),
+                 "sha256": digest, "final": final})
+    except Exception as exc:
+        with _lock:
+            board.subs.pop(sid, None)  # release the slot; the id is not reused
+        return {"error": f"Could not snapshot the deliverable ({exc}). Nothing was submitted. "
+                         "Make sure nothing is writing to it, then submit again."}
+    board.last_digest = digest
+    with _lock:
+        board.test_pending += 1
+    board.val_q.put(sid)
+    return {"id": sid, "status": "queued",
+            "hint": "Grading has started. Check result(id) for the validation score."}
+
+
+def final_submit() -> dict:
+    """After the agent stops: grade the final workspace unless it was already submitted."""
+    try:
+        data = snapshot()
+    except Exception as exc:
+        return {"error": f"final snapshot failed: {exc}"}
+    if board.subs and hashlib.sha256(data).hexdigest() == board.last_digest:
+        return {"skipped": "final workspace equals the last submission"}
+    return do_submit("final workspace (automatic)", final=True)
+
+
+def grade_worker() -> None:
+    """Grade each submission on val, then on test, one submission at a time.
+
+    The val score is published as soon as it is ready. The next submission's val grade
+    waits until this test grade is done, so the two graders never run at the same time.
+    """
+    while True:
+        sid = board.val_q.get()
+        board.subs[sid]["status"] = "grading"
+        data = b""
+        try:
+            data = (STATE / "snapshots" / f"{sid:04d}.tar.gz").read_bytes()
+            res = grade_snapshot(data, f"{sid:04d}-val")
+        except Exception as exc:
+            res = {"score": 0.0, "metric": None, "error": f"grader failed: {exc}",
+                   "net_isolated": NET_ISOLATED, "seconds": 0.0, "output_tail": ""}
+        board.subs[sid]["val"] = res
+        board.subs[sid]["status"] = "graded"
+        try:
+            _ledger({"event": "val", "id": sid, **{k: res[k] for k in ("score", "metric", "error", "seconds", "net_isolated")}})
+        except OSError as exc:  # keep grading later submissions
+            print(f"ARE grader: ledger write failed for {sid}: {exc}", flush=True)
+        test_grade(sid, data)
+
+
+def test_grade(sid: int, data: bytes) -> None:
+    try:
+        _test_grade(sid, data)
+    finally:
+        with _lock:
+            board.test_pending -= 1
+
+
+def _test_grade(sid: int, data: bytes) -> None:
+    """Send one snapshot to the test grader. A failed request is retried (the same snapshot
+    is graded again, so a retry can only recover the honest score); a request that ran
+    past its timeout is not, since the grade itself already took the full time."""
+    started = time.time()
+    for attempt in range(3):
+        try:
+            req = urllib.request.Request(
+                f"{TEST_GRADER_URL}/grade?tag={sid:04d}", data=data, method="POST",
+                headers={"x-are-token": TOKEN},
+            )
+            with urllib.request.urlopen(req, timeout=2 * GRADE_TIMEOUT_SEC + 300) as resp:
+                res = json.loads(resp.read())
+            break
+        except Exception as exc:  # recorded, never shown to the agent
+            res = {"score": None, "metric": None, "error": f"test grader: {exc}",
+                   "seconds": round(time.time() - started, 1)}
+            if attempt == 2 or isinstance(exc, TimeoutError) or isinstance(getattr(exc, "reason", None), TimeoutError):
+                break
+            time.sleep(5)
+    try:
+        _ledger({"event": "test", "id": sid, **{k: res.get(k) for k in ("score", "metric", "error", "seconds", "net_isolated")}})
+    except OSError as exc:  # keep grading later submissions
+        print(f"ARE grader: ledger write failed for {sid}: {exc}", flush=True)
+
+
+def with_time(out: dict) -> dict:
+    """Wall-clock accounting on every reply, as the v1 harness gave each phase."""
+    out["total_budget_seconds"] = BUDGET_SEC
+    out["time_remaining_seconds"] = round(max(0.0, BUDGET_SEC - _elapsed()), 1)
+    return out
+
+
+def status_dict() -> dict:
+    return {
+        "submissions": len(board.subs),
+        "queued_or_grading": sum(s["status"] != "graded" for s in board.subs.values()),
+        "best": board.best(),
+    }
+
+
+def current_result(sid: int) -> dict:
+    return board.public(sid)
+
+
+if ROLE == "val":
+
+    @mcp.tool
+    async def submit(note: str = "") -> dict:
+        """Submit the current deliverable for grading.
+
+        Snapshots the deliverable directory right now (later edits do not affect this
+        submission) and starts grading it on the public validation split. Returns at
+        once with a submission id. One submission is graded at a time: check `result`
+        and submit again once the previous submission has its score. `note` is a short
+        description of what changed.
+        """
+        return with_time(await asyncio.to_thread(do_submit, note))
+
+    @mcp.tool
+    async def result(id: int) -> dict:
+        """The current state of a submission: queued, grading, or graded with its
+        validation score and grader output. Returns immediately."""
+        if id not in board.subs:
+            return {"error": f"unknown submission id {id}"}
+        return with_time(current_result(id))
+
+    @mcp.tool
+    async def status() -> dict:
+        """Submission count, whether one is being graded, the best validation score,
+        and the time budget and time remaining."""
+        return with_time(status_dict())
+
+    @mcp.custom_route("/submit", methods=["POST"])
+    async def http_submit(request: Request) -> Response:
+        note = request.query_params.get("note", "")
+        return JSONResponse(with_time(await asyncio.to_thread(do_submit, note)))
+
+    @mcp.custom_route("/result/{sid}", methods=["GET"])
+    async def http_result(request: Request) -> Response:
+        sid = int(request.path_params["sid"])
+        if sid not in board.subs:
+            return JSONResponse({"error": f"unknown submission id {sid}"}, status_code=404)
+        return JSONResponse(with_time(current_result(sid)))
+
+    @mcp.custom_route("/status", methods=["GET"])
+    async def http_status(request: Request) -> Response:
+        return JSONResponse(with_time(status_dict()))
+
+    @mcp.custom_route("/final", methods=["POST"])
+    async def http_final(request: Request) -> Response:
+        if not _authorized(request):
+            return JSONResponse({"error": "forbidden"}, status_code=403)
+        # Collect hook, after the agent has stopped.
+        return JSONResponse(await asyncio.to_thread(final_submit))
+
+    @mcp.custom_route("/drain", methods=["GET"])
+    async def http_drain(request: Request) -> Response:
+        if not _authorized(request):
+            return JSONResponse({"error": "forbidden"}, status_code=403)
+        # Used by the verifier collect hook after the agent has stopped.
+        pending = sum(s["status"] != "graded" for s in board.subs.values())
+        return JSONResponse({"val_pending": pending, "test_pending": board.test_pending})
+
+
+def _gpus() -> list[str]:
+    try:
+        out = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True, timeout=20)
+        return [l for l in out.stdout.splitlines() if l.strip()]
+    except Exception:
+        return []
+
+
+@mcp.custom_route("/health", methods=["GET"])
+async def health(request: Request) -> Response:
+    return JSONResponse({"ok": True, "role": ROLE, "gpus": await asyncio.to_thread(_gpus)})
+
+
+def _setup_token() -> None:
+    global TOKEN
+    if ROLE == "test":
+        TOKEN_FILE.parent.mkdir(parents=True, exist_ok=True)
+        os.chmod(TOKEN_FILE.parent, 0o700)
+        TOKEN = secrets.token_hex(32)
+        TOKEN_FILE.write_text(TOKEN)
+        os.chmod(TOKEN_FILE, 0o600)
+    else:
+        for _ in range(300):  # the test grader is healthy before this one starts
+            if TOKEN_FILE.exists() and TOKEN_FILE.read_text().strip():
+                break
+            time.sleep(1)
+        TOKEN = TOKEN_FILE.read_text().strip()
+    if not TOKEN:
+        raise SystemExit("ARE: empty internal token; refusing to start")
+
+
+def main() -> None:
+    global NET_ISOLATED
+    NET_ISOLATED = _net_isolation_available()
+    if not NET_ISOLATED:
+        # Graded code must never have a network path (for example back through /submit).
+        raise SystemExit("ARE grader: cannot run grades without network access "
+                         "(needs `unshare -n`, i.e. CAP_SYS_ADMIN); refusing to start")
+    STATE.mkdir(parents=True, exist_ok=True)
+    _BASELINE.update(_all_paths())
+    _setup_token()
+    STATE.mkdir(parents=True, exist_ok=True)
+    os.chmod(STATE, 0o700)
+    (STATE / "snapshots").mkdir(exist_ok=True)
+    if ROLE == "val":
+        # The deliverable volume starts empty and root-owned; hand it to the agent user.
+        SUBMISSION_ROOT.mkdir(parents=True, exist_ok=True)
+        os.chmod(SUBMISSION_ROOT, 0o700)
+        for path in ARTIFACT_PATHS:
+            src = SUBMISSION_ROOT / path.lstrip("/")
+            src.mkdir(parents=True, exist_ok=True)
+            os.chown(src, AGENT_UID, AGENT_UID)
+        (STATE / "meta.json").write_text(json.dumps(
+            {"t0_wall": T0, "budget_seconds": BUDGET_SEC, "artifact_paths": ARTIFACT_PATHS}
+        ))
+        threading.Thread(target=grade_worker, daemon=True).start()
+    mcp.run(transport="http", host="0.0.0.0", port=PORT, show_banner=False,
+            uvicorn_config={"timeout_keep_alive": 86400})
+
+
+if __name__ == "__main__":
+    main()

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/compute_reward.py

@@ -0,0 +1,18 @@
+import json
+import math
+from pathlib import Path
+
+REWARD_PATH = Path("/logs/verifier/reward.txt")
+
+try:
+    value = float(json.loads(Path("/logs/verifier/metric.json").read_text())["reward"])
+    if not math.isfinite(value):
+        raise ValueError("non-finite reward")
+    reward = f"{min(1.0, max(0.0, value)):.12g}"
+    REWARD_PATH.parent.mkdir(parents=True, exist_ok=True)
+    REWARD_PATH.write_text(reward + "\n")
+    print(f"reward={reward}")
+except Exception as exc:
+    REWARD_PATH.parent.mkdir(parents=True, exist_ok=True)
+    REWARD_PATH.write_text("0\n")
+    print(f"reward=0 (fallback: {exc})")

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/grader_core.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import sopcc
+
+HIDDEN = Path(__file__).resolve().parent / "hidden_data"
+SPLITS = ("final", "intermediate")
+
+ANCHORS = {
+
+    "final": (4.212162974044415, 5.403678393388951),
+    "intermediate": (4.90108511497506, 5.935456731233547),
+}
+
+
+def load_panel(split: str):
+    """The sealed panel for `split`: instances plus their pre-drawn cost noise."""
+    if split not in SPLITS:
+        raise ValueError(f"unknown split {split!r}")
+    with np.load(HIDDEN / split / "panel.npz") as data:
+        coords, rewards, noise, draw = (data["coords"], data["rewards"],
+                                        data["noise"], data["draw"])
+    return [
+        {"draw": int(draw[i]), "index": i,
+         "instance": sopcc.instance_from_arrays(coords[i], rewards[i]),
+         "noise": noise[i]}
+        for i in range(coords.shape[0])
+    ]
+
+
+def graded_reward(metric: float, split: str) -> float:
+    """Map the raw metric to a reward in [0, 1): 0 at m0, 0.5 at m_ref, no cutoff above."""
+    m0, m_ref = ANCHORS[split]
+    x_ref = m_ref - m0
+    if not x_ref > 0:
+        raise AssertionError("malformed task: the reference does not beat the trivial baseline")
+    if not np.isfinite(metric):
+        return 0.0
+    u = max(0.0, float(metric) - m0) / x_ref
+    return u / (1.0 + u)

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/hidden_data/final/panel.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b034f0a99b9a9f72228a791c6216acbf68dc22dc33fc3f6d4ededd34f0330a7f
+size 605757

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/hidden_data/intermediate/panel.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c457412f004826b4404e915b5b81e17400cef99f395d5bb76241ea770f2aaeb4
+size 605708

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/intermediate.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+
+set -u
+
+
+
+reward_floor() {
+    if [ ! -s /logs/verifier/reward.txt ]; then
+        mkdir -p /logs/verifier
+        printf '0\n' > /logs/verifier/reward.txt
+    fi
+}
+trap reward_floor EXIT
+
+mkdir -p /logs/verifier
+chown root:root /logs/verifier 2>/dev/null || true
+chmod 755 /logs/verifier 2>/dev/null || true
+rm -f /logs/verifier/reward.txt /logs/verifier/ctrf.json /logs/verifier/metric.json
+
+chmod -R go-rwx /tests
+
+cd /tests
+export GRADE_SPLIT=intermediate
+/usr/local/bin/python3 -m pytest \
+    --ctrf /logs/verifier/ctrf.json /tests/test_state.py -rA
+/usr/local/bin/python3 /tests/compute_reward.py
+
+exit 0

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/policy_worker.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import resource
+import sys
+import traceback
+
+
+def _fail(reply, stage, exc):
+    reply({"ok": False, "stage": stage, "error": f"{type(exc).__name__}: {exc}",
+           "traceback": traceback.format_exc(limit=6)[-1200:]})
+
+
+def _apply_limits(limits: dict) -> None:
+    """Cap this process before any candidate code is imported.
+
+    Set here rather than by the caller so there is no window between exec and the cap, and
+    the hard limit is set too: candidate code can lower these but never raise them.
+    """
+    cpu = int(limits["cpu_seconds"])
+    resource.setrlimit(resource.RLIMIT_CPU, (cpu + 1, cpu + 3))
+    for name, key in (("RLIMIT_AS", "address_space_bytes"),
+                      ("RLIMIT_FSIZE", "file_size_bytes"),
+                      ("RLIMIT_NOFILE", "open_files")):
+        value = int(limits[key])
+        soft, hard = resource.getrlimit(getattr(resource, name))
+        if hard != resource.RLIM_INFINITY:
+            value = min(value, hard)
+        resource.setrlimit(getattr(resource, name), (value, value))
+    resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
+
+
+def main() -> int:
+    solution_dir = os.path.abspath(sys.argv[1])
+    entry = os.path.join(solution_dir, "policy.py")
+    _apply_limits(json.loads(sys.argv[2]))
+
+    reply_fd = os.dup(1)
+    os.dup2(2, 1)
+    sys.stdout = sys.stderr
+    channel = os.fdopen(reply_fd, "w", buffering=1)
+
+    def reply(obj):
+        channel.write(json.dumps(obj) + "\n")
+        channel.flush()
+
+    import numpy as np
+    try:
+        import torch
+        torch.set_num_threads(1)
+    except ImportError:
+        pass
+
+    policy = None
+    for raw in sys.stdin:
+        raw = raw.strip()
+        if not raw:
+            continue
+        msg = json.loads(raw)
+        cmd = msg.get("cmd")
+
+        if cmd == "init":
+            if not os.path.isfile(entry):
+                reply({"ok": False, "stage": "import", "error": f"no entry point at {entry}"})
+                return 0
+            try:
+                if solution_dir not in sys.path:
+                    sys.path.insert(0, solution_dir)
+                spec = importlib.util.spec_from_file_location("candidate_policy", entry)
+                module = importlib.util.module_from_spec(spec)
+                sys.modules["candidate_policy"] = module
+                spec.loader.exec_module(module)
+                policy_cls = getattr(module, "Policy")
+            except Exception as exc:
+                _fail(reply, "import", exc)
+                return 0
+            try:
+                policy = policy_cls(int(msg["seed"]))
+            except Exception as exc:
+                _fail(reply, "construct", exc)
+                return 0
+            try:
+                instance = {
+                    "coords": np.asarray(msg["instance"]["coords"], dtype=np.float64),
+                    "rewards": np.asarray(msg["instance"]["rewards"], dtype=np.float64),
+                    "dist": np.asarray(msg["instance"]["dist"], dtype=np.float64),
+                    "start": int(msg["instance"]["start"]),
+                    "goal": int(msg["instance"]["goal"]),
+                    "budget": float(msg["instance"]["budget"]),
+                    "p_fail": float(msg["instance"]["p_fail"]),
+                    "cost_model": str(msg["instance"]["cost_model"]),
+                }
+                policy.prepare(instance)
+            except Exception as exc:
+                _fail(reply, "prepare", exc)
+                return 0
+            reply({"ok": True})
+
+        elif cmd == "act":
+            obs = msg["obs"]
+            obs = {
+                "current": int(obs["current"]),
+                "visited": np.asarray(obs["visited"], dtype=bool),
+                "remaining_budget": float(obs["remaining_budget"]),
+                "collected_reward": float(obs["collected_reward"]),
+                "step": int(obs["step"]),
+            }
+            try:
+                action = policy.act(obs)
+            except Exception as exc:
+                reply({"ok": False, "stage": "act",
+                       "error": f"{type(exc).__name__}: {exc}"})
+                continue
+            if isinstance(action, bool) or not isinstance(action, (int, np.integer)):
+                reply({"ok": True, "action": None,
+                       "kind": type(action).__name__})
+            else:
+                reply({"ok": True, "action": int(action)})
+
+        elif cmd == "bye":
+            return 0
+
+        else:
+            reply({"ok": False, "stage": "protocol", "error": f"unknown command {cmd!r}"})
+            return 0
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/requirements-verifier.txt

@@ -0,0 +1,2 @@
+pytest==8.3.5
+pytest-json-ctrf==0.3.5

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/requirements.txt

@@ -0,0 +1,5 @@
+--index-url https://download.pytorch.org/whl/cpu
+--extra-index-url https://pypi.org/simple
+numpy==2.5.2
+scipy==1.18.0
+torch==2.13.0+cpu

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/runner.py

@@ -0,0 +1,517 @@
+from __future__ import annotations
+
+import ctypes
+import json
+import os
+import resource
+import select
+import shutil
+import signal
+import stat
+import sys
+import tempfile
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+
+import numpy as np
+
+
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import sopcc
+
+CLOCK_TICKS = os.sysconf("SC_CLK_TCK")
+CPU_POLL_INTERVAL = 2.0
+PR_SET_CHILD_SUBREAPER = 36
+
+_LOCK = threading.Lock()
+_WORKERS: set[int] = set()
+_ESCAPED_CPU = 0.0
+
+
+@dataclass
+class Sandbox:
+    """Resource and privilege policy applied to every candidate process."""
+
+    cpu_seconds: float = 75.0
+    timeout: float = 150.0
+    address_space_bytes: int = 6 * 1024 ** 3
+    file_size_bytes: int = 64 * 1024 ** 2
+    open_files: int = 256
+    run_as_uid: int | None = None
+    run_as_gid: int | None = None
+    new_session: bool = True
+    env: dict = field(default_factory=dict)
+
+
+class WorkerGone(Exception):
+    """The candidate process died, hung, or stopped speaking the protocol."""
+
+
+class _LineChannel:
+    """Deadline-bounded line reads straight off a pipe fd."""
+
+    def __init__(self, fd: int):
+        self.fd = fd
+        self.buf = b""
+
+    def readline(self, deadline: float) -> bytes:
+        while b"\n" not in self.buf:
+            left = deadline - time.monotonic()
+            if left <= 0:
+                raise WorkerGone("wall-clock budget exhausted")
+            ready, _, _ = select.select([self.fd], [], [], min(left, 0.5))
+            if not ready:
+                continue
+            chunk = os.read(self.fd, 1 << 16)
+            if not chunk:
+                raise WorkerGone("candidate process closed the channel")
+            self.buf += chunk
+        line, _, self.buf = self.buf.partition(b"\n")
+        return line
+
+
+def _write_line(fd: int, payload: bytes, deadline: float) -> None:
+    view = memoryview(payload + b"\n")
+    while view:
+        left = deadline - time.monotonic()
+        if left <= 0:
+            raise WorkerGone("wall-clock budget exhausted")
+        _, ready, _ = select.select([], [fd], [], min(left, 0.5))
+        if not ready:
+            continue
+        try:
+            written = os.write(fd, view)
+        except (BrokenPipeError, OSError) as exc:
+            raise WorkerGone(f"candidate process is not reading: {exc}") from exc
+        view = view[written:]
+
+
+def _become_subreaper() -> None:
+    """Adopt orphaned descendants of every candidate instead of leaving them to init.
+
+    A candidate that forks and lets the parent exit would otherwise hand the orphan to pid 1,
+    outside any tree walked below. With this set, such an orphan is re-parented to this process,
+    where `_tree` recognises it (a child of ours that is not a worker we started) and it is
+    charged, killed and reaped along with the candidate's own tree.
+    """
+    try:
+        ctypes.CDLL(None, use_errno=True).prctl(PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0)
+    except (OSError, AttributeError):
+        pass
+
+
+def _scan() -> dict[int, tuple[int, float]]:
+    """pid -> (ppid, CPU seconds) for every live process.
+
+    The CPU figure is utime + stime + cutime + cstime: the process's own threads plus every
+    child it has already reaped, so a helper that burns CPU and exits between two scans is
+    still charged to whoever reaped it.
+    """
+    procs: dict[int, tuple[int, float]] = {}
+    try:
+        names = os.listdir("/proc")
+    except OSError:
+        return procs
+    for name in names:
+        if not name.isdigit():
+            continue
+        try:
+            with open(f"/proc/{name}/stat", "rb") as fh:
+                raw = fh.read()
+        except OSError:
+            continue
+        cut = raw.rfind(b")")
+        if cut < 0:
+            continue
+        fields = raw[cut + 2:].split()
+        if len(fields) < 15:
+            continue
+        try:
+            procs[int(name)] = (int(fields[1]),
+                                sum(int(f) for f in fields[11:15]) / CLOCK_TICKS)
+        except ValueError:
+            continue
+    return procs
+
+
+def _tree(procs: dict[int, tuple[int, float]], root: int) -> tuple[set[int], set[int]]:
+    """(`root` plus its live descendants, adopted orphans plus theirs), both by parent pid.
+
+    Parentage is what setsid(2) cannot change, which is why the session id is not used. An
+    adopted orphan (a child of this process that is not a worker it started) cannot be
+    attributed to one instance, so it is charged to every instance: the candidate is the same
+    code in each of them. Call with `_LOCK` held.
+    """
+    children: dict[int, list[int]] = {}
+    for pid, (ppid, _) in procs.items():
+        children.setdefault(ppid, []).append(pid)
+
+    def walk(roots) -> set[int]:
+        members: set[int] = set()
+        stack = list(roots)
+        while stack:
+            pid = stack.pop()
+            if pid in members:
+                continue
+            members.add(pid)
+            stack.extend(children.get(pid, []))
+        return members
+
+    own = walk([root])
+    orphans = walk(pid for pid in children.get(os.getpid(), []) if pid not in _WORKERS) - own
+    return own, orphans
+
+
+def _charge(procs: dict[int, tuple[int, float]], own: set[int], orphans: set[int]) -> float:
+    return sum(procs[pid][1] for pid in own | orphans if pid in procs) + _ESCAPED_CPU
+
+
+def _tree_cpu(root: int) -> float:
+    """CPU seconds the instance rooted at `root` is charged for right now."""
+    with _LOCK:
+        procs = _scan()
+        return _charge(procs, *_tree(procs, root))
+
+
+def _end_instance(proc) -> float:
+    """Kill the instance's tree, reap what this process adopted, and return the final charge."""
+    global _ESCAPED_CPU
+    with _LOCK:
+        procs = _scan()
+        own, orphans = _tree(procs, proc.pid)
+        charge = _charge(procs, own, orphans)
+        try:
+            os.killpg(proc.pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError, OSError):
+            pass
+        for _ in range(2):
+            for pid in set().union(*_tree(_scan(), proc.pid)):
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except (ProcessLookupError, PermissionError, OSError):
+                    pass
+        try:
+            proc.stdin.close()
+            proc.stdout.close()
+        except OSError:
+            pass
+        try:
+            proc.wait(timeout=10)
+        except Exception:
+            pass
+        _WORKERS.discard(proc.pid)
+
+
+
+        deadline = time.monotonic() + 5.0
+        while True:
+            pending = 0
+            for pid, (ppid, cpu) in _scan().items():
+                if ppid != os.getpid() or pid in _WORKERS:
+                    continue
+                try:
+                    reaped, _ = os.waitpid(pid, os.WNOHANG)
+                except ChildProcessError:
+                    continue
+                if not reaped:
+                    pending += 1
+                elif pid not in own:
+                    _ESCAPED_CPU += cpu
+            if not pending or time.monotonic() >= deadline:
+                break
+            time.sleep(0.05)
+    return charge
+
+
+def validate_solution_dir(path: str, max_bytes: int) -> tuple[bool, str, int]:
+    """Reject a deliverable tree that is missing, oversized, or contains links.
+
+    A symlink or a hard link inside a tree the harness copies is an attempt to make a
+    privileged copy materialise a file from somewhere else, so it is refused outright
+    rather than followed.
+    """
+    if not os.path.isdir(path):
+        return False, f"no deliverable directory at {path}", 0
+    if os.path.islink(path):
+        return False, "deliverable directory is a symlink", 0
+    total = 0
+    for root, dirs, files in os.walk(path, followlinks=False):
+        for name in dirs + files:
+            full = os.path.join(root, name)
+            info = os.lstat(full)
+            if stat.S_ISLNK(info.st_mode):
+                return False, f"symlink in deliverable: {os.path.relpath(full, path)}", total
+            if stat.S_ISREG(info.st_mode):
+                if info.st_nlink > 1:
+                    return False, f"hard link in deliverable: {os.path.relpath(full, path)}", total
+                total += info.st_size
+            elif not stat.S_ISDIR(info.st_mode):
+                return False, f"non-regular file in deliverable: {os.path.relpath(full, path)}", total
+            if total > max_bytes:
+                return False, f"deliverable exceeds {max_bytes} bytes", total
+    if not os.path.isfile(os.path.join(path, "policy.py")):
+        return False, f"no entry point at {os.path.join(path, 'policy.py')}", total
+    return True, "ok", total
+
+
+def stage_candidate(src: str, dst: str, own_uid: int | None = None) -> str:
+    """Copy a validated deliverable to a location the candidate cannot rewrite mid-grade.
+
+    `src` is treated as hostile and must already have passed `validate_solution_dir`; the
+    copy keeps symlinks as symlinks rather than following them. The caller is responsible
+    for `dst`'s parent being traversable by the uid the candidate runs as.
+    """
+    if os.path.exists(dst):
+        shutil.rmtree(dst)
+    shutil.copytree(src, dst, symlinks=True)
+    for root, dirs, files in os.walk(dst):
+        for name in dirs:
+            os.chmod(os.path.join(root, name), 0o755)
+        for name in files:
+            os.chmod(os.path.join(root, name), 0o644)
+    os.chmod(dst, 0o755)
+    if own_uid is not None:
+        for root, dirs, files in os.walk(dst):
+            for name in dirs + files:
+                os.chown(os.path.join(root, name), own_uid, own_uid)
+        os.chown(dst, own_uid, own_uid)
+    return dst
+
+
+def _instance_payload(instance: dict) -> dict:
+    return {
+        "coords": instance["coords"].tolist(),
+        "rewards": instance["rewards"].tolist(),
+        "dist": instance["dist"].tolist(),
+        "start": int(instance["start"]),
+        "goal": int(instance["goal"]),
+        "budget": float(instance["budget"]),
+        "p_fail": float(instance["p_fail"]),
+        "cost_model": str(instance["cost_model"]),
+    }
+
+
+def run_instance(
+    sandbox: Sandbox,
+    candidate_dir: str,
+    worker_path: str,
+    python_exe: str,
+    instance: dict,
+    noise: np.ndarray,
+    seed: int,
+    episodes: int = sopcc.EPISODES_PER_INSTANCE,
+) -> dict:
+    """Grade one instance: `episodes` episodes of one candidate process."""
+    import subprocess
+
+    limits = {
+        "cpu_seconds": float(sandbox.cpu_seconds),
+        "address_space_bytes": int(sandbox.address_space_bytes),
+        "file_size_bytes": int(sandbox.file_size_bytes),
+        "open_files": int(sandbox.open_files),
+    }
+    cmd = [python_exe, "-I", "-B", worker_path, candidate_dir, json.dumps(limits)]
+    privilege = {}
+    if sandbox.run_as_uid is not None:
+        privilege = {"user": int(sandbox.run_as_uid),
+                     "group": int(sandbox.run_as_gid if sandbox.run_as_gid is not None
+                                  else sandbox.run_as_uid),
+                     "extra_groups": []}
+
+
+
+    scratch = tempfile.mkdtemp(prefix="sopcc-run-")
+    if sandbox.run_as_uid is not None:
+        os.chown(scratch, int(sandbox.run_as_uid),
+                 int(sandbox.run_as_gid if sandbox.run_as_gid is not None
+                     else sandbox.run_as_uid))
+    os.chmod(scratch, 0o700)
+    env = {
+        "PATH": "/usr/local/bin:/usr/local/sbin:/usr/bin:/bin",
+        "HOME": scratch,
+        "TMPDIR": scratch,
+        "PYTHONHASHSEED": "0",
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "OMP_NUM_THREADS": "1",
+        "MKL_NUM_THREADS": "1",
+        "OPENBLAS_NUM_THREADS": "1",
+        "NUMEXPR_NUM_THREADS": "1",
+    }
+    env.update(sandbox.env)
+
+    errlog = open(os.path.join(scratch, "stderr.log"), "w+b")
+    deadline = time.monotonic() + float(sandbox.timeout)
+    report = {
+        "seed": int(seed),
+        "episodes": [],
+        "cpu_seconds": 0.0,
+        "wall_seconds": 0.0,
+        "abort": None,
+        "stderr_tail": "",
+    }
+    started = time.monotonic()
+    proc = None
+    _become_subreaper()
+    try:
+        with _LOCK:
+            proc = subprocess.Popen(
+                cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=errlog,
+                cwd="/",
+                env=env,
+                close_fds=True,
+                start_new_session=bool(sandbox.new_session),
+                **privilege,
+            )
+            _WORKERS.add(proc.pid)
+        try:
+            resource.prlimit(proc.pid, resource.RLIMIT_CPU,
+                             (int(sandbox.cpu_seconds) + 1, int(sandbox.cpu_seconds) + 3))
+        except (PermissionError, ProcessLookupError, OSError):
+            pass
+        reader = _LineChannel(proc.stdout.fileno())
+        writer = proc.stdin.fileno()
+
+        next_poll = [time.monotonic()]
+
+        def _exchange(payload: dict) -> dict:
+            _write_line(writer, json.dumps(payload).encode(), deadline)
+            now = time.monotonic()
+            if now >= next_poll[0]:
+                next_poll[0] = now + CPU_POLL_INTERVAL
+                cpu = _tree_cpu(proc.pid)
+                report["cpu_seconds"] = max(report["cpu_seconds"], cpu)
+                if cpu > sandbox.cpu_seconds:
+                    raise WorkerGone(f"cpu budget exhausted ({cpu:.1f}s)")
+            line = reader.readline(deadline)
+            try:
+                return json.loads(line)
+            except (ValueError, UnicodeDecodeError) as exc:
+                raise WorkerGone(f"unparseable reply: {exc}") from exc
+
+        ack = _exchange({"cmd": "init", "seed": int(seed),
+                         "instance": _instance_payload(instance)})
+        if not ack.get("ok"):
+            report["abort"] = f"{ack.get('stage', 'init')}: {ack.get('error', 'refused')}"
+            raise WorkerGone(report["abort"])
+
+        for episode in range(int(episodes)):
+            def choose(obs):
+                message = {
+                    "cmd": "act",
+                    "obs": {
+                        "current": int(obs["current"]),
+                        "visited": [bool(v) for v in obs["visited"]],
+                        "remaining_budget": float(obs["remaining_budget"]),
+                        "collected_reward": float(obs["collected_reward"]),
+                        "step": int(obs["step"]),
+                    },
+                }
+                answer = _exchange(message)
+                if not answer.get("ok"):
+                    raise sopcc.InvalidAction(
+                        f"policy raised {answer.get('error', 'an exception')}")
+                action = answer.get("action")
+                if action is None:
+                    raise sopcc.InvalidAction(
+                        f"action is {answer.get('kind', 'None')}, not an int")
+                return int(action)
+
+            outcome = sopcc.run_episode(instance, noise[episode], choose)
+            report["episodes"].append(outcome)
+    except WorkerGone as exc:
+        report["abort"] = report["abort"] or str(exc)
+    except Exception as exc:
+        report["abort"] = f"{type(exc).__name__}: {exc}"
+    finally:
+        if proc is not None:
+            report["cpu_seconds"] = max(report["cpu_seconds"], _end_instance(proc))
+        report["wall_seconds"] = time.monotonic() - started
+        try:
+            errlog.seek(0)
+            report["stderr_tail"] = errlog.read(4096).decode("utf-8", "replace")
+        except OSError:
+            pass
+        errlog.close()
+        shutil.rmtree(scratch, ignore_errors=True)
+
+    while len(report["episodes"]) < int(episodes):
+        report["episodes"].append(
+            {"delivered": 0.0, "failed": True,
+             "reason": f"aborted: {report['abort'] or 'unknown'}", "visits": 0,
+             "traversals": 0})
+    return report
+
+
+def grade_panel(
+    panel,
+    sandbox: Sandbox,
+    candidate_dir: str,
+    worker_path: str,
+    python_exe: str | None = None,
+    workers: int = 8,
+    seed_base: int = 1000,
+    episodes: int = sopcc.EPISODES_PER_INSTANCE,
+    retry_budget: int = 4,
+) -> dict:
+    """Grade a whole panel, at most `workers` instances at a time, and aggregate the metric."""
+    python_exe = python_exe or sys.executable
+    reports: list[dict | None] = [None] * len(panel)
+    with ThreadPoolExecutor(max_workers=max(1, min(workers, len(panel)))) as pool:
+        futures = {
+            pool.submit(
+                run_instance, sandbox, candidate_dir, worker_path, python_exe,
+                panel[i]["instance"], panel[i]["noise"], seed_base + i, episodes,
+            ): i
+            for i in range(len(panel))
+        }
+        for future, i in futures.items():
+            reports[i] = future.result()
+
+
+
+
+    retries = []
+    for i, report in enumerate(reports):
+        if retry_budget <= 0:
+            break
+        abort = report["abort"] or ""
+        infra = ("closed the channel" in abort) or ("is not reading" in abort)
+        if not infra or report["wall_seconds"] > 0.25 * sandbox.timeout:
+            continue
+        retry_budget -= 1
+        retries.append({"instance": i, "first_abort": abort})
+        reports[i] = run_instance(
+            sandbox, candidate_dir, worker_path, python_exe,
+            panel[i]["instance"], panel[i]["noise"], seed_base + i, episodes)
+
+    delivered, failed, draws = [], [], []
+    for i, report in enumerate(reports):
+        for outcome in report["episodes"]:
+            delivered.append(outcome["delivered"])
+            failed.append(outcome["failed"])
+            draws.append(panel[i].get("draw", 0))
+    summary = sopcc.panel_metric(delivered, failed)
+    delivered_arr = np.asarray(delivered, dtype=np.float64)
+    failed_arr = np.asarray(failed, dtype=bool)
+    draw_arr = np.asarray(draws, dtype=np.int64)
+    per_draw = {}
+    for draw in sorted(set(draws)):
+        mask = draw_arr == draw
+        per_draw[int(draw)] = sopcc.panel_metric(delivered_arr[mask], failed_arr[mask])
+    summary["per_draw"] = per_draw
+    summary["draw_metric_mean"] = float(
+        np.mean([per_draw[d]["metric"] for d in sorted(per_draw)])) if per_draw else 0.0
+    summary["instances"] = len(panel)
+    summary["retried_instances"] = retries
+    summary["aborted_instances"] = sum(1 for r in reports if r["abort"])
+    summary["max_cpu_seconds"] = max((r["cpu_seconds"] for r in reports), default=0.0)
+    summary["max_wall_seconds"] = max((r["wall_seconds"] for r in reports), default=0.0)
+    summary["reports"] = reports
+    return summary

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/sopcc.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import numpy as np
+
+
+N_VERTICES = 40
+START = 0
+GOAL = 1
+BUDGET = 2.0
+P_FAIL = 0.1
+COST_MODEL = "exponential_mean_equals_euclidean"
+
+
+EPISODES_PER_INSTANCE = 32
+MAX_TRAVERSALS = 48
+
+
+FAILURE_ALLOWANCE = 0.10
+PENALTY_SLOPE = 10.0
+
+
+DEV_ENTROPY = 20240917
+DEV_DRAWS = 4
+DEV_INSTANCES_PER_DRAW = 50
+
+
+def instance_seed(entropy: int, index: int) -> np.random.SeedSequence:
+    """Seed sequence for instance `index` of the family rooted at `entropy`."""
+    return np.random.SeedSequence(entropy=int(entropy), spawn_key=(int(index), 0))
+
+
+def noise_seed(entropy: int, index: int, variant: int = 0) -> np.random.SeedSequence:
+    """Seed sequence for the pre-drawn cost noise of instance `index`.
+
+    `variant` draws an independent noise realisation for the same instance, which is how the
+    build measures the metric's own sampling noise.
+    """
+    key = (int(index), 1) if int(variant) == 0 else (int(index), 1, int(variant))
+    return np.random.SeedSequence(entropy=int(entropy), spawn_key=key)
+
+
+def euclidean_matrix(coords: np.ndarray) -> np.ndarray:
+    diff = coords[:, None, :] - coords[None, :, :]
+    dist = np.sqrt((diff * diff).sum(axis=-1))
+    np.fill_diagonal(dist, 0.0)
+    return dist
+
+
+def make_instance(seed_sequence: np.random.SeedSequence) -> dict:
+    """One SOPCC instance: complete graph, U[0,1]^2 coordinates, U[0,1] vertex rewards.
+
+    The start and goal vertex rewards are forced to 0.0, so no reward is collected for
+    free by starting or finishing.
+    """
+    rng = np.random.Generator(np.random.PCG64(seed_sequence))
+    coords = rng.random((N_VERTICES, 2))
+    rewards = rng.random(N_VERTICES)
+    rewards[START] = 0.0
+    rewards[GOAL] = 0.0
+    return instance_from_arrays(coords, rewards)
+
+
+def instance_from_arrays(coords: np.ndarray, rewards: np.ndarray) -> dict:
+    coords = np.ascontiguousarray(coords, dtype=np.float64)
+    rewards = np.ascontiguousarray(rewards, dtype=np.float64)
+    return {
+        "coords": coords,
+        "rewards": rewards,
+        "dist": euclidean_matrix(coords),
+        "start": START,
+        "goal": GOAL,
+        "budget": BUDGET,
+        "p_fail": P_FAIL,
+        "cost_model": COST_MODEL,
+    }
+
+
+def make_noise(
+    seed_sequence: np.random.SeedSequence,
+    episodes: int = EPISODES_PER_INSTANCE,
+    traversals: int = MAX_TRAVERSALS,
+) -> np.ndarray:
+    """Pre-drawn unit-Exponential cost multipliers, one row of `traversals` per episode.
+
+    The realised cost of the k-th traversal of an episode is `dist[u, v] * noise[k]`, so
+    every traversal costs an Exponential variate with mean equal to the Euclidean edge
+    length, and two submissions see the identical random stream.
+    """
+    rng = np.random.Generator(np.random.PCG64(seed_sequence))
+    return rng.exponential(1.0, size=(int(episodes), int(traversals)))
+
+
+def make_dev_panel(draws: int = DEV_DRAWS, instances_per_draw: int = DEV_INSTANCES_PER_DRAW):
+    """The public dev panel: `draws` independent draws of `instances_per_draw` instances."""
+    panel = []
+    for draw in range(int(draws)):
+        for k in range(int(instances_per_draw)):
+            index = draw * int(instances_per_draw) + k
+            panel.append(
+                {
+                    "draw": draw,
+                    "index": index,
+                    "instance": make_instance(instance_seed(DEV_ENTROPY, index)),
+                    "noise": make_noise(noise_seed(DEV_ENTROPY, index)),
+                }
+            )
+    return panel
+
+
+class InvalidAction(Exception):
+    """The policy returned something that is not a legal next vertex."""
+
+
+def check_action(action, current: int, visited: np.ndarray) -> int:
+    """Validate one action, returning it as an int or raising InvalidAction."""
+    if isinstance(action, bool) or not isinstance(action, (int, np.integer)):
+        raise InvalidAction(f"action is {type(action).__name__}, not an int")
+    a = int(action)
+    if not 0 <= a < N_VERTICES:
+        raise InvalidAction(f"action {a} out of range")
+    if a == current:
+        raise InvalidAction("action is the current vertex")
+    if a != GOAL and visited[a]:
+        raise InvalidAction(f"action {a} is an already visited vertex")
+    return a
+
+
+def run_episode(instance: dict, noise_row: np.ndarray, choose) -> dict:
+    """Drive one episode. `choose(obs)` returns the next vertex, or raises.
+
+    Returns a dict with `delivered` (0.0 unless the goal was reached inside budget),
+    `failed`, `reason`, `visits` (count of distinct non-start vertices collected) and
+    `traversals`.
+    """
+    dist = instance["dist"]
+    rewards = instance["rewards"]
+    visited = np.zeros(N_VERTICES, dtype=bool)
+    visited[START] = True
+    current = START
+    remaining = float(instance["budget"])
+    collected = 0.0
+    step = 0
+
+    while True:
+        if step >= MAX_TRAVERSALS:
+            return _failed("traversal_cap", collected, step)
+        obs = {
+            "current": int(current),
+            "visited": visited.copy(),
+            "remaining_budget": float(remaining),
+            "collected_reward": float(collected),
+            "step": int(step),
+        }
+        try:
+            action = check_action(choose(obs), current, visited)
+        except InvalidAction as exc:
+            return _failed(f"invalid_action: {exc}", collected, step)
+        cost = float(dist[current, action]) * float(noise_row[step])
+        remaining -= cost
+        step += 1
+        if remaining < 0.0:
+            return _failed("budget_exhausted", collected, step)
+        if action == GOAL:
+            return {
+                "delivered": float(collected),
+                "failed": False,
+                "reason": "goal",
+                "visits": int(visited.sum()) - 1,
+                "traversals": step,
+                "remaining_budget": float(remaining),
+            }
+        visited[action] = True
+        collected += float(rewards[action])
+        current = action
+
+
+def _failed(reason: str, collected: float, step: int) -> dict:
+    return {
+        "delivered": 0.0,
+        "failed": True,
+        "reason": reason,
+        "visits": 0,
+        "traversals": int(step),
+        "collected_when_failed": float(collected),
+    }
+
+
+def penalty(failure_rate: float) -> float:
+    """1.0 while the failure rate respects the allowance, ramping linearly to 0.0."""
+    f = float(failure_rate)
+    if f <= FAILURE_ALLOWANCE:
+        return 1.0
+    return max(0.0, 1.0 - PENALTY_SLOPE * (f - FAILURE_ALLOWANCE))
+
+
+def panel_metric(delivered, failed) -> dict:
+    """Penalised mean delivered reward over a panel of episodes."""
+    delivered = np.asarray(delivered, dtype=np.float64)
+    failed = np.asarray(failed, dtype=bool)
+    if delivered.size == 0:
+        return {"metric": 0.0, "R": 0.0, "F": 1.0, "penalty": 0.0, "episodes": 0}
+    R = float(delivered.mean())
+    F = float(failed.mean())
+    p = penalty(F)
+    return {
+        "metric": R * p,
+        "R": R,
+        "F": F,
+        "penalty": p,
+        "episodes": int(delivered.size),
+        "delivered_std": float(delivered.std(ddof=1)) if delivered.size > 1 else 0.0,
+    }

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/test.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+
+
+set -u
+
+
+
+reward_floor() {
+    if [ ! -s /logs/verifier/reward.txt ]; then
+        mkdir -p /logs/verifier
+        printf '0\n' > /logs/verifier/reward.txt
+    fi
+}
+trap reward_floor EXIT
+
+mkdir -p /logs/verifier
+chown root:root /logs/verifier 2>/dev/null || true
+chmod 755 /logs/verifier 2>/dev/null || true
+rm -f /logs/verifier/reward.txt /logs/verifier/ctrf.json /logs/verifier/metric.json
+
+chmod -R go-rwx /tests
+
+cd /tests
+export GRADE_SPLIT=final
+/usr/local/bin/python3 -m pytest \
+    --ctrf /logs/verifier/ctrf.json /tests/test_state.py -rA
+/usr/local/bin/python3 /tests/compute_reward.py
+
+exit 0

tasks/sopcc-online-chance-constrained-policy/environment/are-grader-ctx/test_state.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import collections
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import grader_core
+import runner
+import sopcc
+
+TESTS = Path(__file__).resolve().parent
+DELIVERABLE = Path("/app/solution")
+STAGING = Path("/tmp/sopcc-candidate")
+LOGS = Path("/logs/verifier")
+
+
+MAX_DELIVERABLE_BYTES = 50 * 1024 * 1024
+CPU_SECONDS_PER_INSTANCE = 75.0
+WALL_SECONDS_PER_INSTANCE = 150.0
+ADDRESS_SPACE_BYTES = 6 * 1024 ** 3
+FILE_SIZE_BYTES = 64 * 1024 ** 2
+OPEN_FILES = 256
+AGENT_UID = 1001
+AGENT_GID = 1001
+WORKERS = 8
+
+
+
+
+
+
+
+
+SANDBOX = runner.Sandbox(
+    cpu_seconds=CPU_SECONDS_PER_INSTANCE,
+    timeout=WALL_SECONDS_PER_INSTANCE,
+    address_space_bytes=ADDRESS_SPACE_BYTES,
+    file_size_bytes=FILE_SIZE_BYTES,
+    open_files=OPEN_FILES,
+    run_as_uid=AGENT_UID,
+    run_as_gid=AGENT_GID,
+    new_session=True,
+)
+
+
+def _write_metric(payload: dict) -> None:
+    LOGS.mkdir(parents=True, exist_ok=True)
+    (LOGS / "metric.json").write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
+
+
+def _redacted(split: str) -> bool:
+    """The intermediate grader's stdout goes back to the agent, so it stays aggregate-only."""
+    return split != "final"
+
+
+@pytest.fixture(scope="session")
+def graded() -> dict:
+    """Grade the sealed panel exactly once, and write the metric file."""
+    split = os.environ.get("GRADE_SPLIT", "final")
+    payload = {
+        "split": split,
+        "metric": 0.0,
+        "reward": 0.0,
+        "R": 0.0,
+        "F": 1.0,
+        "penalty": 0.0,
+        "valid": False,
+        "reason": "grading did not complete",
+    }
+    _write_metric(payload)
+
+    if split not in grader_core.SPLITS:
+        payload["reason"] = f"unknown split {split!r}"
+        _write_metric(payload)
+        return payload
+
+    ok, reason, size = runner.validate_solution_dir(str(DELIVERABLE), MAX_DELIVERABLE_BYTES)
+    payload["deliverable_bytes"] = size
+    if not ok:
+        payload["reason"] = f"deliverable rejected: {reason}"
+        _write_metric(payload)
+        return payload
+
+    panel = grader_core.load_panel(split)
+    STAGING.parent.mkdir(parents=True, exist_ok=True)
+    if STAGING.exists():
+        shutil.rmtree(STAGING)
+    STAGING.mkdir()
+    STAGING.chmod(0o755)
+    candidate = runner.stage_candidate(str(DELIVERABLE), str(STAGING / "solution"))
+
+
+
+
+    worker = STAGING / "policy_worker.py"
+    shutil.copyfile(TESTS / "policy_worker.py", worker)
+    os.chown(worker, 0, 0)
+    worker.chmod(0o644)
+
+    summary = runner.grade_panel(
+        panel, SANDBOX, candidate,
+        worker_path=str(worker),
+        python_exe=sys.executable,
+        workers=WORKERS,
+        episodes=sopcc.EPISODES_PER_INSTANCE,
+    )
+    reasons = collections.Counter()
+    aborts = []
+    for i, report in enumerate(summary["reports"]):
+        for outcome in report["episodes"]:
+            if outcome["failed"]:
+                reasons[outcome["reason"].split(":")[0]] += 1
+        if report["abort"]:
+            aborts.append({
+                "instance": i,
+                "abort": report["abort"],
+                "cpu_seconds": report["cpu_seconds"],
+                "wall_seconds": report["wall_seconds"],
+
+
+                "unexplained": (("closed the channel" in report["abort"]
+                                 or "is not reading" in report["abort"])
+                                and report["wall_seconds"] < 0.25 * WALL_SECONDS_PER_INSTANCE
+                                and report["cpu_seconds"] < 0.5 * CPU_SECONDS_PER_INSTANCE),
+            })
+
+    payload.update({
+        "metric": summary["metric"],
+        "reward": grader_core.graded_reward(summary["metric"], split),
+        "R": summary["R"],
+        "F": summary["F"],
+        "penalty": summary["penalty"],
+        "episodes": summary["episodes"],
+        "instances": summary["instances"],
+        "per_draw_metric": {str(d): summary["per_draw"][d]["metric"]
+                            for d in sorted(summary["per_draw"])},
+        "per_draw_F": {str(d): summary["per_draw"][d]["F"]
+                       for d in sorted(summary["per_draw"])},
+        "delivered_std": summary["delivered_std"],
+        "failure_reasons": dict(reasons),
+        "aborted_instances": summary["aborted_instances"],
+        "aborts": aborts,
+        "unexplained_aborts": sum(1 for a in aborts if a["unexplained"]),
+        "retried_instances": summary["retried_instances"],
+        "max_cpu_seconds": summary["max_cpu_seconds"],
+        "max_wall_seconds": summary["max_wall_seconds"],
+        "valid": True,
+        "reason": "ok",
+    })
+    _write_metric(payload)
+
+    if _redacted(split):
+        print(f"episodes: {payload['episodes']} over {payload['instances']} instances")
+        print(f"failure rate F: {payload['F']:.4f}  penalty factor: {payload['penalty']:.4f}")
+        print("failure rate per draw: " + ", ".join(
+            f"{d}={v:.4f}" for d, v in payload["per_draw_F"].items()))
+        print("failure reasons: " + (", ".join(
+            f"{k}={v}" for k, v in sorted(reasons.items())) or "none"))
+        print(f"largest per-instance cpu {payload['max_cpu_seconds']:.1f}s of "
+              f"{CPU_SECONDS_PER_INSTANCE:.0f}s, wall {payload['max_wall_seconds']:.1f}s of "
+              f"{WALL_SECONDS_PER_INSTANCE:.0f}s")
+        print(f"instances that ended early: {payload['aborted_instances']}"
+              + (" (" + "; ".join(a["abort"][:80] for a in aborts[:3]) + ")" if aborts else ""))
+    else:
+        print(json.dumps({k: v for k, v in payload.items() if k != "failure_reasons"},
+                         indent=2, sort_keys=True))
+        print("failure reasons: " + json.dumps(dict(reasons), sort_keys=True))
+    return payload
+
+
+def test_deliverable_runs(graded):
+    """The submitted policy must exist, import, and answer decisions at all.
+
+    WHY: everything else is meaningless if the deliverable never ran. A missing, oversized,
+    link-bearing or unimportable deliverable is scored 0 rather than skipped.
+    """
+    assert graded["valid"], graded["reason"]
+    assert graded["episodes"] == graded["instances"] * sopcc.EPISODES_PER_INSTANCE
+
+
+def test_metric_is_well_formed(graded):
+    """The metric and its parts must be finite and inside their definitions.
+
+    WHY: the reward is a function of these numbers, so a NaN or an out-of-range failure rate
+    has to fail loudly here instead of propagating into reward.txt.
+    """
+    assert 0.0 <= graded["F"] <= 1.0
+    assert 0.0 <= graded["penalty"] <= 1.0
+    assert graded["R"] >= 0.0
+    assert graded["metric"] == pytest.approx(graded["R"] * graded["penalty"], abs=1e-9)
+    assert 0.0 <= graded["reward"] < 1.0
+
+
+def test_reward_follows_the_metric(graded):
+    """The reward written for this run must be exactly the map applied to the measured metric.
+
+    WHY: the reward is the only number that leaves the verifier, and it is computed once in the
+    fixture. This re-derives it from the metric through the same map, so a mis-keyed split or a
+    hand-edited payload cannot slip a different number into reward.txt. It also pins the floor:
+    a metric at or below the trivial anchor is worth exactly 0.
+    """
+    split = graded["split"]
+    assert graded["reward"] == pytest.approx(
+        grader_core.graded_reward(graded["metric"], split), abs=1e-12)
+    m0, m_ref = grader_core.ANCHORS[split]
+    assert m_ref > m0
+    assert grader_core.graded_reward(m0, split) == 0.0
+    assert grader_core.graded_reward(m0 - 1.0, split) == 0.0
+    assert grader_core.graded_reward(m_ref, split) == pytest.approx(0.5, abs=1e-12)
+
+
+def test_no_infrastructure_failure(graded):
+    """No instance may end early for a reason that is not the policy's own doing.
+
+    WHY: an instance whose child process vanished contributes 32 failures and drags the metric
+    down. Retries absorb a transient death; anything still unexplained afterwards is surfaced
+    here, on a channel the candidate cannot reach or trigger, instead of being folded silently
+    into a low score. A policy that crashes or blows its own budget is NOT unexplained.
+    """
+    assert graded.get("unexplained_aborts", 0) == 0, (
+        f"{graded.get('unexplained_aborts')} instances died without spending their own "
+        f"budget: {[a for a in graded.get('aborts', []) if a['unexplained']][:3]}")