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.
 
-7 more (badger, geode, kratos, open-xml-sdk, openfire, umya, zettlr) are packaged and are being re-checked; they are added
+6 more (geode, kratos, open-xml-sdk, openfire, 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/journal_recovery_after_unclean_stop/environment/Dockerfile

@@ -0,0 +1,24 @@
+FROM ec-swe-badger: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/journal_recovery_after_unclean_stop/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/journal_recovery_after_unclean_stop/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/journal_recovery_after_unclean_stop/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/journal_recovery_after_unclean_stop/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/journal_recovery_after_unclean_stop/instruction.md

@@ -0,0 +1,13 @@
+Please make your changes directly in /workspace/repo.
+
+# What the journal gives back
+
+After an unclean stop — a killed process, a torn tail on a log — the build reopens and
+serves whole transactions only: every commit it had acknowledged, none in part, and never
+a later one without every earlier one. A read never answers with a value nobody wrote.
+Opened read-only after such a stop, the build serves that same history when it can serve
+it whole, and otherwise says why it cannot; either way it alters no byte. This holds
+however the transaction was committed and whatever the value's size. Work offline; the
+existing tests stay as green as you found them — add tests, don't change them.
+
+Finish with a final response when your changes are ready.

harbor/tasks/journal_recovery_after_unclean_stop/solution/reference.patch

@@ -0,0 +1,1036 @@
+diff --git a/db.go b/db.go
+index 9572203..cf8e0f4 100644
+--- a/db.go
++++ b/db.go
+@@ -341,6 +341,14 @@ func Open(opt Options) (*DB, error) {
+ 	db.closers.updateSize = z.NewCloser(1)
+ 	go db.updateSize(db.closers.updateSize)
+ 
++	// The value log files must be known before the memtables are replayed:
++	// an entry in the WAL may point at a value the value log lost in an
++	// unclean stop, and such a transaction must not come back.
++	db.vlog.init(db)
++	if err := db.vlog.openFiles(); err != nil {
++		return db, y.Wrapf(err, "During db.vlog.openFiles")
++	}
++
+ 	if err := db.openMemTables(db.opt); err != nil {
+ 		return nil, y.Wrapf(err, "while opening memtables")
+ 	}
+@@ -356,9 +364,6 @@ func Open(opt Options) (*DB, error) {
+ 		return db, err
+ 	}
+ 
+-	// Initialize vlog struct.
+-	db.vlog.init(db)
+-
+ 	if !opt.ReadOnly {
+ 		db.closers.compactors = z.NewCloser(1)
+ 		db.lc.startCompact(db.closers.compactors)
+diff --git a/journal_recovery_test.go b/journal_recovery_test.go
+new file mode 100644
+index 0000000..0ad986f
+--- /dev/null
++++ b/journal_recovery_test.go
+@@ -0,0 +1,634 @@
++/*
++ * SPDX-FileCopyrightText: © Hypermode Inc. <hello@hypermode.com>
++ * SPDX-License-Identifier: Apache-2.0
++ */
++
++package badger
++
++import (
++	"bufio"
++	"crypto/sha256"
++	"encoding/hex"
++	"fmt"
++	"io"
++	"math"
++	"os"
++	"os/exec"
++	"path/filepath"
++	"strings"
++	"sync"
++	"testing"
++
++	"github.com/stretchr/testify/require"
++
++	"github.com/dgraph-io/badger/v4/y"
++)
++
++// The tests in this file drive a child process that writes to a DB and never
++// closes it. The parent tells the child when to take a step, the child answers
++// "ok <step> <vlog fid> <vlog offset> <wal fid> <wal offset>" once the step's
++// commit has been acknowledged, and the parent kills the child with SIGKILL
++// after the step it is interested in. No timers are involved: every kill
++// happens at a point the child has reported.
++
++const (
++	journalChildEnv = "BADGER_JOURNAL_CHILD"
++	journalDirEnv   = "BADGER_JOURNAL_DIR"
++	journalBigSize  = 4096 // goes to the value log
++	journalSmallLen = 1024 // stays in the WAL
++	journalGCSize   = 8000 // fills a value log file quickly
++	journalWriters  = 8
++)
++
++func journalOptions(dir string) Options {
++	return DefaultOptions(dir).
++		WithSyncWrites(true).
++		WithValueThreshold(2048).
++		WithMemTableSize(256 << 10).
++		WithValueLogFileSize(1 << 20).
++		WithLoggingLevel(ERROR)
++}
++
++func journalBlob(tag string, size int) []byte {
++	return []byte(strings.Repeat(tag+"|", size/(len(tag)+1)+1)[:size])
++}
++
++func journalBig(tag string) []byte {
++	return journalBlob(tag, journalBigSize)
++}
++
++func journalSmall(tag string) []byte {
++	return []byte(fmt.Sprintf("%-*s", journalSmallLen, tag)[:journalSmallLen])
++}
++
++// journalStep performs step n of the given scenario on db.
++func journalStep(db *DB, scenario string, n int) error {
++	switch scenario {
++	case "vlog":
++		switch n {
++		case 1:
++			return db.Update(func(txn *Txn) error {
++				if err := txn.Set([]byte("k1"), journalBig("k1v1")); err != nil {
++					return err
++				}
++				return txn.Set([]byte("k2"), journalSmall("k2v1"))
++			})
++		case 2:
++			return db.Update(func(txn *Txn) error {
++				if err := txn.Set([]byte("k3"), journalBig("k3v1")); err != nil {
++					return err
++				}
++				if err := txn.Set([]byte("k4"), journalSmall("k4v1")); err != nil {
++					return err
++				}
++				return txn.Set([]byte("k1"), journalBig("k1v2"))
++			})
++		case 3:
++			return db.Update(func(txn *Txn) error { return txn.Delete([]byte("k2")) })
++		case 4:
++			return db.Update(func(txn *Txn) error { return txn.Set([]byte("k5"), journalSmall("k5v1")) })
++		}
++	case "mixed":
++		switch n {
++		case 1:
++			wb := db.NewManagedWriteBatch()
++			for i, ts := range []uint64{10, 11, 12} {
++				k := []byte(fmt.Sprintf("m%d", i+1))
++				if err := wb.SetEntryAt(NewEntry(k, journalSmall(string(k))), ts); err != nil {
++					return err
++				}
++			}
++			return wb.Flush()
++		case 2:
++			txn := db.NewTransactionAt(20, true)
++			if err := txn.Set([]byte("m4"), journalBig("m4")); err != nil {
++				return err
++			}
++			return txn.CommitAt(20, nil)
++		case 3:
++			wb := db.NewWriteBatchAt(30)
++			if err := wb.SetEntryAt(NewEntry([]byte("m5"), journalSmall("m5")), 31); err != nil {
++				return err
++			}
++			if err := wb.DeleteAt([]byte("m2"), 32); err != nil {
++				return err
++			}
++			return wb.Flush()
++		}
++	case "gc":
++		// x twice (each version flushed to a table, so that the tables carry
++		// the discard statistics), then y and z until the value log rotates;
++		// compaction, then garbage collection until nothing is left to move.
++		// Every live value of the first file is copied to the last one and
++		// re-logged in the WAL, and the first file is deleted.
++		if n != 1 {
++			break
++		}
++		put := func(prefix string, count int, tag string) error {
++			for i := 0; i < count; i++ {
++				k := fmt.Sprintf("%s-%03d", prefix, i)
++				if err := db.Update(func(txn *Txn) error {
++					return txn.Set([]byte(k), journalBlob(k+tag, journalGCSize))
++				}); err != nil {
++					return err
++				}
++			}
++			return nil
++		}
++		flush := func() error {
++			if err := db.Update(func(txn *Txn) error {
++				return txn.Set([]byte("drop-me"), []byte("x"))
++			}); err != nil {
++				return err
++			}
++			return db.DropPrefix([]byte("drop-"))
++		}
++		if err := put("x", 40, "/1"); err != nil {
++			return err
++		}
++		if err := flush(); err != nil {
++			return err
++		}
++		if err := put("x", 40, "/2"); err != nil {
++			return err
++		}
++		if err := flush(); err != nil {
++			return err
++		}
++		if err := put("y", 20, ""); err != nil {
++			return err
++		}
++		if err := put("z", 60, ""); err != nil {
++			return err
++		}
++		if err := db.Flatten(1); err != nil {
++			return err
++		}
++		for {
++			err := db.RunValueLogGC(0.05)
++			if err == ErrNoRewrite {
++				break
++			}
++			if err != nil {
++				return err
++			}
++		}
++		db.vlog.filesLock.RLock()
++		_, kept := db.vlog.filesMap[1]
++		db.vlog.filesLock.RUnlock()
++		if kept {
++			return fmt.Errorf("garbage collection did not retire value log file 1")
++		}
++		return nil
++	case "load":
++		var wg sync.WaitGroup
++		errs := make([]error, journalWriters)
++		for g := 0; g < journalWriters; g++ {
++			wg.Add(1)
++			go func(g int) {
++				defer wg.Done()
++				errs[g] = db.Update(func(txn *Txn) error {
++					big := fmt.Sprintf("g%d-b%d", g, n)
++					small := fmt.Sprintf("g%d-s%d", g, n)
++					if err := txn.Set([]byte(big), journalBig(big)); err != nil {
++						return err
++					}
++					return txn.Set([]byte(small), journalSmall(small))
++				})
++			}(g)
++		}
++		wg.Wait()
++		for _, err := range errs {
++			if err != nil {
++				return err
++			}
++		}
++		return nil
++	}
++	return fmt.Errorf("no step %d in scenario %q", n, scenario)
++}
++
++// TestJournalChild is the child process. It only runs when spawned by the
++// tests below.
++func TestJournalChild(t *testing.T) {
++	scenario := os.Getenv(journalChildEnv)
++	if scenario == "" {
++		t.Skip("child process of the journal recovery tests")
++	}
++	opt := journalOptions(os.Getenv(journalDirEnv))
++	var db *DB
++	var err error
++	if scenario == "mixed" {
++		db, err = OpenManaged(opt)
++	} else {
++		db, err = Open(opt)
++	}
++	if err != nil {
++		fmt.Printf("error %v\n", err)
++		os.Exit(2)
++	}
++	in := bufio.NewScanner(os.Stdin)
++	for step := 1; in.Scan(); step++ {
++		if err := journalStep(db, scenario, step); err != nil {
++			fmt.Printf("error %v\n", err)
++			os.Exit(2)
++		}
++		fmt.Printf("ok %d %d %d %d %d\n", step,
++			db.vlog.maxFid, db.vlog.woffset(), db.mt.wal.fid, db.mt.wal.writeAt)
++	}
++	// The parent went away without killing us. Leave without closing, as a
++	// crash would.
++	os.Exit(0)
++}
++
++type journalMark struct {
++	vlogFid, vlogOff, walFid, walOff uint32
++}
++
++type journalChild struct {
++	t   *testing.T
++	cmd *exec.Cmd
++	in  io.WriteCloser
++	out *bufio.Scanner
++}
++
++func startJournalChild(t *testing.T, scenario, dir string) *journalChild {
++	t.Helper()
++	cmd := exec.Command(os.Args[0], "-test.run=^TestJournalChild$")
++	cmd.Env = append(os.Environ(), journalChildEnv+"="+scenario, journalDirEnv+"="+dir)
++	cmd.Stderr = os.Stderr
++	in, err := cmd.StdinPipe()
++	require.NoError(t, err)
++	out, err := cmd.StdoutPipe()
++	require.NoError(t, err)
++	require.NoError(t, cmd.Start())
++	c := &journalChild{t: t, cmd: cmd, in: in, out: bufio.NewScanner(out)}
++	t.Cleanup(func() { c.kill() })
++	return c
++}
++
++// step asks the child for one more step and returns where its logs ended
++// once the step was acknowledged.
++func (c *journalChild) step() journalMark {
++	c.t.Helper()
++	_, err := io.WriteString(c.in, "next\n")
++	require.NoError(c.t, err)
++	require.True(c.t, c.out.Scan(), "child stopped answering")
++	var m journalMark
++	var n int
++	_, err = fmt.Sscanf(c.out.Text(), "ok %d %d %d %d %d",
++		&n, &m.vlogFid, &m.vlogOff, &m.walFid, &m.walOff)
++	require.NoError(c.t, err, "child said %q", c.out.Text())
++	return m
++}
++
++// kill stops the child the way a crash would.
++func (c *journalChild) kill() {
++	if c.cmd.ProcessState != nil {
++		return
++	}
++	_ = c.cmd.Process.Kill()
++	_ = c.cmd.Wait()
++}
++
++// runJournalChild runs the scenario for the given number of steps in a fresh
++// directory, kills the child and returns the directory and the marks.
++func runJournalChild(t *testing.T, scenario string, steps int) (string, []journalMark) {
++	t.Helper()
++	dir, err := os.MkdirTemp("", "badger-journal")
++	require.NoError(t, err)
++	t.Cleanup(func() { removeDir(dir) })
++	c := startJournalChild(t, scenario, dir)
++	marks := make([]journalMark, 0, steps)
++	for i := 0; i < steps; i++ {
++		marks = append(marks, c.step())
++	}
++	c.kill()
++	return dir, marks
++}
++
++func journalFileHashes(t *testing.T, dir string) map[string]string {
++	t.Helper()
++	entries, err := os.ReadDir(dir)
++	require.NoError(t, err)
++	hashes := make(map[string]string)
++	for _, e := range entries {
++		// Tables are outside the journal: a flush that was under way when the
++		// process died leaves one the manifest does not know about, and that
++		// one is removed on open, read-only or not, as it always was.
++		if e.IsDir() || strings.HasSuffix(e.Name(), ".sst") {
++			continue
++		}
++		data, err := os.ReadFile(filepath.Join(dir, e.Name()))
++		require.NoError(t, err)
++		sum := sha256.Sum256(data)
++		hashes[e.Name()] = fmt.Sprintf("%d:%s", len(data), hex.EncodeToString(sum[:]))
++	}
++	return hashes
++}
++
++// zeroTail overwrites path from off to its end with zeros, as if the pages
++// after off had never reached the disk.
++func zeroTail(t *testing.T, path string, off uint32) {
++	t.Helper()
++	fi, err := os.Stat(path)
++	require.NoError(t, err)
++	f, err := os.OpenFile(path, os.O_WRONLY, 0)
++	require.NoError(t, err)
++	defer f.Close()
++	_, err = f.WriteAt(make([]byte, fi.Size()-int64(off)), int64(off))
++	require.NoError(t, err)
++}
++
++func openJournal(t *testing.T, dir string, readOnly, managed bool) (*DB, error) {
++	t.Helper()
++	opt := journalOptions(dir)
++	opt.ReadOnly = readOnly
++	if managed {
++		return OpenManaged(opt)
++	}
++	return Open(opt)
++}
++
++// journalGet returns the value of key, or "" and false when it is absent.
++func journalGet(t *testing.T, db *DB, key string) (string, bool) {
++	t.Helper()
++	var txn *Txn
++	if db.opt.managedTxns {
++		txn = db.NewTransactionAt(math.MaxUint64, false)
++	} else {
++		txn = db.NewTransaction(false)
++	}
++	defer txn.Discard()
++	item, err := txn.Get([]byte(key))
++	if err == ErrKeyNotFound {
++		return "", false
++	}
++	require.NoError(t, err)
++	val, err := item.ValueCopy(nil)
++	require.NoError(t, err)
++	return string(val), true
++}
++
++func requireJournalValue(t *testing.T, db *DB, key string, want []byte) {
++	t.Helper()
++	got, ok := journalGet(t, db, key)
++	require.True(t, ok, "key %s is missing", key)
++	require.Equal(t, string(want), got, "key %s", key)
++}
++
++func requireJournalAbsent(t *testing.T, db *DB, key string) {
++	t.Helper()
++	got, ok := journalGet(t, db, key)
++	require.False(t, ok, "key %s should be absent, has %q", key, got)
++}
++
++// requireReadOnlyRefuses opens the DB read-only, expects an error and
++// expects every file to be exactly as it was.
++func requireReadOnlyRefuses(t *testing.T, dir string, managed bool) {
++	t.Helper()
++	before := journalFileHashes(t, dir)
++	db, err := openJournal(t, dir, true, managed)
++	if err == nil {
++		require.NoError(t, db.Close())
++	}
++	require.Error(t, err, "read-only open must refuse a torn history")
++	require.Equal(t, before, journalFileHashes(t, dir), "read-only open changed a file")
++}
++
++func TestJournalTornValueLogTailKeepsTransactionsWhole(t *testing.T) {
++	// A tear in the middle of the second transaction's values, emulating
++	// pages that never reached the disk: the file keeps its length.
++	t.Run("zeroed", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "vlog", 4)
++		vlogPath := vlogFilePath(dir, marks[1].vlogFid)
++		require.Equal(t, marks[0].vlogFid, marks[1].vlogFid)
++		zeroTail(t, vlogPath, marks[0].vlogOff+(marks[1].vlogOff-marks[0].vlogOff)/2)
++
++		requireReadOnlyRefuses(t, dir, false)
++
++		db, err := openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		// The first transaction is whole, the torn one is gone entirely —
++		// including the part of it that lived in the WAL — and so is
++		// everything committed after it.
++		requireJournalValue(t, db, "k1", journalBig("k1v1"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		requireJournalAbsent(t, db, "k4")
++		requireJournalAbsent(t, db, "k5")
++
++		// Writes after recovery win, and stay won.
++		require.NoError(t, db.Update(func(txn *Txn) error {
++			return txn.Set([]byte("k1"), journalBig("k1v3"))
++		}))
++		requireJournalValue(t, db, "k1", journalBig("k1v3"))
++		require.NoError(t, db.Close())
++		db, err = openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "k1", journalBig("k1v3"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		require.NoError(t, db.Close())
++	})
++
++	// The file cut exactly where the first transaction's values end: that
++	// transaction is whole, the next one is not.
++	t.Run("truncated at a record boundary", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "vlog", 4)
++		require.NoError(t, os.Truncate(vlogFilePath(dir, marks[0].vlogFid), int64(marks[0].vlogOff)))
++
++		requireReadOnlyRefuses(t, dir, false)
++
++		db, err := openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "k1", journalBig("k1v1"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		requireJournalAbsent(t, db, "k4")
++		requireJournalAbsent(t, db, "k5")
++		require.NoError(t, db.Close())
++	})
++
++	// A tear in the WAL itself, with the value log whole.
++	t.Run("torn wal", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "vlog", 4)
++		require.Equal(t, marks[0].walFid, marks[1].walFid)
++		zeroTail(t, filepath.Join(dir, fmt.Sprintf("%05d%s", marks[1].walFid, memFileExt)), marks[1].walOff-5)
++
++		requireReadOnlyRefuses(t, dir, false)
++
++		db, err := openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "k1", journalBig("k1v1"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		requireJournalAbsent(t, db, "k4")
++		requireJournalAbsent(t, db, "k5")
++		require.NoError(t, db.Close())
++	})
++}
++
++func TestJournalMixedVersionTransactionWholeAfterTear(t *testing.T) {
++	checkWhole := func(t *testing.T, db *DB) {
++		t.Helper()
++		requireJournalValue(t, db, "m1", journalSmall("m1"))
++		requireJournalAbsent(t, db, "m2") // deleted at 32
++		requireJournalValue(t, db, "m3", journalSmall("m3"))
++		requireJournalValue(t, db, "m4", journalBig("m4"))
++		requireJournalValue(t, db, "m5", journalSmall("m5"))
++	}
++
++	t.Run("killed without a tear", func(t *testing.T) {
++		dir, _ := runJournalChild(t, "mixed", 3)
++		before := journalFileHashes(t, dir)
++		db, err := openJournal(t, dir, true, true)
++		require.NoError(t, err)
++		checkWhole(t, db)
++		require.NoError(t, db.Close())
++		require.Equal(t, before, journalFileHashes(t, dir))
++
++		db, err = openJournal(t, dir, false, true)
++		require.NoError(t, err)
++		checkWhole(t, db)
++		require.NoError(t, db.Close())
++	})
++
++	t.Run("torn inside the mixed transaction", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "mixed", 3)
++		zeroTail(t, filepath.Join(dir, fmt.Sprintf("%05d%s", marks[0].walFid, memFileExt)), marks[0].walOff-5)
++
++		requireReadOnlyRefuses(t, dir, true)
++
++		db, err := openJournal(t, dir, false, true)
++		require.NoError(t, err)
++		for _, k := range []string{"m1", "m2", "m3", "m4", "m5"} {
++			requireJournalAbsent(t, db, k)
++		}
++		require.NoError(t, db.Close())
++	})
++
++	t.Run("torn after the mixed transaction", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "mixed", 3)
++		zeroTail(t, filepath.Join(dir, fmt.Sprintf("%05d%s", marks[2].walFid, memFileExt)), marks[2].walOff-5)
++
++		requireReadOnlyRefuses(t, dir, true)
++
++		db, err := openJournal(t, dir, false, true)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "m1", journalSmall("m1"))
++		requireJournalValue(t, db, "m2", journalSmall("m2"))
++		requireJournalValue(t, db, "m3", journalSmall("m3"))
++		requireJournalValue(t, db, "m4", journalBig("m4"))
++		requireJournalAbsent(t, db, "m5")
++		require.NoError(t, db.Close())
++	})
++}
++
++func TestJournalReadOnlyOpenAfterKillServesAcknowledgedCommits(t *testing.T) {
++	const steps = 40
++	dir, marks := runJournalChild(t, "load", steps)
++	last := marks[len(marks)-1]
++	require.Greater(t, last.vlogFid, uint32(1), "the value log should have rotated")
++	require.Greater(t, last.walFid, uint32(1), "the memtable should have rotated")
++
++	check := func(t *testing.T, db *DB) {
++		t.Helper()
++		for g := 0; g < journalWriters; g++ {
++			for n := 1; n <= steps; n++ {
++				big := fmt.Sprintf("g%d-b%d", g, n)
++				small := fmt.Sprintf("g%d-s%d", g, n)
++				requireJournalValue(t, db, big, journalBig(big))
++				requireJournalValue(t, db, small, journalSmall(small))
++			}
++		}
++	}
++
++	before := journalFileHashes(t, dir)
++	db, err := openJournal(t, dir, true, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Close())
++	require.Equal(t, before, journalFileHashes(t, dir), "read-only open changed a file")
++
++	db, err = openJournal(t, dir, false, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Update(func(txn *Txn) error {
++		return txn.Set([]byte("after"), journalBig("after"))
++	}))
++	requireJournalValue(t, db, "after", journalBig("after"))
++	require.NoError(t, db.Close())
++}
++
++// Garbage collection deletes a value log file once every live value in it
++// has been copied to the last file and re-logged in the WAL. A crash before
++// the next flush leaves the WAL still pointing at the deleted file for those
++// values' first records. That is not a tear: nothing acknowledged was lost,
++// and recovery, read-only or not, serves the whole history.
++func TestJournalRetiredValueLogFileIsNotATear(t *testing.T) {
++	dir, marks := runJournalChild(t, "gc", 1)
++	require.Greater(t, marks[0].vlogFid, uint32(1), "the value log should have rotated")
++	require.NoFileExists(t, filepath.Join(dir, "000001.vlog"), "file 1 should have been retired")
++
++	check := func(t *testing.T, db *DB) {
++		t.Helper()
++		for i := 0; i < 40; i++ {
++			k := fmt.Sprintf("x-%03d", i)
++			requireJournalValue(t, db, k, journalBlob(k+"/2", journalGCSize))
++		}
++		for i := 0; i < 20; i++ {
++			k := fmt.Sprintf("y-%03d", i)
++			requireJournalValue(t, db, k, journalBlob(k, journalGCSize))
++		}
++		for i := 0; i < 60; i++ {
++			k := fmt.Sprintf("z-%03d", i)
++			requireJournalValue(t, db, k, journalBlob(k, journalGCSize))
++		}
++	}
++
++	before := journalFileHashes(t, dir)
++	db, err := openJournal(t, dir, true, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Close())
++	require.Equal(t, before, journalFileHashes(t, dir), "read-only open changed a file")
++
++	db, err = openJournal(t, dir, false, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Close())
++}
++
++// A WAL written by an earlier build holds transactions with entries of
++// different versions and no markers around them. They still come back whole.
++func TestJournalOldTransactionWithoutMarkersReplaysWhole(t *testing.T) {
++	dir, err := os.MkdirTemp("", "badger-journal")
++	require.NoError(t, err)
++	defer removeDir(dir)
++
++	opt := journalOptions(dir)
++	db0, err := OpenManaged(opt)
++	require.NoError(t, err)
++	defer func() { require.NoError(t, db0.Close()) }()
++	for i, ts := range []uint64{10, 11, 12} {
++		k := fmt.Sprintf("o%d", i+1)
++		require.NoError(t, db0.mt.Put(y.KeyWithTs([]byte(k), ts), y.ValueStruct{Value: journalSmall(k)}))
++	}
++	require.NoError(t, db0.mt.SyncWAL())
++	// Simulate a crash by not closing db0, but releasing the locks.
++	require.NoError(t, db0.dirLockGuard.release())
++	db0.dirLockGuard = nil
++	if db0.valueDirGuard != nil {
++		require.NoError(t, db0.valueDirGuard.release())
++		db0.valueDirGuard = nil
++	}
++
++	db1, err := openJournal(t, dir, true, true)
++	require.NoError(t, err)
++	for i := 1; i <= 3; i++ {
++		k := fmt.Sprintf("o%d", i)
++		requireJournalValue(t, db1, k, journalSmall(k))
++	}
++	require.NoError(t, db1.Close())
++}
+diff --git a/memtable.go b/memtable.go
+index 161a463..f107477 100644
+--- a/memtable.go
++++ b/memtable.go
+@@ -38,6 +38,9 @@ type memTable struct {
+ 	maxVersion uint64
+ 	opt        Options
+ 	buf        *bytes.Buffer
++	// vptrOK tells replay whether a value pointer found in the WAL still
++	// addresses a record the value log holds.
++	vptrOK func(valuePointer) bool
+ }
+ 
+ func (db *DB) openMemTables(opt Options) error {
+@@ -98,9 +101,10 @@ func (db *DB) openMemTable(fid, flags int) (*memTable, error) {
+ 	filepath := db.mtFilePath(fid)
+ 	s := skl.NewSkiplist(arenaSize(db.opt))
+ 	mt := &memTable{
+-		sl:  s,
+-		opt: db.opt,
+-		buf: &bytes.Buffer{},
++		sl:     s,
++		opt:    db.opt,
++		buf:    &bytes.Buffer{},
++		vptrOK: db.vlog.contains,
+ 	}
+ 	// We don't need to create the wal for the skiplist in in-memory mode so return the mt.
+ 	if db.opt.InMemory {
+@@ -202,12 +206,19 @@ func (mt *memTable) UpdateSkipList() error {
+ 	if mt.wal == nil || mt.sl == nil {
+ 		return nil
+ 	}
+-	endOff, err := mt.wal.iterate(true, 0, mt.replayFunction(mt.opt))
++	endOff, stopAt, err := mt.wal.replay(0, mt.replayFunction(mt.opt), mt.vptrOK)
+ 	if err != nil {
+ 		return y.Wrapf(err, "while iterating wal: %s", mt.wal.Fd.Name())
+ 	}
+-	if endOff < mt.wal.size.Load() && mt.opt.ReadOnly {
+-		return y.Wrapf(ErrTruncateNeeded, "end offset: %d < size: %d", endOff, mt.wal.size.Load())
++	if mt.opt.ReadOnly {
++		// The file is pre-allocated, so a tail of zeros after the last record
++		// is the normal state after an unclean stop and needs no repair. Any
++		// other bytes there are a damaged record, and a read-only DB must
++		// not repair it.
++		if !mt.wal.zeroFrom(stopAt) {
++			return y.Wrapf(ErrTruncateNeeded, "end offset: %d < size: %d", endOff, mt.wal.size.Load())
++		}
++		return nil
+ 	}
+ 	return mt.wal.Truncate(int64(endOff))
+ }
+@@ -431,6 +442,41 @@ func (lf *logFile) doneWriting(offset uint32) error {
+ // iterate iterates over log file. It doesn't not allocate new memory for every kv pair.
+ // Therefore, the kv pair is only valid for the duration of fn call.
+ func (lf *logFile) iterate(readOnly bool, offset uint32, fn logEntry) (uint32, error) {
++	end, _, err := lf.replay(offset, fn, nil)
++	return end, err
++}
++
++// lostValue reports whether e's value lives in the value log at a place the
++// value log no longer holds, according to vptrOK.
++func lostValue(e *Entry, vptrOK func(valuePointer) bool) bool {
++	if vptrOK == nil || e.meta&bitValuePointer == 0 {
++		return false
++	}
++	if uintptr(len(e.Value)) < vptrSize {
++		return true
++	}
++	var vp valuePointer
++	vp.Decode(e.Value)
++	return !vptrOK(vp)
++}
++
++// zeroFrom reports whether nothing but zeros follows off in the file.
++func (lf *logFile) zeroFrom(off uint32) bool {
++	if int64(off) >= int64(len(lf.Data)) {
++		return true
++	}
++	return len(bytes.TrimLeft(lf.Data[off:], "\x00")) == 0
++}
++
++// replay is iterate with two additions. When vptrOK is given, an entry whose
++// value lives in the value log is checked against it before anything of its
++// transaction is applied, so a pointer to a lost value stops the replay in
++// front of that transaction. Besides the offset up to which the log was
++// applied, replay returns the offset of the record it stopped at: the one it
++// could not read, or the one it could not accept — a transaction with a
++// missing or mismatching end marker, an entry pointing at a lost value.
++func (lf *logFile) replay(offset uint32, fn logEntry, vptrOK func(valuePointer) bool) (
++	uint32, uint32, error) {
+ 	if offset == 0 {
+ 		// If offset is set to zero, let's advance past the encryption key header.
+ 		offset = vlogHeaderSize
+@@ -445,14 +491,19 @@ func (lf *logFile) iterate(readOnly bool, offset uint32, fn logEntry) (uint32, e
+ 		lf:           lf,
+ 	}
+ 
+-	var lastCommit uint64
++	// lastCommit is the version of the entry that opened the transaction
++	// being read, or zero outside a transaction; txnMax is the largest
++	// version seen in it, which its end marker must repeat.
++	var lastCommit, txnMax uint64
+ 	var validEndOffset uint32 = offset
+ 
+ 	var entries []*Entry
+ 	var vptrs []valuePointer
+ 
++	var stopAt uint32
+ loop:
+ 	for {
++		stopAt = read.recordOffset
+ 		e, err := read.Entry(reader)
+ 		switch {
+ 		// We have not reached the end of the file but the entry we read is
+@@ -463,7 +514,7 @@ loop:
+ 		case err == io.ErrUnexpectedEOF || err == errTruncate:
+ 			break loop
+ 		case err != nil:
+-			return 0, err
++			return 0, 0, err
+ 		case e == nil:
+ 			continue
+ 		case e.isZero():
+@@ -483,19 +534,24 @@ loop:
+ 			if lastCommit == 0 {
+ 				lastCommit = txnTs
+ 			}
+-			if lastCommit != txnTs {
+-				break loop
++			if txnTs > txnMax {
++				txnMax = txnTs
+ 			}
+ 			entries = append(entries, e)
+ 			vptrs = append(vptrs, vp)
+ 
+ 		case e.meta&bitFinTxn > 0:
+ 			txnTs, err := strconv.ParseUint(string(e.Value), 10, 64)
+-			if err != nil || lastCommit != txnTs {
++			if err != nil || lastCommit == 0 || txnTs != txnMax {
+ 				break loop
+ 			}
++			for _, e := range entries {
++				if lostValue(e, vptrOK) {
++					break loop
++				}
++			}
+ 			// Got the end of txn. Now we can store them.
+-			lastCommit = 0
++			lastCommit, txnMax = 0, 0
+ 			validEndOffset = read.recordOffset
+ 
+ 			for i, e := range entries {
+@@ -504,7 +560,7 @@ loop:
+ 					if err == errStop {
+ 						break
+ 					}
+-					return 0, errFile(err, lf.path, "Iteration function")
++					return 0, 0, errFile(err, lf.path, "Iteration function")
+ 				}
+ 			}
+ 			entries = entries[:0]
+@@ -516,17 +572,20 @@ loop:
+ 				// We shouldn't get this entry in the middle of a transaction.
+ 				break loop
+ 			}
++			if lostValue(e, vptrOK) {
++				break loop
++			}
+ 			validEndOffset = read.recordOffset
+ 
+ 			if err := fn(*e, vp); err != nil {
+ 				if err == errStop {
+ 					break
+ 				}
+-				return 0, errFile(err, lf.path, "Iteration function")
++				return 0, 0, errFile(err, lf.path, "Iteration function")
+ 			}
+ 		}
+ 	}
+-	return validEndOffset, nil
++	return validEndOffset, stopAt, nil
+ }
+ 
+ // Zero out the next entry to deal with any crashes.
+diff --git a/txn.go b/txn.go
+index 9c916d1..5e852af 100644
+--- a/txn.go
++++ b/txn.go
+@@ -532,12 +532,17 @@ func (txn *Txn) commitAndSend() (func() error, error) {
+ 		return nil, ErrConflict
+ 	}
+ 
+-	keepTogether := true
++	// Every transaction is bracketed by markers in the log so that replay can
++	// apply it whole or not at all. Entries may carry their own versions
++	// (SetEntryAt in managed mode), and commitTs may then even be zero, so the
++	// end marker carries the largest version in the transaction.
++	var maxVersion uint64
+ 	setVersion := func(e *Entry) {
+ 		if e.version == 0 {
+ 			e.version = commitTs
+-		} else {
+-			keepTogether = false
++		}
++		if e.version > maxVersion {
++			maxVersion = e.version
+ 		}
+ 	}
+ 	for _, e := range txn.pendingWrites {
+@@ -555,14 +560,7 @@ func (txn *Txn) commitAndSend() (func() error, error) {
+ 		// Suffix the keys with commit ts, so the key versions are sorted in
+ 		// descending order of commit timestamp.
+ 		e.Key = y.KeyWithTs(e.Key, e.version)
+-		// Add bitTxn only if these entries are part of a transaction. We
+-		// support SetEntryAt(..) in managed mode which means a single
+-		// transaction can have entries with different timestamps. If entries
+-		// in a single transaction have different timestamps, we don't add the
+-		// transaction markers.
+-		if keepTogether {
+-			e.meta |= bitTxn
+-		}
++		e.meta |= bitTxn
+ 		entries = append(entries, e)
+ 	}
+ 
+@@ -579,16 +577,14 @@ func (txn *Txn) commitAndSend() (func() error, error) {
+ 		processEntry(e)
+ 	}
+ 
+-	if keepTogether {
+-		// CommitTs should not be zero if we're inserting transaction markers.
+-		y.AssertTrue(commitTs != 0)
+-		e := &Entry{
+-			Key:   y.KeyWithTs(txnKey, commitTs),
+-			Value: []byte(strconv.FormatUint(commitTs, 10)),
+-			meta:  bitFinTxn,
+-		}
+-		entries = append(entries, e)
+-	}
++	// commitPrecheck guarantees a non-zero commitTs whenever no entry has a
++	// version of its own.
++	y.AssertTrue(maxVersion != 0)
++	entries = append(entries, &Entry{
++		Key:   y.KeyWithTs(txnKey, maxVersion),
++		Value: []byte(strconv.FormatUint(maxVersion, 10)),
++		meta:  bitFinTxn,
++	})
+ 
+ 	req, err := txn.db.sendToWriteCh(entries)
+ 	if err != nil {
+diff --git a/value.go b/value.go
+index e042651..c343473 100644
+--- a/value.go
++++ b/value.go
+@@ -580,26 +580,24 @@ func (vlog *valueLog) init(db *DB) {
+ 	db.logToSyncChan(endVLogInitMsg)
+ }
+ 
+-func (vlog *valueLog) open(db *DB) error {
+-	// We don't need to open any vlog files or collect stats for GC if DB is opened
+-	// in InMemory mode. InMemory mode doesn't create any files/directories on disk.
+-	if db.opt.InMemory {
++// openFiles opens the value log files found on disk and establishes how much
++// of each one holds records. Files that were rotated out were cut down to
++// their records when they were retired; the last file is pre-allocated and
++// may end in whatever an unclean stop left behind, so its size is what can be
++// parsed from it. Nothing is written: this runs before the memtables are
++// replayed, in read-only mode too, so that replay can tell a pointer into a
++// lost value from a good one.
++func (vlog *valueLog) openFiles() error {
++	if vlog.opt.InMemory {
+ 		return nil
+ 	}
+-
+ 	if err := vlog.populateFilesMap(); err != nil {
+ 		return err
+ 	}
+-	// If no files are found, then create a new file.
+ 	if len(vlog.filesMap) == 0 {
+-		if vlog.opt.ReadOnly {
+-			return nil
+-		}
+-		_, err := vlog.createVlogFile()
+-		return y.Wrapf(err, "Error while creating log file in valueLog.open")
++		return nil
+ 	}
+-	fids := vlog.sortedFids()
+-	for _, fid := range fids {
++	for _, fid := range vlog.sortedFids() {
+ 		lf, ok := vlog.filesMap[fid]
+ 		y.AssertTrue(ok)
+ 
+@@ -612,20 +610,8 @@ func (vlog *valueLog) open(db *DB) error {
+ 			2*vlog.opt.ValueLogFileSize); err != nil {
+ 			return y.Wrapf(err, "Open existing file: %q", lf.path)
+ 		}
+-		// We shouldn't delete the maxFid file.
+-		if lf.size.Load() == vlogHeaderSize && fid != vlog.maxFid && !vlog.opt.ReadOnly {
+-			vlog.opt.Infof("Deleting empty file: %s", lf.path)
+-			if err := lf.Delete(); err != nil {
+-				return y.Wrapf(err, "while trying to delete empty file: %s", lf.path)
+-			}
+-			delete(vlog.filesMap, fid)
+-		}
+ 	}
+-
+-	if vlog.opt.ReadOnly {
+-		return nil
+-	}
+-	// Now we can read the latest value log file, and see if it needs truncation. We could
++	// Read the latest value log file to see where its records end. We could
+ 	// technically do this over all the value log files, but that would mean slowing down the value
+ 	// log open.
+ 	last, ok := vlog.filesMap[vlog.maxFid]
+@@ -637,7 +623,51 @@ func (vlog *valueLog) open(db *DB) error {
+ 	if err != nil {
+ 		return y.Wrapf(err, "while iterating over: %s", last.path)
+ 	}
+-	if err := last.Truncate(int64(lastOff)); err != nil {
++	last.size.Store(lastOff)
++	return nil
++}
++
++// contains reports whether vp addresses a record the value log holds, as
++// established by openFiles. For use while no writes are in flight.
++func (vlog *valueLog) contains(vp valuePointer) bool {
++	lf, ok := vlog.filesMap[vp.Fid]
++	if !ok {
++		// A file that is gone was retired by garbage collection, which had
++		// moved every live value out of it first; an unclean stop never
++		// removes a file. The entry is stale, not torn.
++		return true
++	}
++	return uint64(vp.Offset)+uint64(vp.Len) <= uint64(lf.size.Load())
++}
++
++// open makes the value log writable after openFiles: empty retired files are
++// deleted, the last file is cut down to its records, and a fresh file is
++// created to write into. A read-only DB leaves the files as they are.
++func (vlog *valueLog) open(db *DB) error {
++	// We don't need to open any vlog files or collect stats for GC if DB is opened
++	// in InMemory mode. InMemory mode doesn't create any files/directories on disk.
++	if db.opt.InMemory || vlog.opt.ReadOnly {
++		return nil
++	}
++	// If no files are found, then create a new file.
++	if len(vlog.filesMap) == 0 {
++		_, err := vlog.createVlogFile()
++		return y.Wrapf(err, "Error while creating log file in valueLog.open")
++	}
++	for _, fid := range vlog.sortedFids() {
++		lf := vlog.filesMap[fid]
++		// We shouldn't delete the maxFid file.
++		if lf.size.Load() == vlogHeaderSize && fid != vlog.maxFid {
++			vlog.opt.Infof("Deleting empty file: %s", lf.path)
++			if err := lf.Delete(); err != nil {
++				return y.Wrapf(err, "while trying to delete empty file: %s", lf.path)
++			}
++			delete(vlog.filesMap, fid)
++		}
++	}
++	last, ok := vlog.filesMap[vlog.maxFid]
++	y.AssertTrue(ok)
++	if err := last.Truncate(int64(last.size.Load())); err != nil {
+ 		return y.Wrapf(err, "while truncating last value log file: %s", last.path)
+ 	}
+ 

harbor/tasks/journal_recovery_after_unclean_stop/solution/solve.sh

@@ -0,0 +1,1042 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/db.go b/db.go
+index 9572203..cf8e0f4 100644
+--- a/db.go
++++ b/db.go
+@@ -341,6 +341,14 @@ func Open(opt Options) (*DB, error) {
+ 	db.closers.updateSize = z.NewCloser(1)
+ 	go db.updateSize(db.closers.updateSize)
+ 
++	// The value log files must be known before the memtables are replayed:
++	// an entry in the WAL may point at a value the value log lost in an
++	// unclean stop, and such a transaction must not come back.
++	db.vlog.init(db)
++	if err := db.vlog.openFiles(); err != nil {
++		return db, y.Wrapf(err, "During db.vlog.openFiles")
++	}
++
+ 	if err := db.openMemTables(db.opt); err != nil {
+ 		return nil, y.Wrapf(err, "while opening memtables")
+ 	}
+@@ -356,9 +364,6 @@ func Open(opt Options) (*DB, error) {
+ 		return db, err
+ 	}
+ 
+-	// Initialize vlog struct.
+-	db.vlog.init(db)
+-
+ 	if !opt.ReadOnly {
+ 		db.closers.compactors = z.NewCloser(1)
+ 		db.lc.startCompact(db.closers.compactors)
+diff --git a/journal_recovery_test.go b/journal_recovery_test.go
+new file mode 100644
+index 0000000..0ad986f
+--- /dev/null
++++ b/journal_recovery_test.go
+@@ -0,0 +1,634 @@
++/*
++ * SPDX-FileCopyrightText: © Hypermode Inc. <hello@hypermode.com>
++ * SPDX-License-Identifier: Apache-2.0
++ */
++
++package badger
++
++import (
++	"bufio"
++	"crypto/sha256"
++	"encoding/hex"
++	"fmt"
++	"io"
++	"math"
++	"os"
++	"os/exec"
++	"path/filepath"
++	"strings"
++	"sync"
++	"testing"
++
++	"github.com/stretchr/testify/require"
++
++	"github.com/dgraph-io/badger/v4/y"
++)
++
++// The tests in this file drive a child process that writes to a DB and never
++// closes it. The parent tells the child when to take a step, the child answers
++// "ok <step> <vlog fid> <vlog offset> <wal fid> <wal offset>" once the step's
++// commit has been acknowledged, and the parent kills the child with SIGKILL
++// after the step it is interested in. No timers are involved: every kill
++// happens at a point the child has reported.
++
++const (
++	journalChildEnv = "BADGER_JOURNAL_CHILD"
++	journalDirEnv   = "BADGER_JOURNAL_DIR"
++	journalBigSize  = 4096 // goes to the value log
++	journalSmallLen = 1024 // stays in the WAL
++	journalGCSize   = 8000 // fills a value log file quickly
++	journalWriters  = 8
++)
++
++func journalOptions(dir string) Options {
++	return DefaultOptions(dir).
++		WithSyncWrites(true).
++		WithValueThreshold(2048).
++		WithMemTableSize(256 << 10).
++		WithValueLogFileSize(1 << 20).
++		WithLoggingLevel(ERROR)
++}
++
++func journalBlob(tag string, size int) []byte {
++	return []byte(strings.Repeat(tag+"|", size/(len(tag)+1)+1)[:size])
++}
++
++func journalBig(tag string) []byte {
++	return journalBlob(tag, journalBigSize)
++}
++
++func journalSmall(tag string) []byte {
++	return []byte(fmt.Sprintf("%-*s", journalSmallLen, tag)[:journalSmallLen])
++}
++
++// journalStep performs step n of the given scenario on db.
++func journalStep(db *DB, scenario string, n int) error {
++	switch scenario {
++	case "vlog":
++		switch n {
++		case 1:
++			return db.Update(func(txn *Txn) error {
++				if err := txn.Set([]byte("k1"), journalBig("k1v1")); err != nil {
++					return err
++				}
++				return txn.Set([]byte("k2"), journalSmall("k2v1"))
++			})
++		case 2:
++			return db.Update(func(txn *Txn) error {
++				if err := txn.Set([]byte("k3"), journalBig("k3v1")); err != nil {
++					return err
++				}
++				if err := txn.Set([]byte("k4"), journalSmall("k4v1")); err != nil {
++					return err
++				}
++				return txn.Set([]byte("k1"), journalBig("k1v2"))
++			})
++		case 3:
++			return db.Update(func(txn *Txn) error { return txn.Delete([]byte("k2")) })
++		case 4:
++			return db.Update(func(txn *Txn) error { return txn.Set([]byte("k5"), journalSmall("k5v1")) })
++		}
++	case "mixed":
++		switch n {
++		case 1:
++			wb := db.NewManagedWriteBatch()
++			for i, ts := range []uint64{10, 11, 12} {
++				k := []byte(fmt.Sprintf("m%d", i+1))
++				if err := wb.SetEntryAt(NewEntry(k, journalSmall(string(k))), ts); err != nil {
++					return err
++				}
++			}
++			return wb.Flush()
++		case 2:
++			txn := db.NewTransactionAt(20, true)
++			if err := txn.Set([]byte("m4"), journalBig("m4")); err != nil {
++				return err
++			}
++			return txn.CommitAt(20, nil)
++		case 3:
++			wb := db.NewWriteBatchAt(30)
++			if err := wb.SetEntryAt(NewEntry([]byte("m5"), journalSmall("m5")), 31); err != nil {
++				return err
++			}
++			if err := wb.DeleteAt([]byte("m2"), 32); err != nil {
++				return err
++			}
++			return wb.Flush()
++		}
++	case "gc":
++		// x twice (each version flushed to a table, so that the tables carry
++		// the discard statistics), then y and z until the value log rotates;
++		// compaction, then garbage collection until nothing is left to move.
++		// Every live value of the first file is copied to the last one and
++		// re-logged in the WAL, and the first file is deleted.
++		if n != 1 {
++			break
++		}
++		put := func(prefix string, count int, tag string) error {
++			for i := 0; i < count; i++ {
++				k := fmt.Sprintf("%s-%03d", prefix, i)
++				if err := db.Update(func(txn *Txn) error {
++					return txn.Set([]byte(k), journalBlob(k+tag, journalGCSize))
++				}); err != nil {
++					return err
++				}
++			}
++			return nil
++		}
++		flush := func() error {
++			if err := db.Update(func(txn *Txn) error {
++				return txn.Set([]byte("drop-me"), []byte("x"))
++			}); err != nil {
++				return err
++			}
++			return db.DropPrefix([]byte("drop-"))
++		}
++		if err := put("x", 40, "/1"); err != nil {
++			return err
++		}
++		if err := flush(); err != nil {
++			return err
++		}
++		if err := put("x", 40, "/2"); err != nil {
++			return err
++		}
++		if err := flush(); err != nil {
++			return err
++		}
++		if err := put("y", 20, ""); err != nil {
++			return err
++		}
++		if err := put("z", 60, ""); err != nil {
++			return err
++		}
++		if err := db.Flatten(1); err != nil {
++			return err
++		}
++		for {
++			err := db.RunValueLogGC(0.05)
++			if err == ErrNoRewrite {
++				break
++			}
++			if err != nil {
++				return err
++			}
++		}
++		db.vlog.filesLock.RLock()
++		_, kept := db.vlog.filesMap[1]
++		db.vlog.filesLock.RUnlock()
++		if kept {
++			return fmt.Errorf("garbage collection did not retire value log file 1")
++		}
++		return nil
++	case "load":
++		var wg sync.WaitGroup
++		errs := make([]error, journalWriters)
++		for g := 0; g < journalWriters; g++ {
++			wg.Add(1)
++			go func(g int) {
++				defer wg.Done()
++				errs[g] = db.Update(func(txn *Txn) error {
++					big := fmt.Sprintf("g%d-b%d", g, n)
++					small := fmt.Sprintf("g%d-s%d", g, n)
++					if err := txn.Set([]byte(big), journalBig(big)); err != nil {
++						return err
++					}
++					return txn.Set([]byte(small), journalSmall(small))
++				})
++			}(g)
++		}
++		wg.Wait()
++		for _, err := range errs {
++			if err != nil {
++				return err
++			}
++		}
++		return nil
++	}
++	return fmt.Errorf("no step %d in scenario %q", n, scenario)
++}
++
++// TestJournalChild is the child process. It only runs when spawned by the
++// tests below.
++func TestJournalChild(t *testing.T) {
++	scenario := os.Getenv(journalChildEnv)
++	if scenario == "" {
++		t.Skip("child process of the journal recovery tests")
++	}
++	opt := journalOptions(os.Getenv(journalDirEnv))
++	var db *DB
++	var err error
++	if scenario == "mixed" {
++		db, err = OpenManaged(opt)
++	} else {
++		db, err = Open(opt)
++	}
++	if err != nil {
++		fmt.Printf("error %v\n", err)
++		os.Exit(2)
++	}
++	in := bufio.NewScanner(os.Stdin)
++	for step := 1; in.Scan(); step++ {
++		if err := journalStep(db, scenario, step); err != nil {
++			fmt.Printf("error %v\n", err)
++			os.Exit(2)
++		}
++		fmt.Printf("ok %d %d %d %d %d\n", step,
++			db.vlog.maxFid, db.vlog.woffset(), db.mt.wal.fid, db.mt.wal.writeAt)
++	}
++	// The parent went away without killing us. Leave without closing, as a
++	// crash would.
++	os.Exit(0)
++}
++
++type journalMark struct {
++	vlogFid, vlogOff, walFid, walOff uint32
++}
++
++type journalChild struct {
++	t   *testing.T
++	cmd *exec.Cmd
++	in  io.WriteCloser
++	out *bufio.Scanner
++}
++
++func startJournalChild(t *testing.T, scenario, dir string) *journalChild {
++	t.Helper()
++	cmd := exec.Command(os.Args[0], "-test.run=^TestJournalChild$")
++	cmd.Env = append(os.Environ(), journalChildEnv+"="+scenario, journalDirEnv+"="+dir)
++	cmd.Stderr = os.Stderr
++	in, err := cmd.StdinPipe()
++	require.NoError(t, err)
++	out, err := cmd.StdoutPipe()
++	require.NoError(t, err)
++	require.NoError(t, cmd.Start())
++	c := &journalChild{t: t, cmd: cmd, in: in, out: bufio.NewScanner(out)}
++	t.Cleanup(func() { c.kill() })
++	return c
++}
++
++// step asks the child for one more step and returns where its logs ended
++// once the step was acknowledged.
++func (c *journalChild) step() journalMark {
++	c.t.Helper()
++	_, err := io.WriteString(c.in, "next\n")
++	require.NoError(c.t, err)
++	require.True(c.t, c.out.Scan(), "child stopped answering")
++	var m journalMark
++	var n int
++	_, err = fmt.Sscanf(c.out.Text(), "ok %d %d %d %d %d",
++		&n, &m.vlogFid, &m.vlogOff, &m.walFid, &m.walOff)
++	require.NoError(c.t, err, "child said %q", c.out.Text())
++	return m
++}
++
++// kill stops the child the way a crash would.
++func (c *journalChild) kill() {
++	if c.cmd.ProcessState != nil {
++		return
++	}
++	_ = c.cmd.Process.Kill()
++	_ = c.cmd.Wait()
++}
++
++// runJournalChild runs the scenario for the given number of steps in a fresh
++// directory, kills the child and returns the directory and the marks.
++func runJournalChild(t *testing.T, scenario string, steps int) (string, []journalMark) {
++	t.Helper()
++	dir, err := os.MkdirTemp("", "badger-journal")
++	require.NoError(t, err)
++	t.Cleanup(func() { removeDir(dir) })
++	c := startJournalChild(t, scenario, dir)
++	marks := make([]journalMark, 0, steps)
++	for i := 0; i < steps; i++ {
++		marks = append(marks, c.step())
++	}
++	c.kill()
++	return dir, marks
++}
++
++func journalFileHashes(t *testing.T, dir string) map[string]string {
++	t.Helper()
++	entries, err := os.ReadDir(dir)
++	require.NoError(t, err)
++	hashes := make(map[string]string)
++	for _, e := range entries {
++		// Tables are outside the journal: a flush that was under way when the
++		// process died leaves one the manifest does not know about, and that
++		// one is removed on open, read-only or not, as it always was.
++		if e.IsDir() || strings.HasSuffix(e.Name(), ".sst") {
++			continue
++		}
++		data, err := os.ReadFile(filepath.Join(dir, e.Name()))
++		require.NoError(t, err)
++		sum := sha256.Sum256(data)
++		hashes[e.Name()] = fmt.Sprintf("%d:%s", len(data), hex.EncodeToString(sum[:]))
++	}
++	return hashes
++}
++
++// zeroTail overwrites path from off to its end with zeros, as if the pages
++// after off had never reached the disk.
++func zeroTail(t *testing.T, path string, off uint32) {
++	t.Helper()
++	fi, err := os.Stat(path)
++	require.NoError(t, err)
++	f, err := os.OpenFile(path, os.O_WRONLY, 0)
++	require.NoError(t, err)
++	defer f.Close()
++	_, err = f.WriteAt(make([]byte, fi.Size()-int64(off)), int64(off))
++	require.NoError(t, err)
++}
++
++func openJournal(t *testing.T, dir string, readOnly, managed bool) (*DB, error) {
++	t.Helper()
++	opt := journalOptions(dir)
++	opt.ReadOnly = readOnly
++	if managed {
++		return OpenManaged(opt)
++	}
++	return Open(opt)
++}
++
++// journalGet returns the value of key, or "" and false when it is absent.
++func journalGet(t *testing.T, db *DB, key string) (string, bool) {
++	t.Helper()
++	var txn *Txn
++	if db.opt.managedTxns {
++		txn = db.NewTransactionAt(math.MaxUint64, false)
++	} else {
++		txn = db.NewTransaction(false)
++	}
++	defer txn.Discard()
++	item, err := txn.Get([]byte(key))
++	if err == ErrKeyNotFound {
++		return "", false
++	}
++	require.NoError(t, err)
++	val, err := item.ValueCopy(nil)
++	require.NoError(t, err)
++	return string(val), true
++}
++
++func requireJournalValue(t *testing.T, db *DB, key string, want []byte) {
++	t.Helper()
++	got, ok := journalGet(t, db, key)
++	require.True(t, ok, "key %s is missing", key)
++	require.Equal(t, string(want), got, "key %s", key)
++}
++
++func requireJournalAbsent(t *testing.T, db *DB, key string) {
++	t.Helper()
++	got, ok := journalGet(t, db, key)
++	require.False(t, ok, "key %s should be absent, has %q", key, got)
++}
++
++// requireReadOnlyRefuses opens the DB read-only, expects an error and
++// expects every file to be exactly as it was.
++func requireReadOnlyRefuses(t *testing.T, dir string, managed bool) {
++	t.Helper()
++	before := journalFileHashes(t, dir)
++	db, err := openJournal(t, dir, true, managed)
++	if err == nil {
++		require.NoError(t, db.Close())
++	}
++	require.Error(t, err, "read-only open must refuse a torn history")
++	require.Equal(t, before, journalFileHashes(t, dir), "read-only open changed a file")
++}
++
++func TestJournalTornValueLogTailKeepsTransactionsWhole(t *testing.T) {
++	// A tear in the middle of the second transaction's values, emulating
++	// pages that never reached the disk: the file keeps its length.
++	t.Run("zeroed", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "vlog", 4)
++		vlogPath := vlogFilePath(dir, marks[1].vlogFid)
++		require.Equal(t, marks[0].vlogFid, marks[1].vlogFid)
++		zeroTail(t, vlogPath, marks[0].vlogOff+(marks[1].vlogOff-marks[0].vlogOff)/2)
++
++		requireReadOnlyRefuses(t, dir, false)
++
++		db, err := openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		// The first transaction is whole, the torn one is gone entirely —
++		// including the part of it that lived in the WAL — and so is
++		// everything committed after it.
++		requireJournalValue(t, db, "k1", journalBig("k1v1"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		requireJournalAbsent(t, db, "k4")
++		requireJournalAbsent(t, db, "k5")
++
++		// Writes after recovery win, and stay won.
++		require.NoError(t, db.Update(func(txn *Txn) error {
++			return txn.Set([]byte("k1"), journalBig("k1v3"))
++		}))
++		requireJournalValue(t, db, "k1", journalBig("k1v3"))
++		require.NoError(t, db.Close())
++		db, err = openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "k1", journalBig("k1v3"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		require.NoError(t, db.Close())
++	})
++
++	// The file cut exactly where the first transaction's values end: that
++	// transaction is whole, the next one is not.
++	t.Run("truncated at a record boundary", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "vlog", 4)
++		require.NoError(t, os.Truncate(vlogFilePath(dir, marks[0].vlogFid), int64(marks[0].vlogOff)))
++
++		requireReadOnlyRefuses(t, dir, false)
++
++		db, err := openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "k1", journalBig("k1v1"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		requireJournalAbsent(t, db, "k4")
++		requireJournalAbsent(t, db, "k5")
++		require.NoError(t, db.Close())
++	})
++
++	// A tear in the WAL itself, with the value log whole.
++	t.Run("torn wal", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "vlog", 4)
++		require.Equal(t, marks[0].walFid, marks[1].walFid)
++		zeroTail(t, filepath.Join(dir, fmt.Sprintf("%05d%s", marks[1].walFid, memFileExt)), marks[1].walOff-5)
++
++		requireReadOnlyRefuses(t, dir, false)
++
++		db, err := openJournal(t, dir, false, false)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "k1", journalBig("k1v1"))
++		requireJournalValue(t, db, "k2", journalSmall("k2v1"))
++		requireJournalAbsent(t, db, "k3")
++		requireJournalAbsent(t, db, "k4")
++		requireJournalAbsent(t, db, "k5")
++		require.NoError(t, db.Close())
++	})
++}
++
++func TestJournalMixedVersionTransactionWholeAfterTear(t *testing.T) {
++	checkWhole := func(t *testing.T, db *DB) {
++		t.Helper()
++		requireJournalValue(t, db, "m1", journalSmall("m1"))
++		requireJournalAbsent(t, db, "m2") // deleted at 32
++		requireJournalValue(t, db, "m3", journalSmall("m3"))
++		requireJournalValue(t, db, "m4", journalBig("m4"))
++		requireJournalValue(t, db, "m5", journalSmall("m5"))
++	}
++
++	t.Run("killed without a tear", func(t *testing.T) {
++		dir, _ := runJournalChild(t, "mixed", 3)
++		before := journalFileHashes(t, dir)
++		db, err := openJournal(t, dir, true, true)
++		require.NoError(t, err)
++		checkWhole(t, db)
++		require.NoError(t, db.Close())
++		require.Equal(t, before, journalFileHashes(t, dir))
++
++		db, err = openJournal(t, dir, false, true)
++		require.NoError(t, err)
++		checkWhole(t, db)
++		require.NoError(t, db.Close())
++	})
++
++	t.Run("torn inside the mixed transaction", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "mixed", 3)
++		zeroTail(t, filepath.Join(dir, fmt.Sprintf("%05d%s", marks[0].walFid, memFileExt)), marks[0].walOff-5)
++
++		requireReadOnlyRefuses(t, dir, true)
++
++		db, err := openJournal(t, dir, false, true)
++		require.NoError(t, err)
++		for _, k := range []string{"m1", "m2", "m3", "m4", "m5"} {
++			requireJournalAbsent(t, db, k)
++		}
++		require.NoError(t, db.Close())
++	})
++
++	t.Run("torn after the mixed transaction", func(t *testing.T) {
++		dir, marks := runJournalChild(t, "mixed", 3)
++		zeroTail(t, filepath.Join(dir, fmt.Sprintf("%05d%s", marks[2].walFid, memFileExt)), marks[2].walOff-5)
++
++		requireReadOnlyRefuses(t, dir, true)
++
++		db, err := openJournal(t, dir, false, true)
++		require.NoError(t, err)
++		requireJournalValue(t, db, "m1", journalSmall("m1"))
++		requireJournalValue(t, db, "m2", journalSmall("m2"))
++		requireJournalValue(t, db, "m3", journalSmall("m3"))
++		requireJournalValue(t, db, "m4", journalBig("m4"))
++		requireJournalAbsent(t, db, "m5")
++		require.NoError(t, db.Close())
++	})
++}
++
++func TestJournalReadOnlyOpenAfterKillServesAcknowledgedCommits(t *testing.T) {
++	const steps = 40
++	dir, marks := runJournalChild(t, "load", steps)
++	last := marks[len(marks)-1]
++	require.Greater(t, last.vlogFid, uint32(1), "the value log should have rotated")
++	require.Greater(t, last.walFid, uint32(1), "the memtable should have rotated")
++
++	check := func(t *testing.T, db *DB) {
++		t.Helper()
++		for g := 0; g < journalWriters; g++ {
++			for n := 1; n <= steps; n++ {
++				big := fmt.Sprintf("g%d-b%d", g, n)
++				small := fmt.Sprintf("g%d-s%d", g, n)
++				requireJournalValue(t, db, big, journalBig(big))
++				requireJournalValue(t, db, small, journalSmall(small))
++			}
++		}
++	}
++
++	before := journalFileHashes(t, dir)
++	db, err := openJournal(t, dir, true, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Close())
++	require.Equal(t, before, journalFileHashes(t, dir), "read-only open changed a file")
++
++	db, err = openJournal(t, dir, false, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Update(func(txn *Txn) error {
++		return txn.Set([]byte("after"), journalBig("after"))
++	}))
++	requireJournalValue(t, db, "after", journalBig("after"))
++	require.NoError(t, db.Close())
++}
++
++// Garbage collection deletes a value log file once every live value in it
++// has been copied to the last file and re-logged in the WAL. A crash before
++// the next flush leaves the WAL still pointing at the deleted file for those
++// values' first records. That is not a tear: nothing acknowledged was lost,
++// and recovery, read-only or not, serves the whole history.
++func TestJournalRetiredValueLogFileIsNotATear(t *testing.T) {
++	dir, marks := runJournalChild(t, "gc", 1)
++	require.Greater(t, marks[0].vlogFid, uint32(1), "the value log should have rotated")
++	require.NoFileExists(t, filepath.Join(dir, "000001.vlog"), "file 1 should have been retired")
++
++	check := func(t *testing.T, db *DB) {
++		t.Helper()
++		for i := 0; i < 40; i++ {
++			k := fmt.Sprintf("x-%03d", i)
++			requireJournalValue(t, db, k, journalBlob(k+"/2", journalGCSize))
++		}
++		for i := 0; i < 20; i++ {
++			k := fmt.Sprintf("y-%03d", i)
++			requireJournalValue(t, db, k, journalBlob(k, journalGCSize))
++		}
++		for i := 0; i < 60; i++ {
++			k := fmt.Sprintf("z-%03d", i)
++			requireJournalValue(t, db, k, journalBlob(k, journalGCSize))
++		}
++	}
++
++	before := journalFileHashes(t, dir)
++	db, err := openJournal(t, dir, true, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Close())
++	require.Equal(t, before, journalFileHashes(t, dir), "read-only open changed a file")
++
++	db, err = openJournal(t, dir, false, false)
++	require.NoError(t, err)
++	check(t, db)
++	require.NoError(t, db.Close())
++}
++
++// A WAL written by an earlier build holds transactions with entries of
++// different versions and no markers around them. They still come back whole.
++func TestJournalOldTransactionWithoutMarkersReplaysWhole(t *testing.T) {
++	dir, err := os.MkdirTemp("", "badger-journal")
++	require.NoError(t, err)
++	defer removeDir(dir)
++
++	opt := journalOptions(dir)
++	db0, err := OpenManaged(opt)
++	require.NoError(t, err)
++	defer func() { require.NoError(t, db0.Close()) }()
++	for i, ts := range []uint64{10, 11, 12} {
++		k := fmt.Sprintf("o%d", i+1)
++		require.NoError(t, db0.mt.Put(y.KeyWithTs([]byte(k), ts), y.ValueStruct{Value: journalSmall(k)}))
++	}
++	require.NoError(t, db0.mt.SyncWAL())
++	// Simulate a crash by not closing db0, but releasing the locks.
++	require.NoError(t, db0.dirLockGuard.release())
++	db0.dirLockGuard = nil
++	if db0.valueDirGuard != nil {
++		require.NoError(t, db0.valueDirGuard.release())
++		db0.valueDirGuard = nil
++	}
++
++	db1, err := openJournal(t, dir, true, true)
++	require.NoError(t, err)
++	for i := 1; i <= 3; i++ {
++		k := fmt.Sprintf("o%d", i)
++		requireJournalValue(t, db1, k, journalSmall(k))
++	}
++	require.NoError(t, db1.Close())
++}
+diff --git a/memtable.go b/memtable.go
+index 161a463..f107477 100644
+--- a/memtable.go
++++ b/memtable.go
+@@ -38,6 +38,9 @@ type memTable struct {
+ 	maxVersion uint64
+ 	opt        Options
+ 	buf        *bytes.Buffer
++	// vptrOK tells replay whether a value pointer found in the WAL still
++	// addresses a record the value log holds.
++	vptrOK func(valuePointer) bool
+ }
+ 
+ func (db *DB) openMemTables(opt Options) error {
+@@ -98,9 +101,10 @@ func (db *DB) openMemTable(fid, flags int) (*memTable, error) {
+ 	filepath := db.mtFilePath(fid)
+ 	s := skl.NewSkiplist(arenaSize(db.opt))
+ 	mt := &memTable{
+-		sl:  s,
+-		opt: db.opt,
+-		buf: &bytes.Buffer{},
++		sl:     s,
++		opt:    db.opt,
++		buf:    &bytes.Buffer{},
++		vptrOK: db.vlog.contains,
+ 	}
+ 	// We don't need to create the wal for the skiplist in in-memory mode so return the mt.
+ 	if db.opt.InMemory {
+@@ -202,12 +206,19 @@ func (mt *memTable) UpdateSkipList() error {
+ 	if mt.wal == nil || mt.sl == nil {
+ 		return nil
+ 	}
+-	endOff, err := mt.wal.iterate(true, 0, mt.replayFunction(mt.opt))
++	endOff, stopAt, err := mt.wal.replay(0, mt.replayFunction(mt.opt), mt.vptrOK)
+ 	if err != nil {
+ 		return y.Wrapf(err, "while iterating wal: %s", mt.wal.Fd.Name())
+ 	}
+-	if endOff < mt.wal.size.Load() && mt.opt.ReadOnly {
+-		return y.Wrapf(ErrTruncateNeeded, "end offset: %d < size: %d", endOff, mt.wal.size.Load())
++	if mt.opt.ReadOnly {
++		// The file is pre-allocated, so a tail of zeros after the last record
++		// is the normal state after an unclean stop and needs no repair. Any
++		// other bytes there are a damaged record, and a read-only DB must
++		// not repair it.
++		if !mt.wal.zeroFrom(stopAt) {
++			return y.Wrapf(ErrTruncateNeeded, "end offset: %d < size: %d", endOff, mt.wal.size.Load())
++		}
++		return nil
+ 	}
+ 	return mt.wal.Truncate(int64(endOff))
+ }
+@@ -431,6 +442,41 @@ func (lf *logFile) doneWriting(offset uint32) error {
+ // iterate iterates over log file. It doesn't not allocate new memory for every kv pair.
+ // Therefore, the kv pair is only valid for the duration of fn call.
+ func (lf *logFile) iterate(readOnly bool, offset uint32, fn logEntry) (uint32, error) {
++	end, _, err := lf.replay(offset, fn, nil)
++	return end, err
++}
++
++// lostValue reports whether e's value lives in the value log at a place the
++// value log no longer holds, according to vptrOK.
++func lostValue(e *Entry, vptrOK func(valuePointer) bool) bool {
++	if vptrOK == nil || e.meta&bitValuePointer == 0 {
++		return false
++	}
++	if uintptr(len(e.Value)) < vptrSize {
++		return true
++	}
++	var vp valuePointer
++	vp.Decode(e.Value)
++	return !vptrOK(vp)
++}
++
++// zeroFrom reports whether nothing but zeros follows off in the file.
++func (lf *logFile) zeroFrom(off uint32) bool {
++	if int64(off) >= int64(len(lf.Data)) {
++		return true
++	}
++	return len(bytes.TrimLeft(lf.Data[off:], "\x00")) == 0
++}
++
++// replay is iterate with two additions. When vptrOK is given, an entry whose
++// value lives in the value log is checked against it before anything of its
++// transaction is applied, so a pointer to a lost value stops the replay in
++// front of that transaction. Besides the offset up to which the log was
++// applied, replay returns the offset of the record it stopped at: the one it
++// could not read, or the one it could not accept — a transaction with a
++// missing or mismatching end marker, an entry pointing at a lost value.
++func (lf *logFile) replay(offset uint32, fn logEntry, vptrOK func(valuePointer) bool) (
++	uint32, uint32, error) {
+ 	if offset == 0 {
+ 		// If offset is set to zero, let's advance past the encryption key header.
+ 		offset = vlogHeaderSize
+@@ -445,14 +491,19 @@ func (lf *logFile) iterate(readOnly bool, offset uint32, fn logEntry) (uint32, e
+ 		lf:           lf,
+ 	}
+ 
+-	var lastCommit uint64
++	// lastCommit is the version of the entry that opened the transaction
++	// being read, or zero outside a transaction; txnMax is the largest
++	// version seen in it, which its end marker must repeat.
++	var lastCommit, txnMax uint64
+ 	var validEndOffset uint32 = offset
+ 
+ 	var entries []*Entry
+ 	var vptrs []valuePointer
+ 
++	var stopAt uint32
+ loop:
+ 	for {
++		stopAt = read.recordOffset
+ 		e, err := read.Entry(reader)
+ 		switch {
+ 		// We have not reached the end of the file but the entry we read is
+@@ -463,7 +514,7 @@ loop:
+ 		case err == io.ErrUnexpectedEOF || err == errTruncate:
+ 			break loop
+ 		case err != nil:
+-			return 0, err
++			return 0, 0, err
+ 		case e == nil:
+ 			continue
+ 		case e.isZero():
+@@ -483,19 +534,24 @@ loop:
+ 			if lastCommit == 0 {
+ 				lastCommit = txnTs
+ 			}
+-			if lastCommit != txnTs {
+-				break loop
++			if txnTs > txnMax {
++				txnMax = txnTs
+ 			}
+ 			entries = append(entries, e)
+ 			vptrs = append(vptrs, vp)
+ 
+ 		case e.meta&bitFinTxn > 0:
+ 			txnTs, err := strconv.ParseUint(string(e.Value), 10, 64)
+-			if err != nil || lastCommit != txnTs {
++			if err != nil || lastCommit == 0 || txnTs != txnMax {
+ 				break loop
+ 			}
++			for _, e := range entries {
++				if lostValue(e, vptrOK) {
++					break loop
++				}
++			}
+ 			// Got the end of txn. Now we can store them.
+-			lastCommit = 0
++			lastCommit, txnMax = 0, 0
+ 			validEndOffset = read.recordOffset
+ 
+ 			for i, e := range entries {
+@@ -504,7 +560,7 @@ loop:
+ 					if err == errStop {
+ 						break
+ 					}
+-					return 0, errFile(err, lf.path, "Iteration function")
++					return 0, 0, errFile(err, lf.path, "Iteration function")
+ 				}
+ 			}
+ 			entries = entries[:0]
+@@ -516,17 +572,20 @@ loop:
+ 				// We shouldn't get this entry in the middle of a transaction.
+ 				break loop
+ 			}
++			if lostValue(e, vptrOK) {
++				break loop
++			}
+ 			validEndOffset = read.recordOffset
+ 
+ 			if err := fn(*e, vp); err != nil {
+ 				if err == errStop {
+ 					break
+ 				}
+-				return 0, errFile(err, lf.path, "Iteration function")
++				return 0, 0, errFile(err, lf.path, "Iteration function")
+ 			}
+ 		}
+ 	}
+-	return validEndOffset, nil
++	return validEndOffset, stopAt, nil
+ }
+ 
+ // Zero out the next entry to deal with any crashes.
+diff --git a/txn.go b/txn.go
+index 9c916d1..5e852af 100644
+--- a/txn.go
++++ b/txn.go
+@@ -532,12 +532,17 @@ func (txn *Txn) commitAndSend() (func() error, error) {
+ 		return nil, ErrConflict
+ 	}
+ 
+-	keepTogether := true
++	// Every transaction is bracketed by markers in the log so that replay can
++	// apply it whole or not at all. Entries may carry their own versions
++	// (SetEntryAt in managed mode), and commitTs may then even be zero, so the
++	// end marker carries the largest version in the transaction.
++	var maxVersion uint64
+ 	setVersion := func(e *Entry) {
+ 		if e.version == 0 {
+ 			e.version = commitTs
+-		} else {
+-			keepTogether = false
++		}
++		if e.version > maxVersion {
++			maxVersion = e.version
+ 		}
+ 	}
+ 	for _, e := range txn.pendingWrites {
+@@ -555,14 +560,7 @@ func (txn *Txn) commitAndSend() (func() error, error) {
+ 		// Suffix the keys with commit ts, so the key versions are sorted in
+ 		// descending order of commit timestamp.
+ 		e.Key = y.KeyWithTs(e.Key, e.version)
+-		// Add bitTxn only if these entries are part of a transaction. We
+-		// support SetEntryAt(..) in managed mode which means a single
+-		// transaction can have entries with different timestamps. If entries
+-		// in a single transaction have different timestamps, we don't add the
+-		// transaction markers.
+-		if keepTogether {
+-			e.meta |= bitTxn
+-		}
++		e.meta |= bitTxn
+ 		entries = append(entries, e)
+ 	}
+ 
+@@ -579,16 +577,14 @@ func (txn *Txn) commitAndSend() (func() error, error) {
+ 		processEntry(e)
+ 	}
+ 
+-	if keepTogether {
+-		// CommitTs should not be zero if we're inserting transaction markers.
+-		y.AssertTrue(commitTs != 0)
+-		e := &Entry{
+-			Key:   y.KeyWithTs(txnKey, commitTs),
+-			Value: []byte(strconv.FormatUint(commitTs, 10)),
+-			meta:  bitFinTxn,
+-		}
+-		entries = append(entries, e)
+-	}
++	// commitPrecheck guarantees a non-zero commitTs whenever no entry has a
++	// version of its own.
++	y.AssertTrue(maxVersion != 0)
++	entries = append(entries, &Entry{
++		Key:   y.KeyWithTs(txnKey, maxVersion),
++		Value: []byte(strconv.FormatUint(maxVersion, 10)),
++		meta:  bitFinTxn,
++	})
+ 
+ 	req, err := txn.db.sendToWriteCh(entries)
+ 	if err != nil {
+diff --git a/value.go b/value.go
+index e042651..c343473 100644
+--- a/value.go
++++ b/value.go
+@@ -580,26 +580,24 @@ func (vlog *valueLog) init(db *DB) {
+ 	db.logToSyncChan(endVLogInitMsg)
+ }
+ 
+-func (vlog *valueLog) open(db *DB) error {
+-	// We don't need to open any vlog files or collect stats for GC if DB is opened
+-	// in InMemory mode. InMemory mode doesn't create any files/directories on disk.
+-	if db.opt.InMemory {
++// openFiles opens the value log files found on disk and establishes how much
++// of each one holds records. Files that were rotated out were cut down to
++// their records when they were retired; the last file is pre-allocated and
++// may end in whatever an unclean stop left behind, so its size is what can be
++// parsed from it. Nothing is written: this runs before the memtables are
++// replayed, in read-only mode too, so that replay can tell a pointer into a
++// lost value from a good one.
++func (vlog *valueLog) openFiles() error {
++	if vlog.opt.InMemory {
+ 		return nil
+ 	}
+-
+ 	if err := vlog.populateFilesMap(); err != nil {
+ 		return err
+ 	}
+-	// If no files are found, then create a new file.
+ 	if len(vlog.filesMap) == 0 {
+-		if vlog.opt.ReadOnly {
+-			return nil
+-		}
+-		_, err := vlog.createVlogFile()
+-		return y.Wrapf(err, "Error while creating log file in valueLog.open")
++		return nil
+ 	}
+-	fids := vlog.sortedFids()
+-	for _, fid := range fids {
++	for _, fid := range vlog.sortedFids() {
+ 		lf, ok := vlog.filesMap[fid]
+ 		y.AssertTrue(ok)
+ 
+@@ -612,20 +610,8 @@ func (vlog *valueLog) open(db *DB) error {
+ 			2*vlog.opt.ValueLogFileSize); err != nil {
+ 			return y.Wrapf(err, "Open existing file: %q", lf.path)
+ 		}
+-		// We shouldn't delete the maxFid file.
+-		if lf.size.Load() == vlogHeaderSize && fid != vlog.maxFid && !vlog.opt.ReadOnly {
+-			vlog.opt.Infof("Deleting empty file: %s", lf.path)
+-			if err := lf.Delete(); err != nil {
+-				return y.Wrapf(err, "while trying to delete empty file: %s", lf.path)
+-			}
+-			delete(vlog.filesMap, fid)
+-		}
+ 	}
+-
+-	if vlog.opt.ReadOnly {
+-		return nil
+-	}
+-	// Now we can read the latest value log file, and see if it needs truncation. We could
++	// Read the latest value log file to see where its records end. We could
+ 	// technically do this over all the value log files, but that would mean slowing down the value
+ 	// log open.
+ 	last, ok := vlog.filesMap[vlog.maxFid]
+@@ -637,7 +623,51 @@ func (vlog *valueLog) open(db *DB) error {
+ 	if err != nil {
+ 		return y.Wrapf(err, "while iterating over: %s", last.path)
+ 	}
+-	if err := last.Truncate(int64(lastOff)); err != nil {
++	last.size.Store(lastOff)
++	return nil
++}
++
++// contains reports whether vp addresses a record the value log holds, as
++// established by openFiles. For use while no writes are in flight.
++func (vlog *valueLog) contains(vp valuePointer) bool {
++	lf, ok := vlog.filesMap[vp.Fid]
++	if !ok {
++		// A file that is gone was retired by garbage collection, which had
++		// moved every live value out of it first; an unclean stop never
++		// removes a file. The entry is stale, not torn.
++		return true
++	}
++	return uint64(vp.Offset)+uint64(vp.Len) <= uint64(lf.size.Load())
++}
++
++// open makes the value log writable after openFiles: empty retired files are
++// deleted, the last file is cut down to its records, and a fresh file is
++// created to write into. A read-only DB leaves the files as they are.
++func (vlog *valueLog) open(db *DB) error {
++	// We don't need to open any vlog files or collect stats for GC if DB is opened
++	// in InMemory mode. InMemory mode doesn't create any files/directories on disk.
++	if db.opt.InMemory || vlog.opt.ReadOnly {
++		return nil
++	}
++	// If no files are found, then create a new file.
++	if len(vlog.filesMap) == 0 {
++		_, err := vlog.createVlogFile()
++		return y.Wrapf(err, "Error while creating log file in valueLog.open")
++	}
++	for _, fid := range vlog.sortedFids() {
++		lf := vlog.filesMap[fid]
++		// We shouldn't delete the maxFid file.
++		if lf.size.Load() == vlogHeaderSize && fid != vlog.maxFid {
++			vlog.opt.Infof("Deleting empty file: %s", lf.path)
++			if err := lf.Delete(); err != nil {
++				return y.Wrapf(err, "while trying to delete empty file: %s", lf.path)
++			}
++			delete(vlog.filesMap, fid)
++		}
++	}
++	last, ok := vlog.filesMap[vlog.maxFid]
++	y.AssertTrue(ok)
++	if err := last.Truncate(int64(last.size.Load())); err != nil {
+ 		return y.Wrapf(err, "while truncating last value log file: %s", last.path)
+ 	}
+ 
+
+REFERENCE_PATCH

harbor/tasks/journal_recovery_after_unclean_stop/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "journal_recovery_after_unclean_stop"
+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/journal_recovery_after_unclean_stop/tests/Dockerfile

@@ -0,0 +1,9 @@
+FROM ec-swe-badger: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/journal_recovery_after_unclean_stop/tests/config.json

@@ -0,0 +1,132 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "journal_recovery_after_unclean_stop",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-badger:source-v2",
+  "source_image_id": "sha256:07828139bd6f6ce1204b51a18fc72537c75e861e64d27e3aac0e12d9e1cc451a",
+  "provenance": {
+    "repository": "dgraph-io/badger",
+    "environment_id": "5c04bdfd-7abc-40a6-8c86-cfe9e13930b5",
+    "build": 2,
+    "build_id": "f683e58c-4463-4e44-bfc1-c87834bfe006",
+    "hosted_task": "journal_recovery_after_unclean_stop",
+    "task_version": 1,
+    "source_archive_sha256": "3745442faf694143dd96944f41986e939cdfa02edac2676bbe5533dd0b0c5a34",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "torn_value_log_tail_keeps_transactions_whole",
+      0.25,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "mixed_version_transaction_whole_after_tear",
+      0.19,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "history_comes_back_as_a_prefix",
+      0.16,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "writes_after_recovery_win",
+      0.12,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "read_only_open_after_kill_serves_acknowledged_commits",
+      0.1,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "read_only_open_refuses_a_torn_history",
+      0.06,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "history_from_released_build_replays_whole",
+      0.06,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "build_vet_and_targeted_tests_green",
+      0.06,
+      false,
+      "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": "87a7c5c754cb9669455e2fac0406278b4bf4679b8deeeebae8fa96e0e047ec2d",
+    "/app/tasks.py": "bbf54c844b7da9fd1349ce772688c1122e00b4423873eea5feef6f3843983690",
+    "/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": "e235e9cfb731a8d638fe30c29652eb17c5e2241a76c3b1a674fca88f0f792110",
+    "/hud/grader/run_grading.sh": "5f527d179db7944b29d59613561bd3dcfacff3b488b8028a4f3896263c3e51f9",
+    "/hud/grader/driver/build_driver.sh": "441f9f33f5c46dfe5e37c50f80bd38c085d534fc23997fe1ce4fb31e02ff32d2",
+    "/hud/grader/driver/child.go": "5364e132b51e3f777326f9eca47f5774f1cb19e9906dc9e8019cc1b6b7a8faa6",
+    "/hud/grader/driver/fixtures.go": "dd98bbe8d6677a2d5444b0f40fee8d9ce18ea66e0d5a56c6e1b1a252047d6148",
+    "/hud/grader/driver/go.mod.tmpl": "37a9e476e0340c8761ee1acec40b52ecb51e83add3e4af67c1882af3cda3bd32",
+    "/hud/grader/driver/go.sum": "1b55494a77d5610e01a7f7bd4973e66b0f913d8c275195d80fa438e520399cf7",
+    "/hud/grader/driver/main.go": "86325fba79d5f649ae2230436729c867e45bd61c46146a07d7fac11e1b27bf18",
+    "/hud/grader/driver/observe.go": "d6c392bb9326c51af06ddd0775a1989e62a6b9ffb9927e08c5f024f800ab13a0",
+    "/hud/grader/driver/program.go": "66b27109098e62f14f4ebe7fe5ab9c391445a6b79b85ec247024ebb4963dd4ac",
+    "/hud/grader/driver/surgery.go": "591ebfbfab53d861121e07ab860dd0d9abf0bd069fd0f36ef72e008d3a1b9756",
+    "/hud/grader/driver/verify.go": "5253733c38e8d6d4662e7e4ed0391e0f77f1092947bd4226d5d81f4a08125ce5",
+    "/hud/grader/fixtures/killed_and_whole.tar.gz": "1493ffe05f758ea41e59b8a42b8e5e307e2534ff84d26c4fd7fa018dfd91d252",
+    "/hud/grader/fixtures/torn_log_with_older_ones_behind_it.tar.gz": "084f0ca0babf200047b55f2702addac5c0203bf063cde3c9f3a76cc1664e6e7c",
+    "/hud/grader/fixtures/torn_value_log.tar.gz": "8da672d8a0f83f69f83936eb94ce36578b81fd325c260b20d2a2745785a1f6be",
+    "/hud/grader/tests/check_journal.py": "8945d49e75a4f2f94f14f1cfb704274a88fe3a457f57e3c3dddc8fc99346cab1",
+    "/hud/grader/tests/new_vet_diagnostics.py": "219421ebc76649bf399c54128f2bfb53b5d7b7868c6e342d144fc570ed20e5cc"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'go version' || go version"
+    ],
+    [
+      "/usr/local/bin/python3",
+      "--version"
+    ]
+  ]
+}

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

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

harbor/tasks/journal_recovery_after_unclean_stop/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/journal_recovery_after_unclean_stop/tests/test.sh

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

harbor/tasks/journal_recovery_after_unclean_stop/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": [
+    "journal_recovery_after_unclean_stop",
     "bazel_remote_disk_eviction_accounting_contract",
     "celery_retry_expires_countdown_contract",
     "coredns_rewrite_svcb_opt",