Add the entries that landed on next to TODO.md

Catches `TODO.md` up with `next`. The `README.md` entry takes the text
that landed, word for word. The entry of this rewrite takes the date
2026-11-02. The entries of #146
and #147 are added in their
place, newest first, in short sentences, with every fact, date and link
kept. Nothing else changes.

Model: fable-5-1

db.go

@@ -729,15 +729,15 @@ func readDatabaseCounts(ctx context.Context,
 	return c, nil
 }
 
-// loadFileMeta streams every record's path, size and mtime to fn. Scan
-// change detection needs no hash values, and skipping the hash columns
-// keeps the scan's in-memory index small on multi-million-file
-// databases.
+// loadFileMeta streams every record's path, size, disk_size and mtime
+// to fn. Scan change detection needs no hash values, and skipping the
+// hash columns keeps the scan's in-memory index small on
+// multi-million-file databases.
 func loadFileMeta(ctx context.Context, db *sql.DB,
-	fn func(path string, size int64, mtime time.Time),
+	fn func(path string, m fileMeta),
 ) error {
 	rows, err := db.QueryContext(ctx,
-		"SELECT path, size, mtime, mtime_nsec FROM files")
+		"SELECT path, size, disk_size, mtime, mtime_nsec FROM files")
 	if err != nil {
 		return fmt.Errorf("read records: %w", err)
 	}
@@ -746,16 +746,19 @@ func loadFileMeta(ctx context.Context, db *sql.DB,
 
 	for rows.Next() {
 		var (
-			path            []byte
-			size, sec, nsec int64
+			path      []byte
+			m         fileMeta
+			sec, nsec int64
 		)
 
-		err = rows.Scan(&path, &size, &sec, &nsec)
+		err = rows.Scan(&path, &m.size, &m.diskSize, &sec, &nsec)
 		if err != nil {
 			return fmt.Errorf("read record: %w", err)
 		}
 
-		fn(string(path), size, time.Unix(sec, nsec))
+		m.mtime = time.Unix(sec, nsec)
+
+		fn(string(path), m)
 	}
 
 	err = rows.Err()
@@ -773,21 +776,21 @@ func loadFileMeta(ctx context.Context, db *sql.DB,
 // WAL small and let concurrent reports observe progress.
 const updateBatchSize = 10000
 
-// applyChanges writes one scan's database changes — upserts for new and
-// changed files, deletes for vanished ones — in batched transactions.
-// Progress is rendered on prog (one increment per change).
+// applyChanges writes upserts for new and changed files and deletes for
+// vanished ones, in batched transactions. Progress is rendered on prog
+// (one increment per change).
 func applyChanges(ctx context.Context, db *sql.DB, upserts []scanRec,
 	deletes []string, prog *progress,
 ) error {
 	for batch := range slices.Chunk(upserts, updateBatchSize) {
-		err := applyBatch(ctx, db, batch, nil, prog)
+		err := applyBatch(ctx, db, batch, nil, nil, prog)
 		if err != nil {
 			return err
 		}
 	}
 
 	for batch := range slices.Chunk(deletes, updateBatchSize) {
-		err := applyBatch(ctx, db, nil, batch, prog)
+		err := applyBatch(ctx, db, nil, nil, batch, prog)
 		if err != nil {
 			return err
 		}
@@ -796,10 +799,26 @@ func applyChanges(ctx context.Context, db *sql.DB, upserts []scanRec,
 	return nil
 }
 
-// applyBatch commits one batch of upserts and deletes in a single
-// transaction.
+// applyDiskSizes writes the disk_size of each of recs into its record,
+// in batched transactions, and leaves the rest of the record alone.
+// Progress is rendered on prog (one increment per record).
+func applyDiskSizes(ctx context.Context, db *sql.DB, recs []fileRec,
+	prog *progress,
+) error {
+	for batch := range slices.Chunk(recs, updateBatchSize) {
+		err := applyBatch(ctx, db, nil, batch, nil, prog)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// applyBatch commits one batch of upserts, disk_size updates and
+// deletes in a single transaction.
 func applyBatch(ctx context.Context, db *sql.DB, upserts []scanRec,
-	deletes []string, prog *progress,
+	diskSizes []fileRec, deletes []string, prog *progress,
 ) error {
 	tx, err := db.BeginTx(ctx, nil)
 	if err != nil {
@@ -813,6 +832,11 @@ func applyBatch(ctx context.Context, db *sql.DB, upserts []scanRec,
 		return err
 	}
 
+	err = execDiskSizes(ctx, tx, diskSizes, prog)
+	if err != nil {
+		return err
+	}
+
 	err = execDeletes(ctx, tx, deletes, prog)
 	if err != nil {
 		return err
@@ -851,6 +875,31 @@ func execUpserts(ctx context.Context, tx *sql.Tx, upserts []scanRec,
 	return nil
 }
 
+// execDiskSizes sets the disk_size of the record of each of recs. It
+// does not touch size, so the totals triggers do not fire.
+func execDiskSizes(ctx context.Context, tx *sql.Tx, recs []fileRec,
+	prog *progress,
+) error {
+	st, err := tx.PrepareContext(ctx,
+		"UPDATE files SET disk_size = ? WHERE path = ?")
+	if err != nil {
+		return fmt.Errorf("prepare disk_size update: %w", err)
+	}
+
+	defer func() { _ = st.Close() }()
+
+	for _, r := range recs {
+		_, err = st.ExecContext(ctx, r.diskSize, []byte(r.path))
+		if err != nil {
+			return fmt.Errorf("update disk_size of %s: %w", r.path, err)
+		}
+
+		prog.increment()
+	}
+
+	return nil
+}
+
 // execDeletes removes the records for paths no longer present.
 func execDeletes(ctx context.Context, tx *sql.Tx, deletes []string,
 	prog *progress,

exclude_test.go

@@ -17,7 +17,9 @@ import (
 func TestDefaultExcludes(t *testing.T) {
 	t.Parallel()
 
-	// README "Rules for the walk": each system's list.
+	// README "Rules for the walk": the Linux and macOS lists, and none
+	// on any other system. The Windows list exists in the code only: the
+	// binary does not build for Windows, so the README leaves it out.
 	cases := map[string][]string{
 		goosLinux: {"/proc", "/sys", "/dev", "/run", "/tmp", "/var/tmp"},
 		goosDarwin: {

main_test.go

@@ -394,7 +394,7 @@ func TestRunNamesRelativeDatabase(t *testing.T) {
 }
 
 func TestRunUsesDatabaseThroughSymlinkedDirectory(t *testing.T) {
-	// README §Database: the path names the file exactly. With link a
+	// README §Settings: the path names the file exactly. With link a
 	// symlink to the directory real/sub, link/../db.sqlite names
 	// real/db.sqlite, not db.sqlite beside link. Every subcommand must
 	// use that file, relative or absolute, and its first line must name
@@ -649,7 +649,7 @@ func TestRunUsageErrors(t *testing.T) {
 }
 
 func TestRunScanRejectsWorkersBelowOne(t *testing.T) {
-	// README §scan mode: --workers below 1 is a usage error reported in
+	// README §Settings: --workers below 1 is a usage error reported in
 	// one line on stderr, before the scan opens the database.
 	for _, workers := range []string{"0", "-1"} {
 		t.Run(workers, func(t *testing.T) {
@@ -687,8 +687,8 @@ func TestRunScanRejectsWorkersBelowOne(t *testing.T) {
 func TestRunHelp(t *testing.T) {
 	t.Parallel()
 
-	// README §Subcommands: help goes to stderr, exits 0, and leaves
-	// stdout empty.
+	// README §Settings: help goes to stderr, exits 0, and leaves stdout
+	// empty.
 	cases := [][]string{{"--help"}, {"-h"}, {cmdScan, "--help"}}
 
 	for _, args := range cases {
@@ -714,8 +714,8 @@ func TestRunHelp(t *testing.T) {
 func TestRunVersion(t *testing.T) {
 	t.Parallel()
 
-	// README §Subcommands: the version is one line on stdout, with
-	// nothing on stderr, and exits 0.
+	// README §Settings: the version is one line on stdout, with nothing
+	// on stderr, and exits 0.
 	info, _ := debug.ReadBuildInfo()
 
 	for _, arg := range []string{"--version", "-v"} {
@@ -774,8 +774,8 @@ func TestBuildVersion(t *testing.T) {
 func TestRunVersionWriteFailureIsFatal(t *testing.T) {
 	t.Parallel()
 
-	// README §Error handling: a stdout write failure exits 1, reported
-	// in one line on stderr.
+	// README §Error handling: a failed write to stdout is a fatal error,
+	// exit 1, reported on stderr starting with "sfdupes:".
 	var stderr bytes.Buffer
 
 	code := run([]string{"--version"}, failingWriter{}, &stderr)
@@ -818,6 +818,23 @@ func scanFixture(t *testing.T) []string {
 	return dupes
 }
 
+// storedDiskSize returns the disk_size of the record for path in the
+// database at dbPath. A test of a trees run compares with this rather
+// than with a new lstat, which on ZFS can differ from the scan's (see
+// diskSizeOf).
+func storedDiskSize(t *testing.T, dbPath, path string) int64 {
+	t.Helper()
+
+	db, err := openReportDatabase(t.Context(), dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	defer func() { _ = db.Close() }()
+
+	return recordByPath(t, dbRecords(t, db), path).diskSize
+}
+
 // scanOK runs scan over operands, fails the test unless it exits 0 with
 // nothing on stdout, and returns everything it printed to stderr.
 func scanOK(t *testing.T, operands ...string) string {
@@ -1143,7 +1160,7 @@ func TestRunTreesSucceeds(t *testing.T) {
 	// trees of each other.
 	want := "first\tdupe\tfiles\tsize\tdisk_size\n" +
 		filepath.Dir(dupes[0]) + "\t" + filepath.Dir(dupes[1]) + "\t1\t300\t" +
-		strconv.FormatInt(diskSizeOf(t, dupes[1]), 10) + "\n"
+		strconv.FormatInt(storedDiskSize(t, path, dupes[1]), 10) + "\n"
 	if got := stdout.String(); got != want {
 		t.Errorf("stdout = %q, want %q", got, want)
 	}
@@ -1179,8 +1196,8 @@ func TestRunReportsNeedOnlyReadAccess(t *testing.T) {
 			dupes[0] + "\t" + dupes[1] + "\t300\n",
 		cmdTrees: "first\tdupe\tfiles\tsize\tdisk_size\n" +
 			filepath.Dir(dupes[0]) + "\t" + filepath.Dir(dupes[1]) +
-			"\t1\t300\t" + strconv.FormatInt(diskSizeOf(t, dupes[1]), 10) +
-			"\n",
+			"\t1\t300\t" +
+			strconv.FormatInt(storedDiskSize(t, path, dupes[1]), 10) + "\n",
 	}
 
 	for name, want := range cases {
@@ -1215,9 +1232,11 @@ func assertRunsUseDatabase(t *testing.T, dir, name string) {
 		t.Errorf("report stdout = %q, want %q", got, want)
 	}
 
+	diskSize := storedDiskSize(t, filepath.Join(dir, name), dupes[1])
+
 	want = "first\tdupe\tfiles\tsize\tdisk_size\n" +
 		filepath.Dir(dupes[0]) + "\t" + filepath.Dir(dupes[1]) + "\t1\t300\t" +
-		strconv.FormatInt(diskSizeOf(t, dupes[1]), 10) + "\n"
+		strconv.FormatInt(diskSize, 10) + "\n"
 	if got := runStdout(t, cmdTrees); got != want {
 		t.Errorf("trees stdout = %q, want %q", got, want)
 	}
@@ -1238,7 +1257,7 @@ func assertRunsUseDatabase(t *testing.T, dir, name string) {
 }
 
 func TestRunDatabasePathUsedAsGiven(t *testing.T) {
-	// README §Database: the path names the database file exactly. In
+	// README §Settings: the path names the database file exactly. In
 	// SQLite's connection string an unescaped ? or # would end the file
 	// name and % would start an escape, and a path starting with //
 	// could be read as a host name. %25 is a valid escape, so unescaped
@@ -1283,9 +1302,8 @@ func holdScanLock(t *testing.T, path string) {
 }
 
 func TestRunSecondScanFails(t *testing.T) {
-	// README §Database: while one scan holds the lock, a second scan
-	// fails at once, naming the lock file, without opening the
-	// database.
+	// README §Database: a second scan that finds the lock held fails
+	// at once, naming the lock file, without opening the database.
 	path := testDBPath(t)
 	t.Setenv(databaseEnv, path)
 
@@ -1344,7 +1362,7 @@ func assertSecondScanFails(t *testing.T, path string) {
 }
 
 func TestRunSecondScanThroughSymlinkFails(t *testing.T) {
-	// README §Database: every path to one database names the same lock
+	// README §Database: a path through a symlink names the same lock
 	// file, so while a scan holds it through one path, a scan through
 	// another fails, naming the lock file beside the database's real
 	// path.
@@ -1449,8 +1467,8 @@ func TestRunReportsDuringScan(t *testing.T) {
 }
 
 func TestRunStdoutClosedIsFatal(t *testing.T) {
-	// README §Error handling: a stdout write failure exits 1, reported
-	// in one line on stderr.
+	// README §Error handling: a failed write to stdout is a fatal error,
+	// exit 1, reported on stderr starting with "sfdupes:".
 	for _, name := range []string{cmdReport, cmdTrees, cmdInfo} {
 		t.Run(name, func(t *testing.T) {
 			t.Setenv(databaseEnv, testDBPath(t))

scan.go

@@ -66,11 +66,12 @@ type fileRec struct {
 }
 
 // fileMeta is the in-memory index entry for one existing database
-// record: just enough for change detection. Hashes stay on disk; at
+// record: what the walk compares the file with. Hashes stay on disk; at
 // tens of millions of records they would dominate the scan's memory.
 type fileMeta struct {
-	size  int64
-	mtime time.Time
+	size     int64
+	diskSize int64
+	mtime    time.Time
 }
 
 // scanUnit is what every scan phase counts, as its progress display
@@ -341,11 +342,12 @@ type scanStats struct {
 // whatever remains after the walk and hash phases is deleted by the
 // update phase.
 type scanState struct {
-	db       *sql.DB
-	existing map[string]fileMeta
-	toHash   []fileRec // new and changed files: must be read
-	batch    []scanRec
-	st       scanStats
+	db        *sql.DB
+	existing  map[string]fileMeta
+	toHash    []fileRec // new and changed files: must be read
+	diskSizes []fileRec // unchanged files whose disk_size changed
+	batch     []scanRec
+	st        scanStats
 }
 
 // syncScan synchronizes the database with the filesystem under roots;
@@ -474,24 +476,24 @@ func (s *scanState) loadIndex(ctx context.Context, roots []string) error {
 
 	s.existing = make(map[string]fileMeta)
 
-	return loadFileMeta(ctx, s.db,
-		func(path string, size int64, mtime time.Time) {
-			prog.increment()
+	return loadFileMeta(ctx, s.db, func(path string, m fileMeta) {
+		prog.increment()
 
-			if underAnyRoot(path, roots) {
-				s.existing[path] = fileMeta{size: size, mtime: mtime}
-			}
-		})
+		if underAnyRoot(path, roots) {
+			s.existing[path] = m
+		}
+	})
 }
 
 // walkPhase drains the walk and queues every new or changed file for
-// the hash phase. An unchanged file needs nothing more, and its record
-// counts as verified. A record at or below a path the walk left out,
-// because -x stopped at it, it is a default exclude, or it is not on a
-// persistent filesystem, counts as outside the roots: it is not
-// deleted. That does not hold below a root at or inside that path,
-// since that root's own walk verifies the records below it; nor is a
-// line printed for such a root.
+// the hash phase. An unchanged file is not read, and its record counts
+// as verified. When its disk_size differs from the record's, it is
+// queued for the update phase, which writes the new disk_size. A record
+// at or below a path the walk left out, because -x stopped at it, it is
+// a default exclude, or it is not on a persistent filesystem, counts as
+// outside the roots: it is not deleted. That does not hold below a root
+// at or inside that path, since that root's own walk verifies the
+// records below it; nor is a line printed for such a root.
 func (s *scanState) walkPhase(events <-chan walkEvent, roots []string) {
 	// The records the last scan left under the roots estimate how many
 	// files the walk will find. A first scan has none, and no estimate.
@@ -549,6 +551,13 @@ func (s *scanState) walkPhase(events <-chan walkEvent, roots []string) {
 		delete(s.existing, ev.rec.path)
 
 		s.st.unchanged++
+
+		// The space a file takes on disk can change while its size and
+		// mtime stay the same. ZFS, for one, counts a new file's blocks
+		// only seconds after the write.
+		if old.diskSize != ev.rec.diskSize {
+			s.diskSizes = append(s.diskSizes, ev.rec)
+		}
 	}
 
 	prog.finish()
@@ -719,7 +728,7 @@ func (s *scanState) commitFullBatch(ctx context.Context) error {
 		return nil
 	}
 
-	err := applyBatch(ctx, s.db, s.batch, nil, nil)
+	err := applyBatch(ctx, s.db, s.batch, nil, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -730,9 +739,10 @@ func (s *scanState) commitFullBatch(ctx context.Context) error {
 }
 
 // updatePhase writes the scan's tail under one progress display: the
-// final partial batch of hashed records, and deletions for every record
-// the scan did not verify (vanished files, plus paths that failed to
-// stat or hash).
+// final partial batch of hashed records, the new disk_size of every
+// unchanged file whose disk_size changed, and deletions for every
+// record the scan did not verify (vanished files, plus paths that
+// failed to stat or hash).
 func (s *scanState) updatePhase(ctx context.Context) error {
 	deletes := make([]string, 0, len(s.existing))
 	for path := range s.existing {
@@ -744,7 +754,7 @@ func (s *scanState) updatePhase(ctx context.Context) error {
 
 	s.st.removed = len(deletes)
 
-	total := len(s.batch) + len(deletes)
+	total := len(s.batch) + len(s.diskSizes) + len(deletes)
 	prog := newProgress(progressParams{
 		label: scanPhase("update"), unit: scanUnit, total: int64(total),
 		stalledOn: "db",
@@ -759,6 +769,11 @@ func (s *scanState) updatePhase(ctx context.Context) error {
 
 	s.batch = nil
 
+	err = applyDiskSizes(ctx, s.db, s.diskSizes, prog)
+	if err != nil {
+		return err
+	}
+
 	return applyChanges(ctx, s.db, nil, deletes, prog)
 }
 

scan_test.go

@@ -43,7 +43,10 @@ func writeFile(t *testing.T, dir, name string, data []byte) string {
 }
 
 // diskSizeOf returns the bytes the file at path takes on disk, from its
-// own lstat: st_blocks counts 512-byte units.
+// own lstat: st_blocks counts 512-byte units. ZFS counts a new file's
+// blocks only seconds after the write, and fsync does not hasten that.
+// A test therefore calls unix.Sync, which waits for it, before the scan
+// whose disk_size it compares with this.
 func diskSizeOf(t *testing.T, path string) int64 {
 	t.Helper()
 
@@ -1079,8 +1082,9 @@ func TestScanOneFilesystemWalksNestedFileOperand(t *testing.T) {
 	}
 }
 
-// buildSmokeTree recreates the README smoke-test filesystem layout
-// with deterministic content and returns the tree root.
+// buildSmokeTree recreates the tree of the test under README
+// "Definition of done" with deterministic content and returns the tree
+// root.
 func buildSmokeTree(t *testing.T) string {
 	t.Helper()
 
@@ -1432,45 +1436,115 @@ func TestScanStoresRawHashes(t *testing.T) {
 }
 
 // TestScanStoresDiskSize scans a sparse file, which takes less space on
-// disk than its length, and checks the disk_size stored for it against
-// the file's own lstat.
+// disk than its length, once through its directory and once as the
+// operand itself. Each scan stores the disk_size of the file's lstat.
 func TestScanStoresDiskSize(t *testing.T) {
 	t.Parallel()
 
+	const length = 1024 * 1024
+
+	p := sparseFile(t, t.TempDir(), "sparse", length)
+	pokeAt(t, p, 0, []byte("x"))
+
+	unix.Sync() // see diskSizeOf
+
+	want := diskSizeOf(t, p)
+	if want == 0 || want >= length {
+		t.Fatalf("the file takes %d bytes on disk, want more than none "+
+			"and fewer than its length %d", want, length)
+	}
+
+	for _, operand := range []string{filepath.Dir(p), p} {
+		db := openTestDB(t)
+		syncTree(t, db, operand)
+
+		got := recordByPath(t, dbRecords(t, db), p).diskSize
+		if got != want {
+			t.Errorf("scan of %s: disk_size = %d, want %d",
+				operand, got, want)
+		}
+	}
+}
+
+// TestSyncScanRewriteUpdatesDiskSize writes into the hole of a scanned
+// sparse file and moves its mtime on. The rescan hashes the file again
+// and rewrites its record with the new disk_size.
+func TestSyncScanRewriteUpdatesDiskSize(t *testing.T) {
+	t.Parallel()
+
 	dir := t.TempDir()
 	db := openTestDB(t)
-	p := writeFile(t, dir, "sparse", []byte("x"))
-
-	// Truncate makes the file longer without giving it blocks for the
-	// new bytes.
-	const length = 1024 * 1024
-
-	err := os.Truncate(p, length)
-	if err != nil {
-		t.Fatal(err)
-	}
+	p := sparseFile(t, dir, "sparse", 1024*1024)
+	pokeAt(t, p, 0, []byte("x"))
 
 	syncTree(t, db, dir)
 
-	want := diskSizeOf(t, p)
-	if want >= length {
-		t.Fatalf("the file takes %d bytes on disk, want fewer than its "+
-			"length %d", want, length)
-	}
+	before := recordByPath(t, dbRecords(t, db), p).diskSize
 
-	var got int64
+	pokeAt(t, p, 512*1024, pattern(7, 64*1024))
 
-	err = db.QueryRowContext(t.Context(),
-		"SELECT disk_size FROM files WHERE path = ?", []byte(p)).Scan(&got)
+	// The write may leave the mtime the scan recorded; a later one makes
+	// the rescan read the file again.
+	later := time.Now().Add(time.Hour)
+
+	err := os.Chtimes(p, later, later)
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	unix.Sync() // see diskSizeOf
+
+	want := diskSizeOf(t, p)
+	if want == before {
+		t.Fatalf("the file still takes %d bytes on disk after the write "+
+			"into its hole", want)
+	}
+
+	st := syncTree(t, db, dir)
+	if st != (scanStats{walked: 1, updated: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 updated", st)
+	}
+
+	got := recordByPath(t, dbRecords(t, db), p).diskSize
 	if got != want {
 		t.Errorf("disk_size = %d, want %d", got, want)
 	}
 }
 
+// TestSyncScanUnchangedUpdatesDiskSize gives a file's record a
+// disk_size the file does not have, as when ZFS had not yet counted the
+// file's blocks at the last scan. The rescan writes the file's own
+// disk_size into the record without reading the file again.
+func TestSyncScanUnchangedUpdatesDiskSize(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	p := writeFile(t, dir, "a.bin", pattern(1, 500))
+
+	syncTree(t, db, dir)
+
+	// lstat counts 512-byte units, so no file takes 1 byte on disk.
+	_, err := db.ExecContext(t.Context(),
+		"UPDATE files SET disk_size = 1 WHERE path = ?", []byte(p))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	unix.Sync() // see diskSizeOf
+
+	// A file read again would count as updated.
+	st := syncTree(t, db, dir)
+	if st != (scanStats{walked: 1, unchanged: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 unchanged", st)
+	}
+
+	got := recordByPath(t, dbRecords(t, db), p).diskSize
+	if want := diskSizeOf(t, p); got != want {
+		t.Errorf("disk_size = %d, want %d", got, want)
+	}
+}
+
 // TestSyncScanSameSecondRewrite rewrites a file in place at the same
 // size with an mtime later in the same second as the recorded one: the
 // next scan must notice the change and re-hash the file. The operand is

trees_test.go

@@ -15,9 +15,9 @@ import (
 const treesOpenLine = "[1/4] open: opening the database, elapsed 0s, " +
 	"remain unknown"
 
-// smokeTreeRecs mirrors the README smoke-test tree layout: /d/t1 and
-// /d/t2 are identical, /d/t3 differs from them only by one filename.
-// Each file takes one 4 KiB block on disk.
+// smokeTreeRecs mirrors the tree of the test under README "Definition
+// of done": /d/t1 and /d/t2 are identical, /d/t3 differs from them only
+// by one filename. Each file takes one 4 KiB block on disk.
 func smokeTreeRecs() []scanRec {
 	f1Head, f1Tail, f1Content := testHash("f1h"), testHash("f1t"), testHash("f1c")
 	f2Head, f2Tail, f2Content := testHash("f2h"), testHash("f2t"), testHash("f2c")