Update dataset (part 2)

README.md

@@ -297,7 +297,7 @@ empty change scores 0, and the reference fix scores 1.0 with every criterion
 equal to the task's original grading. The folder contains the reference fixes
 and the hidden graders, as the rows of this dataset do.
 
-9 more (badger, bazel-remote, geode, kratos, open-xml-sdk, openfire, terser, umya, zettlr) are packaged and are being re-checked; they are added
+8 more (badger, geode, kratos, open-xml-sdk, openfire, terser, umya, zettlr) are packaged and are being re-checked; they are added
 as each one passes.
 
 Nine tasks have no Harbor package yet: click, sequelize, druid and hooks (one criterion each

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/environment/Dockerfile

@@ -0,0 +1,24 @@
+FROM ec-swe-bazel-remote:source-v2 AS sanitized
+USER root
+COPY sanitize.py capture.py capture_submission.py /opt/task-tools/
+RUN HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 /opt/hudvenv/bin/python /opt/task-tools/sanitize.py
+FROM scratch
+COPY --from=sanitized / /
+ENV PATH="/usr/local/go/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
+ENV LANG="C.UTF-8"
+ENV GOTOOLCHAIN="local"
+ENV CGO_ENABLED="1"
+ENV GOWORK="off"
+ENV GOFLAGS="-mod=mod"
+ENV GOPATH="/go"
+ENV GOMODCACHE="/go/pkg/mod"
+ENV GOMEMLIMIT="1GiB"
+ENV GOPROXY="off"
+ENV GOMAXPROCS="2"
+ENV HOME="/tmp/agent-home"
+ENV GOCACHE="/tmp/agent-home/.cache/go-build"
+ENV HUD_TELEMETRY_ENABLED="false"
+ENV HUD_CLI_ANALYTICS_ENABLED="0"
+WORKDIR /workspace/repo
+USER 1000:1000
+CMD ["sleep", "infinity"]

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/environment/capture.py

@@ -0,0 +1,28 @@
+"""Capture a patch against protected baseline history inside the agent sandbox."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, "/opt/task-tools")
+from capture_submission import capture_submission  # noqa: E402
+
+with tempfile.TemporaryDirectory(prefix="capture-") as directory:
+    git_dir = Path(directory) / "git"
+    shutil.copytree("/opt/task-tools/baseline.git", git_dir)
+    os.environ.update(
+        GIT_DIR=str(git_dir),
+        GIT_WORK_TREE="/workspace/repo",
+        GIT_CONFIG_NOSYSTEM="1",
+        GIT_CONFIG_GLOBAL="/dev/null",
+    )
+    print(
+        json.dumps(
+            capture_submission(
+                Path("/workspace/repo"), Path("/workspace/submissions/submitted.patch")
+            )
+        )
+    )

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/environment/capture_submission.py

@@ -0,0 +1,157 @@
+"""Capture tracked and new SWE files without changing the agent's Git index."""
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+import tempfile
+from pathlib import Path
+
+MAX_SUBMISSION_BYTES = 32 * 1024 * 1024
+
+
+def capture_submission(
+    repository: Path, output: Path, *, max_bytes: int = MAX_SUBMISSION_BYTES
+) -> dict[str, object]:
+    """Write a bounded binary patch including nonignored new files.
+
+    Parameters
+    ----------
+    repository : Path
+        Git checkout root. HEAD must remain the task's initial commit.
+    output : Path
+        Submission path outside the checkout. Replaces any prior submission.
+    max_bytes : int, default: 33554432
+        Maximum emitted patch size. Oversized submissions fail without a patch.
+
+    Returns
+    -------
+    dict
+        Patch size, SHA-256, base commit and capture format for trial evidence.
+
+    Raises
+    ------
+    ValueError
+        If paths or the limit are invalid, or the patch exceeds the limit.
+    OSError, subprocess.CalledProcessError, RuntimeError
+        If capture fails. No partial patch is published.
+
+    Notes
+    -----
+    Uses a temporary index to combine staged, unstaged and untracked changes.
+    Ignored untracked files are excluded. This is a capture bound, not a total
+    sandbox disk quota or a security boundary against a malicious Git runtime.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    repository = repository.resolve(strict=True)
+    if output.is_symlink():
+        raise ValueError("Submission output must not be a symlink")
+    output = output.resolve()
+    if output.is_relative_to(repository):
+        raise ValueError("Submission output must be outside the repository")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.unlink(missing_ok=True)
+    root = subprocess.check_output(
+        ["git", "rev-parse", "--show-toplevel"], cwd=repository, text=True
+    ).strip()
+    if Path(root).resolve() != repository:
+        raise ValueError("repository must be the Git checkout root")
+    base = subprocess.check_output(
+        ["git", "rev-parse", "--verify", "HEAD^{commit}"], cwd=repository, text=True
+    ).strip()
+    with tempfile.TemporaryDirectory(prefix="submission-", dir=output.parent) as directory:
+        temporary = Path(directory)
+        env = {**os.environ, "GIT_INDEX_FILE": str(temporary / "index")}
+        for arguments in (["read-tree", base], ["add", "--all", "--", "."]):
+            subprocess.run(["git", *arguments], cwd=repository, env=env, check=True)
+        patch = temporary / "patch"
+        size = 0
+        digest = hashlib.sha256()
+        with (
+            patch.open("wb") as stream,
+            tempfile.TemporaryFile() as errors,
+            subprocess.Popen(
+                [
+                    "git",
+                    "diff",
+                    "--cached",
+                    "--binary",
+                    "--full-index",
+                    "--no-renames",
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-color",
+                    "--src-prefix=a/",
+                    "--dst-prefix=b/",
+                    base,
+                ],
+                cwd=repository,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=errors,
+            ) as process,
+        ):
+            assert process.stdout is not None
+            try:
+                while chunk := process.stdout.read(65536):
+                    size += len(chunk)
+                    if size > max_bytes:
+                        raise ValueError(f"Submission exceeds {max_bytes} bytes")
+                    stream.write(chunk)
+                    digest.update(chunk)
+            except BaseException:
+                process.kill()
+                process.wait()
+                raise
+            if process.wait():
+                errors.seek(0)
+                raise RuntimeError(
+                    "Git patch capture failed: " + errors.read(4096).decode(errors="replace")
+                )
+        patch.replace(output)
+    return {
+        "bytes": size,
+        "sha256": digest.hexdigest(),
+        "base_commit": base,
+        "format": "git-binary-v1",
+    }
+
+
+def submission_command(*, max_bytes: int = MAX_SUBMISSION_BYTES) -> str:
+    """Build the trusted command recorded before Harbor collects artifacts.
+
+    Parameters
+    ----------
+    max_bytes : int, default: 33554432
+        Maximum emitted patch bytes.
+
+    Returns
+    -------
+    str
+        Shell command carrying this exact helper into the solver runtime.
+
+    Raises
+    ------
+    ValueError
+        If the size limit is invalid.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    return "python -c " + shlex.quote(Path(__file__).read_text()) + f" --max-bytes {max_bytes}"
+
+
+def main() -> None:
+    """Capture the submission and print its identity as trial evidence."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repository", type=Path, default=Path("/testbed"))
+    parser.add_argument("--output", type=Path, default=Path("/workspace/submitted.patch"))
+    parser.add_argument("--max-bytes", type=int, default=MAX_SUBMISSION_BYTES)
+    args = parser.parse_args()
+    print(json.dumps(capture_submission(args.repository, args.output, max_bytes=args.max_bytes)))
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/environment/docker-compose.yaml

@@ -0,0 +1,11 @@
+services:
+  main:
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - type: tmpfs
+        target: /logs/verifier
+        tmpfs:
+          mode: 448
+          size: 1048576

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/environment/sanitize.py

@@ -0,0 +1,25 @@
+"""Remove private task assets and history when building the agent-only image."""
+
+import asyncio
+import os
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/app")
+from env import _setup  # noqa: E402
+
+asyncio.run(_setup())
+# The new history contains only the public baseline. Preserve a root-owned
+# copy so capture can ignore agent-controlled refs, hooks and Git configuration.
+shutil.copytree("/workspace/repo/.git", "/opt/task-tools/baseline.git")
+for path in Path("/opt/task-tools/baseline.git").rglob("*"):
+    os.chown(path, 0, 0)
+    path.chmod(0o755 if path.is_dir() else 0o644)
+for name in ("/hud", "/app", "/root/.cache", "/root/.hud"):
+    if Path(name).exists():
+        shutil.rmtree(name)
+# Capture runs on the base interpreter under one name, whatever the image calls it.
+os.symlink(os.path.realpath(sys.executable), "/opt/task-tools/python")
+Path("/workspace/submissions").mkdir()
+os.chown("/workspace/submissions", 1000, 1000)

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/instruction.md

@@ -0,0 +1,7 @@
+Please make your changes directly in /workspace/repo.
+
+# Ticket
+
+Every reported number covers the bytes or events it names, logical sizes in plain bytes, each entry observed at its own size; an admitted write never loses its space to a concurrent write, a reopening under the same limits, or the stored form's overhead; a directory always opens, dropping what no longer fits. Existing tests stay unchanged and green.
+
+Finish with a final response when your changes are ready.

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/solution/reference.patch

@@ -0,0 +1,445 @@
+diff --git a/cache/disk/accounting_test.go b/cache/disk/accounting_test.go
+new file mode 100644
+index 0000000..e2b40cd
+--- /dev/null
++++ b/cache/disk/accounting_test.go
+@@ -0,0 +1,229 @@
++package disk
++
++import (
++	"bytes"
++	"context"
++	"crypto/sha256"
++	"encoding/hex"
++	"io"
++	"math/rand"
++	"os"
++	"testing"
++	"time"
++
++	"github.com/buchgr/bazel-remote/v2/cache"
++	testutils "github.com/buchgr/bazel-remote/v2/utils"
++	dto "github.com/prometheus/client_model/go"
++)
++
++func accountingBlob(n int, seed int64) ([]byte, string) {
++	r := rand.New(rand.NewSource(seed))
++	b := make([]byte, n)
++	_, _ = r.Read(b)
++	sum := sha256.Sum256(b)
++	return b, hex.EncodeToString(sum[:])
++}
++
++func openAccountingCache(t *testing.T, dir string, maxSize int64, mode string) *diskCache {
++	t.Helper()
++	c, err := New(dir, maxSize, WithStorageMode(mode), WithAccessLogger(testutils.NewSilentLogger()))
++	if err != nil {
++		t.Fatal(err)
++	}
++	return c.(*diskCache)
++}
++
++func TestAdmittedBlobKeptDespiteStoredFormOverhead(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	maxSize := int64(8 * BlockSize)
++	c := openAccountingCache(t, dir, maxSize, "zstd")
++
++	data, hash := accountingBlob(int(maxSize), 1)
++	if err := c.Put(ctx, cache.CAS, hash, int64(len(data)), bytes.NewReader(data)); err != nil {
++		t.Fatalf("admitted blob was refused at commit: %v", err)
++	}
++	if ok, _ := c.Contains(ctx, cache.CAS, hash, int64(len(data))); !ok {
++		t.Fatal("admitted blob is not in the cache")
++	}
++
++	// A restart with the same limit keeps it.
++	c2 := openAccountingCache(t, dir, maxSize, "zstd")
++	rc, _, err := c2.Get(ctx, cache.CAS, hash, int64(len(data)), 0)
++	if err != nil || rc == nil {
++		t.Fatalf("admitted blob lost on restart: rc=%v err=%v", rc, err)
++	}
++	got, err := io.ReadAll(rc)
++	_ = rc.Close()
++	if err != nil || !bytes.Equal(got, data) {
++		t.Fatalf("admitted blob not served back after restart: %v", err)
++	}
++}
++
++type heldReader struct {
++	data             []byte
++	pos              int
++	started, release chan struct{}
++	once             bool
++}
++
++func (h *heldReader) Read(p []byte) (int, error) {
++	if !h.once {
++		h.once = true
++		close(h.started)
++	}
++	if h.pos < len(h.data) {
++		n := copy(p, h.data[h.pos:])
++		h.pos += n
++		return n, nil
++	}
++	<-h.release
++	return 0, io.EOF
++}
++
++func TestAdmittedBlobKeptDespiteBlockRounding(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	maxSize := int64(16 * BlockSize)
++	c := openAccountingCache(t, dir, maxSize, "uncompressed")
++
++	aData, aHash := accountingBlob(int(maxSize)-4097, 2)
++	hold := &heldReader{data: aData, started: make(chan struct{}), release: make(chan struct{})}
++	aDone := make(chan error, 1)
++	go func() { aDone <- c.Put(ctx, cache.CAS, aHash, int64(len(aData)), hold) }()
++	<-hold.started
++	for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(time.Millisecond) {
++		if _, reserved, _, _ := c.Stats(); reserved == int64(len(aData)) {
++			break
++		}
++		if time.Now().After(deadline) {
++			t.Fatal("reservation not visible")
++		}
++	}
++
++	bData, bHash := accountingBlob(4097, 3)
++	errB := c.Put(ctx, cache.CAS, bHash, int64(len(bData)), bytes.NewReader(bData))
++	close(hold.release)
++	if err := <-aDone; err != nil {
++		t.Fatal(err)
++	}
++	if errB != nil {
++		t.Fatalf("admitted blob was refused at commit: %v", errB)
++	}
++}
++
++func TestLoadDiscardsBlobsThatNoLongerFit(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 64*BlockSize, "uncompressed")
++	big, bigHash := accountingBlob(20000, 4)
++	if err := c.Put(ctx, cache.CAS, bigHash, int64(len(big)), bytes.NewReader(big)); err != nil {
++		t.Fatal(err)
++	}
++	small, smallHash := accountingBlob(1000, 5)
++	if err := c.Put(ctx, cache.RAW, smallHash, int64(len(small)), bytes.NewReader(small)); err != nil {
++		t.Fatal(err)
++	}
++
++	c2 := openAccountingCache(t, dir, 2*BlockSize, "uncompressed")
++	if ok, _ := c2.Contains(ctx, cache.CAS, bigHash, int64(len(big))); ok {
++		t.Fatal("oversized blob was not discarded")
++	}
++	if ok, _ := c2.Contains(ctx, cache.RAW, smallHash, int64(len(small))); !ok {
++		t.Fatal("blob that fits was not kept")
++	}
++	if _, _, n, _ := c2.Stats(); n != 1 {
++		t.Fatalf("expected 1 item, found %d", n)
++	}
++}
++
++func TestLogicalSizeInPlainBytes(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 64*BlockSize, "zstd")
++	acHash := hashStr("accounting-ac")
++	if err := c.Put(ctx, cache.AC, acHash, 100, bytes.NewReader(bytes.Repeat([]byte("a"), 100))); err != nil {
++		t.Fatal(err)
++	}
++	raw, rawHash := accountingBlob(1000, 6)
++	if err := c.Put(ctx, cache.RAW, rawHash, int64(len(raw)), bytes.NewReader(raw)); err != nil {
++		t.Fatal(err)
++	}
++	if err := c.Put(ctx, cache.AC, acHash, 50, bytes.NewReader(bytes.Repeat([]byte("b"), 50))); err != nil {
++		t.Fatal(err)
++	}
++	if _, _, _, logical := c.Stats(); logical != 1050 {
++		t.Fatalf("logical size %d, want 1050", logical)
++	}
++}
++
++func TestEvictedBytesCountOnlyEvictions(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 3*BlockSize, "uncompressed")
++	evicted := func() float64 {
++		var m dto.Metric
++		if err := c.lru.counterEvictedBytes.Write(&m); err != nil {
++			t.Fatal(err)
++		}
++		return m.GetCounter().GetValue()
++	}
++
++	data, hash := accountingBlob(BlockSize, 7)
++	if err := c.Put(ctx, cache.RAW, hash, int64(len(data)), bytes.NewReader(data)); err != nil {
++		t.Fatal(err)
++	}
++	key := cache.LookupKey(cache.RAW, hash)
++	item, _ := c.lru.Get(key)
++	if err := os.Remove(c.getElementPath(key, item)); err != nil {
++		t.Fatal(err)
++	}
++	if rc, _, _ := c.Get(ctx, cache.RAW, hash, int64(len(data)), 0); rc != nil {
++		t.Fatal("lost blob was served")
++	}
++	if got := evicted(); got != 0 {
++		t.Fatalf("evicted bytes %v after dropping a lost file", got)
++	}
++
++	for i := 0; i < 4; i++ {
++		d, h := accountingBlob(BlockSize, int64(10+i))
++		if err := c.Put(ctx, cache.RAW, h, int64(len(d)), bytes.NewReader(d)); err != nil {
++			t.Fatal(err)
++		}
++	}
++	if got := evicted(); got != BlockSize {
++		t.Fatalf("evicted bytes %v after one eviction, want %d", got, BlockSize)
++	}
++}
++
++func TestEntryBytesSummaryObservesEntrySize(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 64*BlockSize, "zstd")
++	hash := hashStr("accounting-summary")
++	body := bytes.Repeat([]byte("y"), 100)
++	for i := 0; i < 2; i++ {
++		if err := c.Put(ctx, cache.AC, hash, int64(len(body)), bytes.NewReader(body)); err != nil {
++			t.Fatal(err)
++		}
++	}
++	var m dto.Metric
++	if err := c.lru.summaryCacheItemBytes.Write(&m); err != nil {
++		t.Fatal(err)
++	}
++	if n, sum := m.GetSummary().GetSampleCount(), m.GetSummary().GetSampleSum(); n != 2 || sum != 200 {
++		t.Fatalf("entry bytes summary: %d observations summing to %v, want 2 of 100", n, sum)
++	}
++}
+diff --git a/cache/disk/disk.go b/cache/disk/disk.go
+index 4db928c..cb54739 100644
+--- a/cache/disk/disk.go
++++ b/cache/disk/disk.go
+@@ -429,7 +429,11 @@ func (c *diskCache) commit(key string, legacy bool, tempfile string, reservedSiz
+ 		random:     random,
+ 	}
+ 
+-	if !c.lru.Add(key, newItem) {
++	if reservedSize > 0 {
++		// Space for this blob was granted when it was reserved. That
++		// grant is not withdrawn now, whatever the stored form adds.
++		c.lru.AddAdmitted(key, newItem)
++	} else if !c.lru.Add(key, newItem) {
+ 		err = fmt.Errorf("INTERNAL ERROR: failed to add: %s, size %d (on disk: %d)",
+ 			key, logicalSize, sizeOnDisk)
+ 		log.Println(err.Error())
+diff --git a/cache/disk/load.go b/cache/disk/load.go
+index cab7f4e..b09d646 100644
+--- a/cache/disk/load.go
++++ b/cache/disk/load.go
+@@ -616,12 +616,25 @@ func (c *diskCache) loadExistingFiles(maxSizeBytes int64, cc CacheConfig) error
+ 	go c.lru.performQueuedEvictionsContinuously()
+ 
+ 	for i := 0; i < len(result.item); i++ {
+-		ok := c.lru.Add(result.metadata[i].lookupKey, *result.item[i])
+-		if !ok {
+-			err = os.Remove(filepath.Join(c.dir, result.metadata[i].lookupKey))
+-			if err != nil {
+-				return err
+-			}
++		key := result.metadata[i].lookupKey
++		item := *result.item[i]
++
++		// An existing file is kept if a request of its size would be
++		// granted space by this cache, i.e. by the same rule that
++		// admitted it in the first place.
++		if c.lru.Fits(item.size) {
++			c.lru.AddAdmitted(key, item)
++			continue
++		}
++
++		// It no longer fits (e.g. the cache was restarted with a lower
++		// max size): discard it and carry on loading.
++		f := c.getElementPath(key, item)
++		log.Printf("Removing %s (%d bytes), it does not fit in the cache (max size %d bytes).",
++			f, item.size, maxSizeBytes)
++		err = os.Remove(f)
++		if err != nil && !os.IsNotExist(err) {
++			return err
+ 		}
+ 	}
+ 
+diff --git a/cache/disk/lru.go b/cache/disk/lru.go
+index 7bc4997..faf058c 100644
+--- a/cache/disk/lru.go
++++ b/cache/disk/lru.go
+@@ -26,8 +26,8 @@ type SizedLRU struct {
+ 	// Total cache size including reserved bytes and estimated filesystem overhead.
+ 	currentSize int64
+ 
+-	// Total size of all blobs in uncompressed form.
+-	// This does not include reserved space.
++	// Total size of all blobs in uncompressed form, in plain bytes (not
++	// rounded up to BlockSize). This does not include reserved space.
+ 	uncompressedSize int64
+ 
+ 	// Number of bytes reserved for incoming blobs.
+@@ -188,47 +188,77 @@ func (c *SizedLRU) Add(key string, value lruItem) (ok bool) {
+ 	// time (unless Reserve method was used and evicted them).
+ 	c.calcTotalDiskSizeAndUpdatePeak(roundedUpSizeOnDisk)
+ 
+-	var sizeDelta, uncompressedSizeDelta int64
++	sizeDelta := roundedUpSizeOnDisk
+ 	if ee, ok := c.cache[key]; ok {
+-		sizeDelta = roundedUpSizeOnDisk - roundUp4k(ee.Value.(*entry).value.sizeOnDisk)
+-		if c.reservedSize+sizeDelta > c.maxSize {
+-			return false
+-		}
+-		uncompressedSizeDelta = roundUp4k(value.size) - roundUp4k(ee.Value.(*entry).value.size)
++		sizeDelta -= roundUp4k(ee.Value.(*entry).value.sizeOnDisk)
++	}
++	if c.reservedSize+sizeDelta > c.maxSize {
++		return false
++	}
++
++	c.insert(key, value)
++
++	return true
++}
++
++// AddAdmitted adds a (key, value) whose admission was already decided,
++// either because space for it was granted by Reserve (which the caller
++// must have released with Unreserve first), or because it is an existing
++// file that fits the cache by its logical size. It never rejects the item,
++// whatever its stored form adds on top of the logical size (block rounding,
++// compression headers): other items are evicted to make room, but never the
++// item itself, so the cache can temporarily exceed maxSize by that overhead.
++func (c *SizedLRU) AddAdmitted(key string, value lruItem) {
++	c.calcTotalDiskSizeAndUpdatePeak(roundUp4k(value.sizeOnDisk))
++	c.insert(key, value)
++}
++
++// Fits reports whether an item of the given logical size can be admitted,
++// using the same rule as Reserve.
++func (c *SizedLRU) Fits(logicalSize int64) bool {
++	return logicalSize >= 0 && logicalSize <= c.maxSize
++}
++
++// insert stores (key, value), replacing any existing value for key, and
++// then evicts least recently used items (never the inserted one) until the
++// cache is within maxSize again.
++func (c *SizedLRU) insert(key string, value lruItem) {
++	sizeDelta := roundUp4k(value.sizeOnDisk)
++	uncompressedSizeDelta := value.size
++
++	var ele *list.Element
++	if ee, ok := c.cache[key]; ok {
++		old := ee.Value.(*entry)
++		sizeDelta -= roundUp4k(old.value.sizeOnDisk)
++		uncompressedSizeDelta -= old.value.size
+ 		c.ll.MoveToFront(ee)
+-		c.counterOverwrittenBytes.Add(float64(ee.Value.(*entry).value.sizeOnDisk))
++		c.counterOverwrittenBytes.Add(float64(old.value.sizeOnDisk))
+ 
+-		kv := ee.Value.(*entry)
+-		kvCopy := &entry{kv.key, kv.value}
+-		c.appendEvictionToQueue(kvCopy)
++		// The replaced file still has to be removed from disk.
++		c.appendEvictionToQueue(&entry{old.key, old.value})
+ 
+-		ee.Value.(*entry).value = value
++		old.value = value
++		ele = ee
+ 	} else {
+-		sizeDelta = roundedUpSizeOnDisk
+-		if c.reservedSize+sizeDelta > c.maxSize {
+-			return false
+-		}
+-		uncompressedSizeDelta = roundUp4k(value.size)
+-		ele := c.ll.PushFront(&entry{key, value})
++		ele = c.ll.PushFront(&entry{key, value})
+ 		c.cache[key] = ele
+ 	}
+ 
++	c.currentSize += sizeDelta
++	c.uncompressedSize += uncompressedSizeDelta
++
+ 	// Eviction. This is needed even if the key was already present, since the size of the
+ 	// value might have changed, pushing the total size over maxSize.
+-	for c.currentSize+sizeDelta > c.maxSize {
+-		ele := c.ll.Back()
+-		if ele != nil {
+-			c.removeElement(ele)
++	for c.currentSize > c.maxSize {
++		back := c.ll.Back()
++		if back == nil || back == ele {
++			break
+ 		}
++		c.evictElement(back)
+ 	}
+ 
+-	c.currentSize += sizeDelta
+-	c.uncompressedSize += uncompressedSizeDelta
+-
+ 	c.gaugeCacheLogicalBytes.Set(float64(c.uncompressedSize))
+-	c.summaryCacheItemBytes.Observe(float64(sizeDelta))
+-
+-	return true
++	c.summaryCacheItemBytes.Observe(float64(value.sizeOnDisk))
+ }
+ 
+ // Get looks up a key in the cache. The lruItem is only valid if *list.Element is not nil.
+@@ -361,7 +391,7 @@ func (c *SizedLRU) Reserve(size int64) error {
+ 	for sumLargerThan(size, c.currentSize, c.maxSize) {
+ 		ele := c.ll.Back()
+ 		if ele != nil {
+-			c.removeElement(ele)
++			c.evictElement(ele)
+ 		} else {
+ 			return internalErr(errReservation) // This should have been caught at the start.
+ 		}
+@@ -394,16 +424,25 @@ func (c *SizedLRU) Unreserve(size int64) error {
+ 	return nil
+ }
+ 
++// removeElement drops an element from the index and queues its file for
++// removal. It is used both for evictions and for entries whose file was
++// lost or found to be corrupt; only evictElement counts as an eviction.
+ func (c *SizedLRU) removeElement(e *list.Element) {
+ 	c.ll.Remove(e)
+ 	kv := e.Value.(*entry)
+ 	delete(c.cache, kv.key)
+ 	c.currentSize -= roundUp4k(kv.value.sizeOnDisk)
+-	c.uncompressedSize -= roundUp4k(kv.value.size)
+-	c.counterEvictedBytes.Add(float64(kv.value.sizeOnDisk))
++	c.uncompressedSize -= kv.value.size
++	c.gaugeCacheLogicalBytes.Set(float64(c.uncompressedSize))
+ 	c.appendEvictionToQueue(kv)
+ }
+ 
++// evictElement removes an element to make room in a full cache.
++func (c *SizedLRU) evictElement(e *list.Element) {
++	c.counterEvictedBytes.Add(float64(e.Value.(*entry).value.sizeOnDisk))
++	c.removeElement(e)
++}
++
+ // Round n up to the nearest multiple of BlockSize (4096).
+ func roundUp4k(n int64) int64 {
+ 	return (n + BlockSize - 1) & -BlockSize

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/solution/solve.sh

@@ -0,0 +1,451 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/cache/disk/accounting_test.go b/cache/disk/accounting_test.go
+new file mode 100644
+index 0000000..e2b40cd
+--- /dev/null
++++ b/cache/disk/accounting_test.go
+@@ -0,0 +1,229 @@
++package disk
++
++import (
++	"bytes"
++	"context"
++	"crypto/sha256"
++	"encoding/hex"
++	"io"
++	"math/rand"
++	"os"
++	"testing"
++	"time"
++
++	"github.com/buchgr/bazel-remote/v2/cache"
++	testutils "github.com/buchgr/bazel-remote/v2/utils"
++	dto "github.com/prometheus/client_model/go"
++)
++
++func accountingBlob(n int, seed int64) ([]byte, string) {
++	r := rand.New(rand.NewSource(seed))
++	b := make([]byte, n)
++	_, _ = r.Read(b)
++	sum := sha256.Sum256(b)
++	return b, hex.EncodeToString(sum[:])
++}
++
++func openAccountingCache(t *testing.T, dir string, maxSize int64, mode string) *diskCache {
++	t.Helper()
++	c, err := New(dir, maxSize, WithStorageMode(mode), WithAccessLogger(testutils.NewSilentLogger()))
++	if err != nil {
++		t.Fatal(err)
++	}
++	return c.(*diskCache)
++}
++
++func TestAdmittedBlobKeptDespiteStoredFormOverhead(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	maxSize := int64(8 * BlockSize)
++	c := openAccountingCache(t, dir, maxSize, "zstd")
++
++	data, hash := accountingBlob(int(maxSize), 1)
++	if err := c.Put(ctx, cache.CAS, hash, int64(len(data)), bytes.NewReader(data)); err != nil {
++		t.Fatalf("admitted blob was refused at commit: %v", err)
++	}
++	if ok, _ := c.Contains(ctx, cache.CAS, hash, int64(len(data))); !ok {
++		t.Fatal("admitted blob is not in the cache")
++	}
++
++	// A restart with the same limit keeps it.
++	c2 := openAccountingCache(t, dir, maxSize, "zstd")
++	rc, _, err := c2.Get(ctx, cache.CAS, hash, int64(len(data)), 0)
++	if err != nil || rc == nil {
++		t.Fatalf("admitted blob lost on restart: rc=%v err=%v", rc, err)
++	}
++	got, err := io.ReadAll(rc)
++	_ = rc.Close()
++	if err != nil || !bytes.Equal(got, data) {
++		t.Fatalf("admitted blob not served back after restart: %v", err)
++	}
++}
++
++type heldReader struct {
++	data             []byte
++	pos              int
++	started, release chan struct{}
++	once             bool
++}
++
++func (h *heldReader) Read(p []byte) (int, error) {
++	if !h.once {
++		h.once = true
++		close(h.started)
++	}
++	if h.pos < len(h.data) {
++		n := copy(p, h.data[h.pos:])
++		h.pos += n
++		return n, nil
++	}
++	<-h.release
++	return 0, io.EOF
++}
++
++func TestAdmittedBlobKeptDespiteBlockRounding(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	maxSize := int64(16 * BlockSize)
++	c := openAccountingCache(t, dir, maxSize, "uncompressed")
++
++	aData, aHash := accountingBlob(int(maxSize)-4097, 2)
++	hold := &heldReader{data: aData, started: make(chan struct{}), release: make(chan struct{})}
++	aDone := make(chan error, 1)
++	go func() { aDone <- c.Put(ctx, cache.CAS, aHash, int64(len(aData)), hold) }()
++	<-hold.started
++	for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(time.Millisecond) {
++		if _, reserved, _, _ := c.Stats(); reserved == int64(len(aData)) {
++			break
++		}
++		if time.Now().After(deadline) {
++			t.Fatal("reservation not visible")
++		}
++	}
++
++	bData, bHash := accountingBlob(4097, 3)
++	errB := c.Put(ctx, cache.CAS, bHash, int64(len(bData)), bytes.NewReader(bData))
++	close(hold.release)
++	if err := <-aDone; err != nil {
++		t.Fatal(err)
++	}
++	if errB != nil {
++		t.Fatalf("admitted blob was refused at commit: %v", errB)
++	}
++}
++
++func TestLoadDiscardsBlobsThatNoLongerFit(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 64*BlockSize, "uncompressed")
++	big, bigHash := accountingBlob(20000, 4)
++	if err := c.Put(ctx, cache.CAS, bigHash, int64(len(big)), bytes.NewReader(big)); err != nil {
++		t.Fatal(err)
++	}
++	small, smallHash := accountingBlob(1000, 5)
++	if err := c.Put(ctx, cache.RAW, smallHash, int64(len(small)), bytes.NewReader(small)); err != nil {
++		t.Fatal(err)
++	}
++
++	c2 := openAccountingCache(t, dir, 2*BlockSize, "uncompressed")
++	if ok, _ := c2.Contains(ctx, cache.CAS, bigHash, int64(len(big))); ok {
++		t.Fatal("oversized blob was not discarded")
++	}
++	if ok, _ := c2.Contains(ctx, cache.RAW, smallHash, int64(len(small))); !ok {
++		t.Fatal("blob that fits was not kept")
++	}
++	if _, _, n, _ := c2.Stats(); n != 1 {
++		t.Fatalf("expected 1 item, found %d", n)
++	}
++}
++
++func TestLogicalSizeInPlainBytes(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 64*BlockSize, "zstd")
++	acHash := hashStr("accounting-ac")
++	if err := c.Put(ctx, cache.AC, acHash, 100, bytes.NewReader(bytes.Repeat([]byte("a"), 100))); err != nil {
++		t.Fatal(err)
++	}
++	raw, rawHash := accountingBlob(1000, 6)
++	if err := c.Put(ctx, cache.RAW, rawHash, int64(len(raw)), bytes.NewReader(raw)); err != nil {
++		t.Fatal(err)
++	}
++	if err := c.Put(ctx, cache.AC, acHash, 50, bytes.NewReader(bytes.Repeat([]byte("b"), 50))); err != nil {
++		t.Fatal(err)
++	}
++	if _, _, _, logical := c.Stats(); logical != 1050 {
++		t.Fatalf("logical size %d, want 1050", logical)
++	}
++}
++
++func TestEvictedBytesCountOnlyEvictions(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 3*BlockSize, "uncompressed")
++	evicted := func() float64 {
++		var m dto.Metric
++		if err := c.lru.counterEvictedBytes.Write(&m); err != nil {
++			t.Fatal(err)
++		}
++		return m.GetCounter().GetValue()
++	}
++
++	data, hash := accountingBlob(BlockSize, 7)
++	if err := c.Put(ctx, cache.RAW, hash, int64(len(data)), bytes.NewReader(data)); err != nil {
++		t.Fatal(err)
++	}
++	key := cache.LookupKey(cache.RAW, hash)
++	item, _ := c.lru.Get(key)
++	if err := os.Remove(c.getElementPath(key, item)); err != nil {
++		t.Fatal(err)
++	}
++	if rc, _, _ := c.Get(ctx, cache.RAW, hash, int64(len(data)), 0); rc != nil {
++		t.Fatal("lost blob was served")
++	}
++	if got := evicted(); got != 0 {
++		t.Fatalf("evicted bytes %v after dropping a lost file", got)
++	}
++
++	for i := 0; i < 4; i++ {
++		d, h := accountingBlob(BlockSize, int64(10+i))
++		if err := c.Put(ctx, cache.RAW, h, int64(len(d)), bytes.NewReader(d)); err != nil {
++			t.Fatal(err)
++		}
++	}
++	if got := evicted(); got != BlockSize {
++		t.Fatalf("evicted bytes %v after one eviction, want %d", got, BlockSize)
++	}
++}
++
++func TestEntryBytesSummaryObservesEntrySize(t *testing.T) {
++	ctx := context.Background()
++	dir := testutils.TempDir(t)
++	defer func() { _ = os.RemoveAll(dir) }()
++
++	c := openAccountingCache(t, dir, 64*BlockSize, "zstd")
++	hash := hashStr("accounting-summary")
++	body := bytes.Repeat([]byte("y"), 100)
++	for i := 0; i < 2; i++ {
++		if err := c.Put(ctx, cache.AC, hash, int64(len(body)), bytes.NewReader(body)); err != nil {
++			t.Fatal(err)
++		}
++	}
++	var m dto.Metric
++	if err := c.lru.summaryCacheItemBytes.Write(&m); err != nil {
++		t.Fatal(err)
++	}
++	if n, sum := m.GetSummary().GetSampleCount(), m.GetSummary().GetSampleSum(); n != 2 || sum != 200 {
++		t.Fatalf("entry bytes summary: %d observations summing to %v, want 2 of 100", n, sum)
++	}
++}
+diff --git a/cache/disk/disk.go b/cache/disk/disk.go
+index 4db928c..cb54739 100644
+--- a/cache/disk/disk.go
++++ b/cache/disk/disk.go
+@@ -429,7 +429,11 @@ func (c *diskCache) commit(key string, legacy bool, tempfile string, reservedSiz
+ 		random:     random,
+ 	}
+ 
+-	if !c.lru.Add(key, newItem) {
++	if reservedSize > 0 {
++		// Space for this blob was granted when it was reserved. That
++		// grant is not withdrawn now, whatever the stored form adds.
++		c.lru.AddAdmitted(key, newItem)
++	} else if !c.lru.Add(key, newItem) {
+ 		err = fmt.Errorf("INTERNAL ERROR: failed to add: %s, size %d (on disk: %d)",
+ 			key, logicalSize, sizeOnDisk)
+ 		log.Println(err.Error())
+diff --git a/cache/disk/load.go b/cache/disk/load.go
+index cab7f4e..b09d646 100644
+--- a/cache/disk/load.go
++++ b/cache/disk/load.go
+@@ -616,12 +616,25 @@ func (c *diskCache) loadExistingFiles(maxSizeBytes int64, cc CacheConfig) error
+ 	go c.lru.performQueuedEvictionsContinuously()
+ 
+ 	for i := 0; i < len(result.item); i++ {
+-		ok := c.lru.Add(result.metadata[i].lookupKey, *result.item[i])
+-		if !ok {
+-			err = os.Remove(filepath.Join(c.dir, result.metadata[i].lookupKey))
+-			if err != nil {
+-				return err
+-			}
++		key := result.metadata[i].lookupKey
++		item := *result.item[i]
++
++		// An existing file is kept if a request of its size would be
++		// granted space by this cache, i.e. by the same rule that
++		// admitted it in the first place.
++		if c.lru.Fits(item.size) {
++			c.lru.AddAdmitted(key, item)
++			continue
++		}
++
++		// It no longer fits (e.g. the cache was restarted with a lower
++		// max size): discard it and carry on loading.
++		f := c.getElementPath(key, item)
++		log.Printf("Removing %s (%d bytes), it does not fit in the cache (max size %d bytes).",
++			f, item.size, maxSizeBytes)
++		err = os.Remove(f)
++		if err != nil && !os.IsNotExist(err) {
++			return err
+ 		}
+ 	}
+ 
+diff --git a/cache/disk/lru.go b/cache/disk/lru.go
+index 7bc4997..faf058c 100644
+--- a/cache/disk/lru.go
++++ b/cache/disk/lru.go
+@@ -26,8 +26,8 @@ type SizedLRU struct {
+ 	// Total cache size including reserved bytes and estimated filesystem overhead.
+ 	currentSize int64
+ 
+-	// Total size of all blobs in uncompressed form.
+-	// This does not include reserved space.
++	// Total size of all blobs in uncompressed form, in plain bytes (not
++	// rounded up to BlockSize). This does not include reserved space.
+ 	uncompressedSize int64
+ 
+ 	// Number of bytes reserved for incoming blobs.
+@@ -188,47 +188,77 @@ func (c *SizedLRU) Add(key string, value lruItem) (ok bool) {
+ 	// time (unless Reserve method was used and evicted them).
+ 	c.calcTotalDiskSizeAndUpdatePeak(roundedUpSizeOnDisk)
+ 
+-	var sizeDelta, uncompressedSizeDelta int64
++	sizeDelta := roundedUpSizeOnDisk
+ 	if ee, ok := c.cache[key]; ok {
+-		sizeDelta = roundedUpSizeOnDisk - roundUp4k(ee.Value.(*entry).value.sizeOnDisk)
+-		if c.reservedSize+sizeDelta > c.maxSize {
+-			return false
+-		}
+-		uncompressedSizeDelta = roundUp4k(value.size) - roundUp4k(ee.Value.(*entry).value.size)
++		sizeDelta -= roundUp4k(ee.Value.(*entry).value.sizeOnDisk)
++	}
++	if c.reservedSize+sizeDelta > c.maxSize {
++		return false
++	}
++
++	c.insert(key, value)
++
++	return true
++}
++
++// AddAdmitted adds a (key, value) whose admission was already decided,
++// either because space for it was granted by Reserve (which the caller
++// must have released with Unreserve first), or because it is an existing
++// file that fits the cache by its logical size. It never rejects the item,
++// whatever its stored form adds on top of the logical size (block rounding,
++// compression headers): other items are evicted to make room, but never the
++// item itself, so the cache can temporarily exceed maxSize by that overhead.
++func (c *SizedLRU) AddAdmitted(key string, value lruItem) {
++	c.calcTotalDiskSizeAndUpdatePeak(roundUp4k(value.sizeOnDisk))
++	c.insert(key, value)
++}
++
++// Fits reports whether an item of the given logical size can be admitted,
++// using the same rule as Reserve.
++func (c *SizedLRU) Fits(logicalSize int64) bool {
++	return logicalSize >= 0 && logicalSize <= c.maxSize
++}
++
++// insert stores (key, value), replacing any existing value for key, and
++// then evicts least recently used items (never the inserted one) until the
++// cache is within maxSize again.
++func (c *SizedLRU) insert(key string, value lruItem) {
++	sizeDelta := roundUp4k(value.sizeOnDisk)
++	uncompressedSizeDelta := value.size
++
++	var ele *list.Element
++	if ee, ok := c.cache[key]; ok {
++		old := ee.Value.(*entry)
++		sizeDelta -= roundUp4k(old.value.sizeOnDisk)
++		uncompressedSizeDelta -= old.value.size
+ 		c.ll.MoveToFront(ee)
+-		c.counterOverwrittenBytes.Add(float64(ee.Value.(*entry).value.sizeOnDisk))
++		c.counterOverwrittenBytes.Add(float64(old.value.sizeOnDisk))
+ 
+-		kv := ee.Value.(*entry)
+-		kvCopy := &entry{kv.key, kv.value}
+-		c.appendEvictionToQueue(kvCopy)
++		// The replaced file still has to be removed from disk.
++		c.appendEvictionToQueue(&entry{old.key, old.value})
+ 
+-		ee.Value.(*entry).value = value
++		old.value = value
++		ele = ee
+ 	} else {
+-		sizeDelta = roundedUpSizeOnDisk
+-		if c.reservedSize+sizeDelta > c.maxSize {
+-			return false
+-		}
+-		uncompressedSizeDelta = roundUp4k(value.size)
+-		ele := c.ll.PushFront(&entry{key, value})
++		ele = c.ll.PushFront(&entry{key, value})
+ 		c.cache[key] = ele
+ 	}
+ 
++	c.currentSize += sizeDelta
++	c.uncompressedSize += uncompressedSizeDelta
++
+ 	// Eviction. This is needed even if the key was already present, since the size of the
+ 	// value might have changed, pushing the total size over maxSize.
+-	for c.currentSize+sizeDelta > c.maxSize {
+-		ele := c.ll.Back()
+-		if ele != nil {
+-			c.removeElement(ele)
++	for c.currentSize > c.maxSize {
++		back := c.ll.Back()
++		if back == nil || back == ele {
++			break
+ 		}
++		c.evictElement(back)
+ 	}
+ 
+-	c.currentSize += sizeDelta
+-	c.uncompressedSize += uncompressedSizeDelta
+-
+ 	c.gaugeCacheLogicalBytes.Set(float64(c.uncompressedSize))
+-	c.summaryCacheItemBytes.Observe(float64(sizeDelta))
+-
+-	return true
++	c.summaryCacheItemBytes.Observe(float64(value.sizeOnDisk))
+ }
+ 
+ // Get looks up a key in the cache. The lruItem is only valid if *list.Element is not nil.
+@@ -361,7 +391,7 @@ func (c *SizedLRU) Reserve(size int64) error {
+ 	for sumLargerThan(size, c.currentSize, c.maxSize) {
+ 		ele := c.ll.Back()
+ 		if ele != nil {
+-			c.removeElement(ele)
++			c.evictElement(ele)
+ 		} else {
+ 			return internalErr(errReservation) // This should have been caught at the start.
+ 		}
+@@ -394,16 +424,25 @@ func (c *SizedLRU) Unreserve(size int64) error {
+ 	return nil
+ }
+ 
++// removeElement drops an element from the index and queues its file for
++// removal. It is used both for evictions and for entries whose file was
++// lost or found to be corrupt; only evictElement counts as an eviction.
+ func (c *SizedLRU) removeElement(e *list.Element) {
+ 	c.ll.Remove(e)
+ 	kv := e.Value.(*entry)
+ 	delete(c.cache, kv.key)
+ 	c.currentSize -= roundUp4k(kv.value.sizeOnDisk)
+-	c.uncompressedSize -= roundUp4k(kv.value.size)
+-	c.counterEvictedBytes.Add(float64(kv.value.sizeOnDisk))
++	c.uncompressedSize -= kv.value.size
++	c.gaugeCacheLogicalBytes.Set(float64(c.uncompressedSize))
+ 	c.appendEvictionToQueue(kv)
+ }
+ 
++// evictElement removes an element to make room in a full cache.
++func (c *SizedLRU) evictElement(e *list.Element) {
++	c.counterEvictedBytes.Add(float64(e.Value.(*entry).value.sizeOnDisk))
++	c.removeElement(e)
++}
++
+ // Round n up to the nearest multiple of BlockSize (4096).
+ func roundUp4k(n int64) int64 {
+ 	return (n + BlockSize - 1) & -BlockSize
+
+REFERENCE_PATCH

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "bazel_remote_disk_eviction_accounting_contract"
+validation_revision = "coding-rubric-v2"
+[agent]
+timeout_sec = 1800
+user = "1000:1000"
+[environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[verifier]
+timeout_sec = 7200
+user = "0"
+environment_mode = "separate"
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/tests/Dockerfile

@@ -0,0 +1,9 @@
+FROM ec-swe-bazel-remote:source-v2
+USER root
+RUN grep -q '^[^:]*:[^:]*:1000:' /etc/passwd || echo 'grader:x:1000:1000::/tmp/agent-home:/bin/sh' >> /etc/passwd; grep -q '^[^:]*:[^:]*:1000:' /etc/group || echo 'grader:x:1000:' >> /etc/group
+ENV HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 HUD_FILE_TRACKING_ENABLED=false
+RUN rm -f /hud/gold.diff
+COPY verify.py evidence.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/tests/config.json

@@ -0,0 +1,122 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "bazel_remote_disk_eviction_accounting_contract",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-bazel-remote:source-v2",
+  "source_image_id": "sha256:c1f0073e7b8a86bda5151303cf107f15fc5fda5b5469543413ab37887baf10cf",
+  "provenance": {
+    "repository": "buchgr/bazel-remote",
+    "environment_id": "66517a55-2b44-4cd7-9ff1-3a059e8ccc03",
+    "build": 2,
+    "build_id": "0e4083f4-d1f1-4e8f-9343-56cdb78655af",
+    "hosted_task": "bazel_remote_disk_eviction_accounting_contract-afe5ea56",
+    "task_version": 1,
+    "source_archive_sha256": "4c42b091fdd5702a54d9a306f14f0e8b774b8daa6e7f81e9021ac8619cf60772",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "admitted_blob_survives_restart_with_the_same_limits",
+      0.27,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "admitted_blob_is_kept_despite_stored_form_overhead",
+      0.27,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "admitted_blob_is_kept_despite_block_rounding_under_concurrent_reservation",
+      0.09,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "cache_dir_with_oversized_blob_still_loads_and_discards_it",
+      0.09,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "logical_size_is_reported_in_plain_bytes",
+      0.09,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "evicted_bytes_counter_ignores_lost_files",
+      0.09,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "entry_size_summary_observes_each_entry_size",
+      0.09,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "gate_repo_suite_green_and_tests_untouched",
+      0.01,
+      true,
+      "bash",
+      900
+    ]
+  ],
+  "gates": [],
+  "reward_rule": "weighted_cap",
+  "local_hostname": false,
+  "fault_exit": 3,
+  "grader_readable": [],
+  "grader_writable": [],
+  "blocker_cap": 0.6,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/env.py": "2ba1517a839fd7b38b3f9e701ef4741351e3b3c3f577eb4a56a65946ffc956c5",
+    "/app/tasks.py": "d7e4325c619978a106a8a61e30b8db95e9aa25ce10e234c0479ee317916bbe47",
+    "/app/coding/github.py": "dfb450735dd44af94d51088ccd37df0470a4bf7c1339f5277aea2419bd64c694",
+    "/app/coding/repo.py": "b1366540d1ea28ccb7cc578a311662ef4a2b9e7e5a4c27543dcbd594cc6d86da",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/task/prompt.md": "9518d37eeeed2f588b5dc636f6588283863f56f975aa9af9df3281316065b8dd",
+    "/hud/grader/run_grading.sh": "344e3b6df0af414c9a49287a333e2d79ed25da263dccc76718bc6dc15c0d1448",
+    "/hud/grader/controls/alt.diff": "43162609826d241f9faf52830f446f4bc6d78b67b0ff8d6bcb9c4a22855ad2d0",
+    "/hud/grader/controls/cheat.diff": "9dbe991b917ff847efea11cb31dff05ad9a6df9f1f0c9c1cfaffb60535312722",
+    "/hud/grader/controls/lazy.diff": "2a15431225ec43bf4b70ea490ee83669886f455da71a3ab6ed01f47c7a4d915f",
+    "/hud/grader/harness/suite_gate.py": "c2fe01b49f83cf4d28ee0ab36b42285f2e6c205ca45003d82a9d3d29c5b36b8d",
+    "/hud/grader/harness/spec/cells_test.go": "de51528d91ed7b44452861c036e782a66df838bfbc6748abccaed1ab704cf195"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'go version' || go version"
+    ],
+    [
+      "/usr/local/bin/python3",
+      "--version"
+    ]
+  ]
+}

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/tests/docker-compose.yaml

@@ -0,0 +1,6 @@
+services:
+  main:
+    network_mode: none
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/tests/evidence.py

@@ -0,0 +1,123 @@
+"""Validate complete coding-rubric evidence without importing the grader library or Harbor."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+REVISION = "coding-rubric-v2"
+
+
+def _number(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise ValueError("Expected numeric rubric evidence")
+    if not math.isfinite(value) or not 0 <= value <= 1:
+        raise ValueError("Rubric values must be finite and within [0, 1]")
+    return float(value)
+
+
+def validate_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check provenance, criterion coverage, weights, caps and command outcomes.
+
+    Parameters
+    ----------
+    report, config : dict
+        Fresh verifier evidence and the trusted prepared task configuration.
+    digest : str
+        SHA-256 of the submission collected by Harbor.
+
+    Raises
+    ------
+    ValueError
+        If evidence is missing, inconsistent or reports infrastructure failure.
+    """
+    if (
+        report.get("revision") != REVISION
+        or report.get("task_id") != config["task_id"]
+        or report.get("patch_sha256") != digest
+        or report.get("grader_version") != config["grader_version"]
+    ):
+        raise ValueError("Verifier evidence provenance mismatch")
+    result = report.get("result", {})
+    reward = _number(result.get("reward"))
+    # A rubric may flag its own result when a grader could not judge. That is
+    # admitted only together with proof, checked below, that the same grader
+    # reaches a verdict on the untouched repository.
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in report.get("commands", [])
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    flagged = result.get("isError", False)
+    if (flagged and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    status = report.get("status")
+    if status == "rejected_patch":
+        if reward != 0 or not report.get("patch_error") or result.get("subscores"):
+            raise ValueError("Invalid rejected-patch evidence")
+        return
+    if status == "empty_patch":
+        credited = any(_number(row["value"]) for row in result.get("subscores") or [])
+        if reward != 0 or digest != config["empty_sha256"] or report.get("commands") or credited:
+            raise ValueError("Invalid empty-patch evidence")
+        return
+    if status != "graded":
+        raise ValueError("Verifier did not complete")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    if not isinstance(scores, list) or len(scores) != len(expected):
+        raise ValueError("Missing rubric criteria")
+    names = [row["name"] for row in scores]
+    if len(set(names)) != len(names) or set(names) != set(expected):
+        raise ValueError("Duplicate or unexpected rubric criteria")
+    raw = 0.0
+    values = {}
+    for score in scores:
+        name = score["name"]
+        value, weight = _number(score["value"]), _number(score["weight"])
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    commands = report.get("commands", [])
+    command_names = [row["name"] for row in commands]
+    expected_commands = set(expected) | set(config["gates"])
+    if len(command_names) != len(set(command_names)) or set(command_names) != expected_commands:
+        raise ValueError("Missing or duplicate grader command evidence")
+    for command in commands:
+        info = command.get("info") or {}
+        code = info.get("exit_code")
+        verdict = type(code) is int and (code in (0, 1) or command["name"] in faults)
+        if not verdict or info.get("timed_out"):
+            raise ValueError("Grader command failed outside its verdict contract")
+        if _number(command["value"]) != float(code == 0):
+            raise ValueError("Command exit code disagrees with score")
+    probes = {row["name"]: row for row in report.get("fault_probes") or []}
+    if set(probes) != faults or any(
+        row.get("timed_out") or row.get("exit_code") not in (0, 1) for row in probes.values()
+    ):
+        raise ValueError(
+            "A grader could not judge and the untouched repository does not explain it"
+        )
+    if any(values.get(name, 0) for name in faults):
+        raise ValueError("A criterion its grader could not judge is credited")
+    info = result.get("info") or {}
+    if info.get("aggregate_mismatch") or info.get("git_apply"):
+        raise ValueError("Grader reported inconsistent grading")
+    if config.get("reward_rule") == "authored":
+        # The task's own function decides the reward. It may take credit away
+        # (a cap, a criterion that pays only with progress) but never add any.
+        passed = {row["name"]: row["value"] for row in commands}
+        if any(values[name] > passed[name] for name in expected):
+            raise ValueError("A criterion is credited although its command failed")
+        if reward > raw + 1e-9:
+            raise ValueError("Grader reward exceeds its weighted criteria")
+        return
+    failed = {name for name, row in expected.items() if row[2] and values[name] < 1}
+    gate_failed = {
+        row["name"] for row in commands if row["name"] in config["gates"] and row["value"] < 1
+    }
+    expected_reward = min(raw, config["blocker_cap"]) if failed or gate_failed else raw
+    if not math.isclose(reward, expected_reward, abs_tol=1e-9):
+        raise ValueError("Grader reward disagrees with original weights and blocker cap")

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/tests/test.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+/opt/hudvenv/bin/python /tests/verify.py

harbor/tasks/bazel_remote_disk_eviction_accounting_contract/tests/verify.py

@@ -0,0 +1,235 @@
+"""Run the original trusted coding rubric in a fresh, offline verifier container."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from evidence import REVISION, validate_report
+
+OUT = Path("/logs/verifier")
+PRIVATE = Path("/var/lib/task-evidence")
+CONFIG = Path("/tests/config.json")
+PATCH = Path("/workspace/submissions/submitted.patch")
+GRADER_HOME = "/tmp/agent-home"
+
+
+def _run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(command, text=True, capture_output=True, timeout=300, **kwargs)
+
+
+def _preflight(config: dict[str, Any]) -> None:
+    if importlib.metadata.version("hud") != config["grader_version"]:
+        raise RuntimeError("Grader library version does not match the task")
+    for filename, expected in config["verifier_files"].items():
+        if hashlib.sha256(Path(filename).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"Verifier source changed: {filename}")
+    for command in config["preflight"]:
+        completed = _run(command, cwd="/workspace/repo")
+        if completed.returncode:
+            raise RuntimeError(f"Prerequisite failed: {command}: {completed.stderr[-2000:]}")
+
+
+def _readable_mode(path: Path) -> int:
+    # World-readable, keeping what is executable so: a grader may ship tools.
+    return 0o755 if path.is_dir() or path.stat().st_mode & 0o111 else 0o644
+
+
+def _permissions() -> None:
+    # The orchestrator owns reports and rubric definitions. Grader commands,
+    # and so the candidate's code, run as uid 1000: the user the task installed
+    # its toolchain and caches for. They cannot read gold/vault or overwrite
+    # the rubric or the result files, which stay root's.
+    Path("/hud").chmod(0o711)
+    for root in (Path("/hud/grader"), Path("/hud/base"), Path("/hud/base-src")):
+        if root.exists():
+            root.chmod(0o755)
+            for path in root.rglob("*"):
+                if not path.is_symlink():
+                    path.chmod(_readable_mode(path))
+    home = Path(GRADER_HOME)
+    home.mkdir(parents=True, exist_ok=True)
+    os.chown(home, 1000, 1000)
+    for directory in ("/hud/logs", "/hud/gocache", "/hud/grader/runner"):
+        path = Path(directory)
+        path.mkdir(parents=True, exist_ok=True)
+        for item in (path, *path.rglob("*")):
+            if not item.is_symlink():
+                os.chown(item, 1000, 1000)
+                item.chmod(_readable_mode(item))
+
+
+def _hand_over_checkout() -> None:
+    # The original grader runs as root and may run the candidate's own suite in
+    # place, which writes into the tree. The rubric resets and re-applies the
+    # candidate as root, so give what root touched back to the grading user.
+    # Installed dependency trees are large and already that user's.
+    subprocess.run(
+        [
+            "find",
+            "/workspace/repo",
+            "-path",
+            "*/node_modules",
+            "-prune",
+            "-o",
+            "!",
+            "-user",
+            "1000",
+            "-exec",
+            "chown",
+            "-h",
+            "1000:1000",
+            "{}",
+            "+",
+        ],
+        check=True,
+        capture_output=True,
+        timeout=3600,
+    )
+
+
+async def _grade(config: dict[str, Any], record: dict[str, Any]) -> None:
+    _preflight(config)
+    sys.path.insert(0, "/app")
+    task: Any = importlib.import_module("tasks")
+    await task._setup()
+    _permissions()
+    patch = PATCH.read_bytes()
+    if patch:
+        checked = _run(["git", "apply", "--check", str(PATCH)], cwd="/workspace/repo")
+        if checked.returncode:
+            record.update(
+                status="rejected_patch",
+                patch_error=checked.stderr[-4000:],
+                result={"reward": 0.0, "subscores": None},
+            )
+            return
+        _run(["git", "apply", str(PATCH)], cwd="/workspace/repo", check=True)
+    original = task.BashGrader
+    fault_exit = config.get("fault_exit")
+    faulted: list[tuple[tuple[Any, ...], dict[str, Any], str]] = []
+
+    class ObservedGrader:
+        @classmethod
+        async def grade(cls, *args: Any, **kwargs: Any) -> Any:
+            command = kwargs["command"]
+            _hand_over_checkout()
+            kwargs["command"] = (
+                "setpriv --reuid 1000 --regid 1000 --clear-groups --no-new-privs "
+                f"env HOME={GRADER_HOME} bash -lc " + shlex.quote(command)
+            )
+            score = await original.grade(*args, **kwargs)
+            snapshot = score.model_dump(mode="json")
+            record["commands"].append(snapshot)
+            (PRIVATE / "commands.json").write_text(json.dumps(record["commands"], indent=2))
+            info = snapshot.get("info") or {}
+            if info.get("timed_out") or type(info.get("exit_code")) is not int:
+                raise RuntimeError(f"Grader infrastructure failure: {snapshot['name']}")
+            if fault_exit is not None and info["exit_code"] == fault_exit:
+                # The grader says it could not judge. Whether the submission or
+                # the environment is the reason is settled after grading.
+                faulted.append((args, dict(kwargs), snapshot["name"]))
+            elif info["exit_code"] not in (0, 1):
+                raise RuntimeError(f"Grader command exit {info['exit_code']}: {snapshot['name']}")
+            return score
+
+    task.BashGrader = ObservedGrader
+    result = await task._grade(None)
+    if faulted:
+        # Ask the same commands about the untouched repository. A verdict there
+        # means the grader works here and the submission is what it could not
+        # judge, so the criterion stays unmet. No verdict there means the
+        # environment is at fault, and the attempt is invalid.
+        await task.repo_lib.git(task.REPO_DIR, "reset", "--hard", "HEAD")
+        await task.repo_lib.git(task.REPO_DIR, "clean", "-fd")
+        # Graders keep state between criteria, some of them a copy of the tree
+        # they judged. It describes the submission, so it goes too.
+        for leftover in Path(getattr(task, "LOGS_DIR", "/hud/logs")).iterdir():
+            if leftover.is_dir() and not leftover.is_symlink():
+                shutil.rmtree(leftover)
+            else:
+                leftover.unlink()
+        record["fault_probes"] = []
+        for args, kwargs, name in faulted:
+            _hand_over_checkout()
+            probe = (await original.grade(*args, **kwargs)).model_dump(mode="json")
+            info = probe.get("info") or {}
+            record["fault_probes"].append(
+                {
+                    "name": name,
+                    "exit_code": info.get("exit_code"),
+                    "timed_out": info.get("timed_out"),
+                    "stdout": (info.get("stdout") or "")[-2000:],
+                }
+            )
+            (PRIVATE / "fault_probes.json").write_text(json.dumps(record["fault_probes"], indent=2))
+            if info.get("timed_out") or info.get("exit_code") not in (0, 1):
+                raise RuntimeError(f"Grader cannot judge the untouched repository: {name}")
+    record["result"] = result.model_dump(mode="json")
+    # A rubric may answer an empty change without running any criterion.
+    record["status"] = "empty_patch" if not patch and not record["commands"] else "graded"
+
+
+def _stop_candidate_processes() -> None:
+    # A candidate may fork. End its UID's processes before publishing evidence
+    # to a host bind mount, whose permissions may differ on Docker Desktop.
+    for directory in Path("/proc").iterdir():
+        if not directory.name.isdecimal():
+            continue
+        try:
+            status = (directory / "status").read_text()
+            uid = next(line.split()[1] for line in status.splitlines() if line.startswith("Uid:"))
+            if uid == "1000":
+                os.kill(int(directory.name), signal.SIGKILL)
+        except (FileNotFoundError, ProcessLookupError):
+            pass
+
+
+def main() -> None:
+    """Persist structured evidence and publish reward only after validation."""
+    OUT.mkdir(parents=True, exist_ok=True)
+    PRIVATE.mkdir(parents=True, exist_ok=True, mode=0o700)
+    PRIVATE.chmod(0o700)
+    reward_path = OUT / "reward.txt"
+    reward_path.unlink(missing_ok=True)
+    config = json.loads(CONFIG.read_text())
+    shutil.copy2(CONFIG, OUT / "config.json")
+    record: dict[str, Any] = {
+        "revision": REVISION,
+        "task_id": config["task_id"],
+        "grader_version": importlib.metadata.version("hud"),
+        "commands": [],
+        "status": "error",
+    }
+    try:
+        if PATCH.is_symlink() or not PATCH.is_file() or PATCH.stat().st_size > 32 * 1024 * 1024:
+            raise ValueError("Missing, oversized or symlink submission")
+        record["patch_sha256"] = hashlib.sha256(PATCH.read_bytes()).hexdigest()
+        try:
+            asyncio.run(_grade(config, record))
+        finally:
+            _stop_candidate_processes()
+        reward_path.unlink(missing_ok=True)
+        validate_report(record, config, record["patch_sha256"])
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        reward_path.write_text(str(record["result"]["reward"]) + "\n")
+    except BaseException as error:
+        reward_path.unlink(missing_ok=True)
+        record.update(status="error", error={"type": type(error).__name__, "message": str(error)})
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        raise
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/manifest.json

@@ -1,6 +1,7 @@
 {
   "revision": "coding-rubric-v2",
   "tasks": [
+    "bazel_remote_disk_eviction_accounting_contract",
     "celery_retry_expires_countdown_contract",
     "coredns_rewrite_svcb_opt",
     "epicyon_deleted_post_announce_cache_contract",