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

tasks/hicard-latent-encoder/task.toml

@@ -1,57 +1,71 @@
 schema_version = "1.4"
-artifacts = [ "/app/output",]
+artifacts = [
+    { source = "/var/lib/are", service = "grader" },
+]
 
 [task]
 name = "bespokelabs/hicard-latent-encoder"
-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 = "Feature engineering"
-task_objective = [ "Implement", "Optimize",]
-artifact_type = [ "Single script or program",]
+task_objective = [
+    "Implement",
+    "Optimize",
+]
+artifact_type = [
+    "Single script or program",
+]
 expert_time_estimate_hours = 4.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 = 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/hicard-latent-encoder/tests/Dockerfile

@@ -1,35 +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 mkdir -p /opt/harness \
-    && cp /tests/candidate_runner.py /opt/harness/candidate_runner.py \
-    && chown -R root:root /opt/harness /tests \
-    && chmod 755 /opt/harness \
-    && chmod 644 /opt/harness/candidate_runner.py \
-    && chmod 700 /tests/hidden_data /tests/hidden_data/intermediate /tests/hidden_data/final \
-    && chmod +x /tests/test.sh /tests/intermediate.sh \
-    && find /tests /opt/harness -exec touch -d @1700000000 {} +
-
-WORKDIR /tests
+FROM python:3.12-slim
+COPY . /tests/

tasks/hicard-latent-encoder/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/hicard-latent-encoder/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
-
-trap 'if [ ! -s /logs/verifier/reward.txt ]; then echo 0 > /logs/verifier/reward.txt; fi' EXIT TERM INT
-
-chmod -R go-rwx /tests
-
-export GRADER_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/label-efficient-risk-estimator/environment/.dockerignore

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

tasks/label-efficient-risk-estimator/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/output /logs/verifier /grade_run
+
+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/label-efficient-risk-estimator/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/output /logs/verifier /grade_run
+
+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/label-efficient-risk-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/label-efficient-risk-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/label-efficient-risk-estimator/environment/are-grader-ctx/candidate_runner.py

@@ -0,0 +1,142 @@
+import argparse
+import os
+import signal
+import socket
+import struct
+import sys
+import time
+import types
+
+import numpy as np
+
+_HDR = struct.Struct("<c")
+_I32 = struct.Struct("<i")
+_F64 = struct.Struct("<d")
+
+
+def _sendall(sock, data):
+    sock.sendall(data)
+
+
+def _recv_exact(sock, n):
+    buf = b""
+    while len(buf) < n:
+        chunk = sock.recv(n - len(buf))
+        if not chunk:
+            raise ConnectionError("scorer closed the label channel")
+        buf += chunk
+    return buf
+
+
+def _request_label(sock, index):
+    _sendall(sock, _HDR.pack(b"L") + _I32.pack(int(index)))
+    return _I32.unpack(_recv_exact(sock, 4))[0]
+
+
+def _run_one_seed(sock, code, module_path, submission_dir, pool, budget, seed):
+    """Executed in the grandchild only. Never returns."""
+    try:
+        os.setpgid(0, 0)
+    except OSError:
+        pass
+    try:
+        sys.path.insert(0, submission_dir)
+        mod = types.ModuleType("candidate_estimator")
+        mod.__file__ = module_path
+        exec(code, mod.__dict__)
+        Estimator = mod.Estimator
+        rng = np.random.default_rng([pool["_cseed"], seed])
+        est = Estimator(pool["_view"], budget, rng)
+        n_pool = pool["_view"]["n_pool"]
+        for _ in range(budget):
+            idx = est.next_index()
+            idx = int(idx)
+            if not (0 <= idx < n_pool):
+                raise ValueError(f"next_index returned {idx}, outside [0, {n_pool})")
+            label = _request_label(sock, idx)
+            if label < 0:
+                raise RuntimeError("label budget exhausted")
+            est.observe(idx, label)
+        value = float(est.estimate())
+        if not np.isfinite(value):
+            raise ValueError(f"estimate() returned {value}")
+        _sendall(sock, _HDR.pack(b"R") + _I32.pack(seed) + _F64.pack(value))
+        _recv_exact(sock, 1)
+        os._exit(0)
+    except BaseException:
+        try:
+            sys.stderr.write(f"[seed {seed}] candidate failed\n")
+        except Exception:
+            pass
+        os._exit(3)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pool", required=True)
+    ap.add_argument("--submission-dir", required=True)
+    ap.add_argument("--entry", required=True)
+    ap.add_argument("--budget", type=int, required=True)
+    ap.add_argument("--seeds", type=int, required=True)
+    ap.add_argument("--seed-start", type=int, default=0)
+    ap.add_argument("--cell-seed", type=int, required=True)
+    ap.add_argument("--per-seed-timeout", type=float, required=True)
+    ap.add_argument("--sock-fd", type=int, required=True)
+    args = ap.parse_args()
+
+    sock = socket.socket(fileno=args.sock_fd)
+
+    with open(args.entry, "rb") as fh:
+        src = fh.read()
+    code = compile(src, args.entry, "exec")
+
+    npz = np.load(args.pool)
+    target_probs = np.ascontiguousarray(npz["target_probs"], dtype=np.float64)
+    surrogate_probs = np.ascontiguousarray(npz["surrogate_probs"], dtype=np.float64)
+    n_pool, n_classes = target_probs.shape
+
+    for seed in range(args.seed_start, args.seed_start + args.seeds):
+        _sendall(sock, _HDR.pack(b"S") + _I32.pack(seed))
+        if _recv_exact(sock, 1) != b"\x01":
+            sys.stderr.write("scorer refused the seed handshake\n")
+            return 1
+        perm = np.random.default_rng([args.cell_seed, seed, 0x5EED]).permutation(n_pool)
+        view = {
+            "target_probs": np.ascontiguousarray(target_probs[perm]),
+            "surrogate_probs": np.ascontiguousarray(surrogate_probs[perm]),
+            "n_classes": int(n_classes),
+            "n_pool": int(n_pool),
+        }
+        pool = {"_view": view, "_cseed": args.cell_seed}
+        pid = os.fork()
+        if pid == 0:
+            _run_one_seed(sock, code, args.entry, args.submission_dir, pool,
+                          args.budget, seed)
+        deadline = time.monotonic() + args.per_seed_timeout
+        status = None
+        while True:
+            done, status = os.waitpid(pid, os.WNOHANG)
+            if done:
+                break
+            if time.monotonic() > deadline:
+                for sig in (signal.SIGKILL,):
+                    try:
+                        os.killpg(pid, sig)
+                    except OSError:
+                        try:
+                            os.kill(pid, sig)
+                        except OSError:
+                            pass
+                os.waitpid(pid, 0)
+                status = -1
+                break
+            time.sleep(0.0005)
+        if status != 0:
+            _sendall(sock, _HDR.pack(b"F") + _I32.pack(seed))
+            _recv_exact(sock, 1)
+    _sendall(sock, _HDR.pack(b"Q") + _I32.pack(0))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/compute_reward.py

@@ -0,0 +1,20 @@
+import json
+import math
+from pathlib import Path
+
+REWARD_PATH = Path("/logs/verifier/reward.txt")
+
+try:
+    REWARD_PATH.parent.mkdir(parents=True, exist_ok=True)
+    payload = json.loads(Path("/logs/verifier/metric.json").read_text())
+    if not payload.get("valid", False):
+        raise ValueError(f"invalid submission: {payload.get('reason')}")
+    value = float(payload["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.write_text("0\n")
+    print(f"reward=0 (fallback: {exc})")

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/grader_core.py

@@ -0,0 +1,79 @@
+import hashlib
+import math
+
+import numpy as np
+
+BUDGETS = (50, 100, 200, 400)
+N_SEEDS = 4000
+PER_SEED_TIMEOUT_S = 5.0
+PER_CELL_TIMEOUT_S = 900.0
+SE_CAP = 100.0
+RATIO_CAP = 1.0e4
+
+M0 = 1.0
+BASELINE_SCORE = 0.68
+HIGHER_IS_BETTER = False
+
+_SALT = "2508-09093/label-efficient-risk-estimator/v1"
+
+
+def cell_seed(instance_id: str, budget: int) -> int:
+    """Deterministic per-cell seed. Identical on both sides of the socket."""
+    h = hashlib.sha256(f"{_SALT}|{instance_id}|{budget}".encode()).digest()
+    return int.from_bytes(h[:8], "big")
+
+
+def seed_permutation(cseed: int, seed: int, n_pool: int) -> np.ndarray:
+    """Row order the candidate sees for this (cell, seed). Defeats any {row -> label} cache."""
+    return np.random.default_rng([cseed, seed, 0x5EED]).permutation(n_pool)
+
+
+def exact_risk(target_probs: np.ndarray, labels: np.ndarray) -> float:
+    """R = (1/N) sum_i -log target_probs[i, y_i] over the WHOLE pool."""
+    p = target_probs[np.arange(labels.shape[0]), labels]
+    return float(np.mean(-np.log(np.clip(p, 1e-300, None))))
+
+
+def reference_squared_errors(target_probs, labels, budget, cseed, seeds):
+    """Uniform-random acquisition + plain sample mean, on the same seeds and the same
+    permuted view the candidate is given. This is the metric's denominator."""
+    n_pool = labels.shape[0]
+    risk = exact_risk(target_probs, labels)
+    nll = -np.log(np.clip(target_probs[np.arange(n_pool), labels], 1e-300, None))
+    out = np.empty(len(seeds), dtype=np.float64)
+    for k, s in enumerate(seeds):
+        perm = seed_permutation(cseed, s, n_pool)
+        nll_perm = nll[perm]
+        rng = np.random.default_rng([cseed, s])
+        idx = rng.choice(n_pool, size=budget, replace=False)
+        out[k] = (float(np.mean(nll_perm[idx])) - risk) ** 2
+    return out
+
+
+def cell_ratio(agent_se: np.ndarray, ref_se: np.ndarray) -> float:
+    """median-over-seeds squared error of the candidate, divided by the reference's."""
+    num = float(np.median(agent_se))
+    den = float(np.median(ref_se))
+    if not math.isfinite(den) or den <= 0.0:
+        den = 1e-12
+    return float(min(RATIO_CAP, num / den))
+
+
+def aggregate(cell_ratios) -> float:
+    """The graded metric: the median of the per-cell ratios."""
+    vals = np.asarray(list(cell_ratios), dtype=np.float64)
+    if vals.size == 0 or not np.all(np.isfinite(vals)):
+        return float(RATIO_CAP)
+    return float(np.median(vals))
+
+
+def graded_reward(metric: float, valid: bool) -> float:
+    """rational_squash on two task-derived anchors. Clamped again in compute_reward.py."""
+    if not valid or metric is None or not math.isfinite(metric):
+        return 0.0
+    sigma = 1.0 if HIGHER_IS_BETTER else -1.0
+    x = sigma * (metric - M0)
+    x_ref = sigma * (BASELINE_SCORE - M0)
+    assert x_ref > 0, "malformed task: the anchor does not beat the trivial baseline"
+    u = max(0.0, x) / x_ref
+    return u / (1.0 + u)

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool01/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool01/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool01", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool01/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool01/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool02/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool02/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool02", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool02/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool02/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool04/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool04/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool04", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool04/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool04/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool07/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool07/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool07", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool07/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/final/pool07/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool00/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool00/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool00", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool00/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool00/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool03/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool03/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool03", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool03/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool03/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool05/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool05/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool05", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool05/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool05/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool06/labels.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool06/meta.json

@@ -0,0 +1 @@
+{"pool_id": "pool06", "n_pool": 2000, "n_classes": 2}

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool06/surrogate_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/hidden_data/intermediate/pool06/target_probs.npy

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/intermediate.sh

@@ -0,0 +1,20 @@
+#!/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 '[ -s /logs/verifier/reward.txt ] || printf "0\n" > /logs/verifier/reward.txt' EXIT
+
+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/label-efficient-risk-estimator/environment/are-grader-ctx/requirements-verifier.txt

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

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/requirements.txt

@@ -0,0 +1,2 @@
+numpy==2.3.2
+scipy==1.16.1

tasks/label-efficient-risk-estimator/environment/are-grader-ctx/test.sh

@@ -0,0 +1,20 @@
+#!/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 '[ -s /logs/verifier/reward.txt ] || printf "0\n" > /logs/verifier/reward.txt' EXIT
+
+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/label-efficient-risk-estimator/environment/are-grader-ctx/test_state.py

@@ -0,0 +1,319 @@
+import json
+import os
+import shutil
+import socket
+import struct
+import subprocess
+import sys
+import tempfile
+import time
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import grader_core as GC
+
+PY = "/usr/local/bin/python3"
+TESTS_DIR = Path(__file__).resolve().parent
+RUNNER_SRC = TESTS_DIR / "candidate_runner.py"
+DELIVERABLE_DIR = Path("/app/output")
+ENTRY_NAME = "estimator.py"
+STAGE = Path("/grade_run")
+LOGS = Path("/logs/verifier")
+AGENT_UID, AGENT_GID = 1001, 1001
+MAX_SUBMISSION_BYTES = 256 * 1024 * 1024
+MAX_SUBMISSION_FILES = 2000
+
+_HDR = struct.Struct("<c")
+_I32 = struct.Struct("<i")
+_F64 = struct.Struct("<d")
+
+
+def harvest_submission():
+    """Copy /app/output into a root-owned staging tree, refusing every link.
+
+    Every submitted path is treated as hostile: symlinks and hard links are rejected
+    before anything is copied (checked at every depth), and the copy itself never
+    follows a link. A privileged copy that dereferenced a submitted symlink would
+    materialise sealed verifier files into the tree the score is computed from.
+    """
+    dest = STAGE / "submission"
+    if dest.exists():
+        shutil.rmtree(dest)
+    if DELIVERABLE_DIR.is_symlink():
+        return None, f"{DELIVERABLE_DIR} is a symlink"
+    if not DELIVERABLE_DIR.is_dir():
+        return None, f"no deliverable directory at {DELIVERABLE_DIR}"
+    total, count = 0, 0
+    for root, dirs, files in os.walk(DELIVERABLE_DIR, followlinks=False):
+        for name in list(dirs) + list(files):
+            p = Path(root) / name
+            st = p.lstat()
+            if p.is_symlink():
+                return None, f"symlink in the deliverable tree: {p}"
+            if p.is_file() and st.st_nlink > 1:
+                return None, f"hard link in the deliverable tree: {p}"
+            if p.is_file():
+                total += st.st_size
+                count += 1
+            elif not p.is_dir():
+                return None, f"not a regular file or directory: {p}"
+    if count == 0:
+        return None, "the deliverable directory is empty"
+    if total > MAX_SUBMISSION_BYTES or count > MAX_SUBMISSION_FILES:
+        return None, f"deliverable too large: {count} files, {total} bytes"
+    shutil.copytree(DELIVERABLE_DIR, dest, symlinks=True)
+    for root, dirs, files in os.walk(dest):
+        os.chmod(root, 0o755)
+        for name in files:
+            os.chmod(Path(root) / name, 0o644)
+    entry = dest / ENTRY_NAME
+    if entry.is_symlink() or not entry.is_file() or entry.stat().st_size == 0:
+        return None, f"missing or empty entry point {DELIVERABLE_DIR / ENTRY_NAME}"
+    return dest, None
+
+
+def seal_filesystem():
+    """Leave uid 1001 no writable directory, so no candidate state can survive a seed."""
+    for path in ("/tmp", "/var/tmp", "/dev/shm", "/home/agent", "/app", "/app/output"):
+        try:
+            os.chown(path, 0, 0)
+            os.chmod(path, 0o755)
+        except OSError:
+            pass
+
+
+def _launch_runner(cell_dir, submission_dir, budget, cseed, n_seeds, seed0, child_fd):
+    argv = [PY, "-I", str(cell_dir / "candidate_runner.py"),
+            "--pool", str(cell_dir / "pool.npz"),
+            "--submission-dir", str(submission_dir),
+            "--entry", str(Path(submission_dir) / ENTRY_NAME),
+            "--budget", str(budget), "--seeds", str(n_seeds),
+            "--seed-start", str(seed0),
+            "--cell-seed", str(cseed),
+            "--per-seed-timeout", str(GC.PER_SEED_TIMEOUT_S),
+            "--sock-fd", str(child_fd)]
+    env = {"PATH": "/usr/local/bin:/usr/bin:/bin", "HOME": "/home/agent",
+           "TMPDIR": "/nonexistent", "PYTHONDONTWRITEBYTECODE": "1",
+           "PYTHONSAFEPATH": "1", "PYTHONHASHSEED": "0", "OMP_NUM_THREADS": "1",
+           "MKL_NUM_THREADS": "1", "OPENBLAS_NUM_THREADS": "1",
+           "NUMEXPR_NUM_THREADS": "1", "LC_ALL": "C"}
+    err = subprocess.DEVNULL
+    if os.environ.get("GRADE_DEBUG"):
+        err = open(Path(cell_dir) / "candidate_stderr.log", "wb")
+    prefix = []
+    for cand, args in (("/usr/sbin/runuser", ["-u", "agent", "--"]),
+                       ("/usr/bin/setpriv", [f"--reuid={AGENT_UID}",
+                                             f"--regid={AGENT_GID}", "--clear-groups", "--"])):
+        if os.path.exists(cand):
+            prefix = [cand] + args
+            break
+    kwargs = {}
+    if not prefix:
+        kwargs = {"user": AGENT_UID, "group": AGENT_GID, "extra_groups": []}
+    return subprocess.Popen(prefix + argv, env=env, start_new_session=True,
+                            pass_fds=(child_fd,), stdout=subprocess.DEVNULL,
+                            stderr=err, cwd=str(cell_dir), **kwargs)
+
+
+def _serve(sock, labels, budget, cseed, seeds, deadline):
+    """Label oracle. Enforces the budget and the one-shot, in-order seed protocol."""
+    n_pool = labels.shape[0]
+    estimates, used, answered, perm = {}, 0, True, None
+    expected = list(seeds)
+    pos, current = 0, None
+    violation = None
+    try:
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                violation = "cell wall-clock budget exhausted"
+                break
+            sock.settimeout(remaining)
+            head = sock.recv(1)
+            if not head:
+                break
+            if head == b"S":
+                s = _I32.unpack(_recv_exact(sock, 4))[0]
+                if pos >= len(expected) or s != expected[pos]:
+                    violation = f"out-of-order seed handshake: {s} after {current}"
+                    break
+                current, used, answered = s, 0, False
+                pos += 1
+                perm = GC.seed_permutation(cseed, s, n_pool)
+                sock.sendall(b"\x01")
+            elif head == b"L":
+                j = _I32.unpack(_recv_exact(sock, 4))[0]
+                if answered or used >= budget or not (0 <= j < n_pool):
+                    sock.sendall(_I32.pack(-1))
+                else:
+                    used += 1
+                    sock.sendall(_I32.pack(int(labels[perm[j]])))
+            elif head == b"R":
+                s = _I32.unpack(_recv_exact(sock, 4))[0]
+                v = _F64.unpack(_recv_exact(sock, 8))[0]
+                if s != current or answered:
+                    violation = f"duplicate or stray result for seed {s}"
+                    sock.sendall(b"\x01")
+                    break
+                estimates[s], answered = v, True
+                sock.sendall(b"\x01")
+            elif head == b"F":
+                _recv_exact(sock, 4)
+                answered = True
+                sock.sendall(b"\x01")
+            elif head == b"Q":
+                _recv_exact(sock, 4)
+                break
+            else:
+                violation = f"unknown opcode {head!r}"
+                break
+    except (socket.timeout, ConnectionError, OSError, struct.error) as exc:
+        if violation is None and len(estimates) < len(expected):
+            violation = f"label channel ended early ({type(exc).__name__})"
+    return estimates, violation
+
+
+def _recv_exact(sock, n):
+    buf = b""
+    while len(buf) < n:
+        chunk = sock.recv(n - len(buf))
+        if not chunk:
+            raise ConnectionError("candidate closed the label channel")
+        buf += chunk
+    return buf
+
+
+def grade_cell(job):
+    """Runs in a root worker process. Returns the cell's ratio and diagnostics.
+
+    Any failure inside this worker is reported as a worst-case cell rather than being
+    allowed to abort the grade, so the reward path always reaches compute_reward.py.
+    """
+    try:
+        return _grade_cell(job)
+    except Exception as exc:
+        return {"instance": job[1], "budget": job[2], "risk": None,
+                "ratio": GC.RATIO_CAP, "n_ok": 0, "n_seeds": job[4],
+                "violation": f"scorer error: {type(exc).__name__}: {exc}"}
+
+
+def _grade_cell(job):
+    inst_dir, instance_id, budget, submission_dir, n_seeds, seed0 = job
+    inst_dir = Path(inst_dir)
+    target = np.load(inst_dir / "target_probs.npy").astype(np.float64)
+    surrogate = np.load(inst_dir / "surrogate_probs.npy").astype(np.float64)
+    labels = np.load(inst_dir / "labels.npy").astype(np.int64)
+    cseed = GC.cell_seed(instance_id, budget)
+    risk = GC.exact_risk(target, labels)
+    seeds = list(range(seed0, seed0 + n_seeds))
+    ref_se = GC.reference_squared_errors(target, labels, budget, cseed, seeds)
+
+    cell_dir = Path(tempfile.mkdtemp(prefix=f"cell_{instance_id}_{budget}_", dir=str(STAGE)))
+    os.chmod(cell_dir, 0o755)
+    np.savez(cell_dir / "pool.npz", target_probs=target, surrogate_probs=surrogate)
+    shutil.copy2(RUNNER_SRC, cell_dir / "candidate_runner.py")
+    os.chmod(cell_dir / "pool.npz", 0o644)
+    os.chmod(cell_dir / "candidate_runner.py", 0o644)
+
+    parent_sock, child_sock = socket.socketpair()
+    proc = None
+    try:
+        proc = _launch_runner(cell_dir, submission_dir, budget, cseed, n_seeds, seed0,
+                              child_sock.fileno())
+        child_sock.close()
+        estimates, violation = _serve(parent_sock, labels, budget, cseed, seeds,
+                                      time.monotonic() + GC.PER_CELL_TIMEOUT_S)
+    finally:
+        if os.environ.get("GRADE_DEBUG"):
+            try:
+                tail = (cell_dir / "candidate_stderr.log").read_bytes()[-4000:]
+                if tail:
+                    print(f"[stderr {instance_id} M={budget}]\n{tail.decode(errors='replace')}")
+            except OSError:
+                pass
+        try:
+            parent_sock.close()
+        except OSError:
+            pass
+        if proc is not None:
+            try:
+                os.killpg(os.getpgid(proc.pid), 9)
+            except OSError:
+                pass
+            try:
+                proc.wait(timeout=30)
+            except Exception:
+                pass
+        shutil.rmtree(cell_dir, ignore_errors=True)
+
+    agent_se = np.full(n_seeds, GC.SE_CAP, dtype=np.float64)
+    if violation is None:
+        for s, v in estimates.items():
+            k = s - seed0
+            if 0 <= k < n_seeds and np.isfinite(v):
+                agent_se[k] = min(GC.SE_CAP, (float(v) - risk) ** 2)
+    n_ok = int(np.sum(agent_se < GC.SE_CAP))
+    return {"instance": instance_id, "budget": budget, "risk": risk,
+            "ratio": GC.cell_ratio(agent_se, ref_se), "n_ok": n_ok,
+            "n_seeds": n_seeds, "violation": violation}
+
+
+def _write_metric(payload):
+    LOGS.mkdir(parents=True, exist_ok=True)
+    (LOGS / "metric.json").write_text(json.dumps(payload, indent=2, sort_keys=True))
+
+
+def test_reward():
+    """Execute the candidate estimator over every sealed cell and write metric.json.
+
+    WHAT: drives the candidate's /app/output/estimator.py through the full adaptive
+    acquisition protocol on the sealed pools, computes the median relative
+    risk-estimation error against the verifier's own uniform-random reference, and maps
+    it to the graded reward.
+    WHY: the reward has to come from EXECUTING candidate code on inputs that were never
+    in the agent image, never from reading a file the candidate wrote.
+    """
+    split = os.environ.get("GRADE_SPLIT", "final")
+    hidden = TESTS_DIR / "hidden_data" / split
+    n_seeds = int(os.environ.get("GRADE_SEEDS", GC.N_SEEDS))
+    seed0 = int(os.environ.get("GRADE_SEED_OFFSET", 0))
+    STAGE.mkdir(parents=True, exist_ok=True)
+    os.chmod(STAGE, 0o755)
+
+    submission_dir, reason = harvest_submission()
+    if submission_dir is None:
+        _write_metric({"valid": False, "reason": reason, "reward": 0.0,
+                       "metric": None, "split": split})
+        print(f"INVALID SUBMISSION: {reason}")
+        assert False, reason
+
+    seal_filesystem()
+    instances = sorted(p for p in hidden.iterdir() if p.is_dir())
+    assert instances, f"no sealed instances under {hidden}"
+    jobs = [(str(p), p.name, b, str(submission_dir), n_seeds, seed0)
+            for p in instances for b in GC.BUDGETS]
+
+    workers = min(8, len(jobs))
+    with ProcessPoolExecutor(max_workers=workers) as pool:
+        cells = list(pool.map(grade_cell, jobs))
+
+    metric = GC.aggregate(c["ratio"] for c in cells)
+    reward = GC.graded_reward(metric, valid=True)
+    _write_metric({"valid": True, "split": split, "metric": metric, "reward": reward,
+                   "n_seeds": n_seeds, "seed_offset": seed0,
+                   "cells": cells})
+    if split != "intermediate":
+        for c in sorted(cells, key=lambda c: (c["instance"], c["budget"])):
+            print(f"  {c['instance']:>16s}  M={c['budget']:>3d}  "
+                  f"relative_error={c['ratio']:.4f}  seeds_ok={c['n_ok']}/{c['n_seeds']}"
+                  + (f"  [{c['violation']}]" if c["violation"] else ""))
+    print(f"median relative risk-estimation error = {metric:.4f} "
+          f"over {len(cells)} cells")
+    assert np.isfinite(metric)
+
+
+if __name__ == "__main__":
+    test_reward()

tasks/label-efficient-risk-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: "2700"
+    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: "2700"
+    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