369 validated tasks; grader keeps large builds within the 10 GB disk (part 6)

Re-ran the oracle with the updated verifier. The verifier now empties Lake's per-module setup files and generated C once each module is built, and deletes the build before writing its verdict, so a build that fills the disk scores 0 instead of leaving the trial without a result. 14 more tasks validated; not-validated list updated.

tasks/depth-three/task.toml

@@ -23,7 +23,7 @@ reference_modules = 175
 reference_lean_bytes = 1026594
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 776
+oracle_grade_seconds = 398
 difficulty = "research"
 
 [agent]

tasks/depth-three/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/diamond-distortion/task.toml

@@ -23,7 +23,7 @@ reference_modules = 32
 reference_lean_bytes = 472861
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 771
+oracle_grade_seconds = 268
 difficulty = "research"
 
 [agent]

tasks/diamond-distortion/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/diluted-spin/task.toml

@@ -23,7 +23,7 @@ reference_modules = 405
 reference_lean_bytes = 2760702
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1537
+oracle_grade_seconds = 1199
 difficulty = "research"
 
 [agent]

tasks/diluted-spin/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/dimension-ten-channel/task.toml

@@ -23,7 +23,7 @@ reference_modules = 148
 reference_lean_bytes = 3075057
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 2360
+oracle_grade_seconds = 1785
 difficulty = "research"
 
 [agent]

tasks/dimension-ten-channel/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/dimension-ten-pair/task.toml

@@ -23,7 +23,7 @@ reference_modules = 129
 reference_lean_bytes = 2413995
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1766
+oracle_grade_seconds = 1663
 difficulty = "research"
 
 [agent]

tasks/dimension-ten-pair/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/direct-crouzeix/task.toml

@@ -23,7 +23,7 @@ reference_modules = 42
 reference_lean_bytes = 314025
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1202
+oracle_grade_seconds = 429
 difficulty = "research"
 
 [agent]

tasks/direct-crouzeix/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/directed-feedback/task.toml

@@ -23,7 +23,7 @@ reference_modules = 224
 reference_lean_bytes = 8506385
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1662
+oracle_grade_seconds = 1607
 difficulty = "research"
 
 [agent]

tasks/directed-feedback/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/directional-ballisticity/task.toml

@@ -23,7 +23,7 @@ reference_modules = 513
 reference_lean_bytes = 5012403
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1730
+oracle_grade_seconds = 1803
 difficulty = "research"
 
 [agent]

tasks/directional-ballisticity/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/directional-walk/task.toml

@@ -23,7 +23,7 @@ reference_modules = 69
 reference_lean_bytes = 951618
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 968
+oracle_grade_seconds = 459
 difficulty = "research"
 
 [agent]

tasks/directional-walk/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/discrete-lipschitz-free/task.toml

@@ -23,7 +23,7 @@ reference_modules = 32
 reference_lean_bytes = 173635
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 662
+oracle_grade_seconds = 199
 difficulty = "research"
 
 [agent]

tasks/discrete-lipschitz-free/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/disk-maximal/task.toml

@@ -23,7 +23,7 @@ reference_modules = 30
 reference_lean_bytes = 970308
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 756
+oracle_grade_seconds = 415
 difficulty = "research"
 
 [agent]

tasks/disk-maximal/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/dixmier-all-discrete/task.toml

@@ -23,7 +23,7 @@ reference_modules = 39
 reference_lean_bytes = 181502
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 471
+oracle_grade_seconds = 194
 difficulty = "research"
 
 [agent]

tasks/dixmier-all-discrete/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/dixmier/task.toml

@@ -23,7 +23,7 @@ reference_modules = 32
 reference_lean_bytes = 158919
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 332
+oracle_grade_seconds = 112
 difficulty = "research"
 
 [agent]

tasks/dixmier/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/doubling-hilbert/task.toml

@@ -23,7 +23,7 @@ reference_modules = 12
 reference_lean_bytes = 157722
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 454
+oracle_grade_seconds = 179
 difficulty = "research"
 
 [agent]

tasks/doubling-hilbert/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/dutta-domain/task.toml

@@ -23,7 +23,7 @@ reference_modules = 278
 reference_lean_bytes = 2409516
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1913
+oracle_grade_seconds = 1966
 difficulty = "research"
 
 [agent]

tasks/dutta-domain/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/dyadic-avoidance/task.toml

@@ -23,7 +23,7 @@ reference_modules = 75
 reference_lean_bytes = 369234
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 796
+oracle_grade_seconds = 198
 difficulty = "research"
 
 [agent]

tasks/dyadic-avoidance/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/edit-approximation/task.toml

@@ -23,7 +23,7 @@ reference_modules = 1024
 reference_lean_bytes = 7591774
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 3183
+oracle_grade_seconds = 2717
 difficulty = "research"
 
 [agent]