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

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/weighted-sweep-moments/task.toml

@@ -23,7 +23,7 @@ reference_modules = 40
 reference_lean_bytes = 815310
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 338
+oracle_grade_seconds = 329
 difficulty = "research"
 
 [agent]

tasks/weighted-sweep-moments/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/weisfeiler-leman/task.toml

@@ -23,7 +23,7 @@ reference_modules = 43
 reference_lean_bytes = 917937
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 401
+oracle_grade_seconds = 301
 difficulty = "research"
 
 [agent]

tasks/weisfeiler-leman/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/witnessed-choice/task.toml

@@ -23,7 +23,7 @@ reference_modules = 27
 reference_lean_bytes = 1118157
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 585
+oracle_grade_seconds = 485
 difficulty = "research"
 
 [agent]

tasks/witnessed-choice/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/wl-identification/task.toml

@@ -23,7 +23,7 @@ reference_modules = 67
 reference_lean_bytes = 765224
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 529
+oracle_grade_seconds = 358
 difficulty = "research"
 
 [agent]

tasks/wl-identification/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/yau-counterexample/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: