Add scan --exclude PATH (closes #163)

The walk neither enters nor records an --exclude path or anything
below it, and prints "scan: skipped PATH (--exclude)" for each one it
reaches. The flag repeats. Each value is resolved to its real path, as
an operand is. The records below an excluded path are kept, as for a
default exclude. An empty value, which would name the working
directory, is a usage error. An --exclude path whose real path scan
cannot find, or an operand at or below one, is a fatal error before
the scan starts. The line naming the database moved out of runScan
into printDatabasePath, which keeps runScan under the lint length
limit.

Model: opus-5-5

README.md

@@ -21,7 +21,7 @@ file takes too long. It has five subcommands. `scan` walks the filesystem and
 records the files it finds in an SQLite database. SQLite keeps a whole database
 in one file. The database is kept between runs. A rescan reads only new and
 changed files. That makes `scan` cheap enough to run every day from `cron`, the
-system's job scheduler. `report`, `trees` and `info` work from the database and
+system's job scheduler. `report`, `trees` and `info` read the database alone and
 can run at any time. `dwim` scans `/` and then prints the `trees` report, for a
 first look at a new machine with one command.
 
@@ -98,15 +98,13 @@ Each `-v` flag below makes a bind mount, which shows a host directory at a path
 inside the container. Bind-mount `/var/lib/sfdupes` to keep the database between
 runs. Mount the tree to scan at the same path inside the container as on the
 host. Read-only access is enough. The database then records the host's paths,
-and so do the reports. `report` and `trees` need that mount too. Without it,
+and so do the reports.
-every recorded path counts as gone, and each report holds only its header line.
 
 ```sh
 make docker
 docker run --rm -v /srv:/srv:ro -v /var/lib/sfdupes:/var/lib/sfdupes \
     sfdupes scan /srv
-docker run --rm -v /srv:/srv:ro -v /var/lib/sfdupes:/var/lib/sfdupes \
+docker run --rm -v /var/lib/sfdupes:/var/lib/sfdupes sfdupes report > dupes.tsv
-    sfdupes report > dupes.tsv
 ```
 
 ### Daily scan from `cron`
@@ -161,10 +159,8 @@ to keep is your choice.
 
 A row is a candidate, not proof:
 
-- The reports show each file as it was when a scan last recorded it. They check
+- The reports show each file as it was when a scan last recorded it. A file may
-  only that each copy still exists: the file, or the directory at the top of a
+  have changed or gone since.
-  tree. A file may have changed since, and a file inside a tree may be gone. Run
-  `scan` again to bring the reports up to date.
 - A file of 100 MiB or more is compared only on samples of its content (see
   "Duplicate detection").
 - Two paths that are hard links, two names for one file, are listed as
@@ -212,9 +208,8 @@ makes the comparison exact. Reading samples cuts a 150 GiB file to about 150 MiB
 of reads, at the price of a comparison that is not exact.
 
 The hashes live in a database that is kept between runs. A rescan reads only new
-files, and files whose size or modification time (mtime) differs from their
+files, and files whose size changed or whose modification time (mtime) is newer
-record. All analysis then works from the database. The reports only check that
+than recorded. All analysis then works from the database alone.
-each copy they name still exists.
 
 The goal is whole duplicated trees, not only single files. A download extracted
 twice, or a project copied once too often, is such a tree. It can be removed as
@@ -240,10 +235,9 @@ In order:
    the files of the directories it is reading.
 3. **Rescan cheaply, analyze from the database.** The scan keeps its database
    between runs, and an unchanged file is never read again. `report`, `trees`
-   and `info` work from the database and never read a scanned file. `report` and
+   and `info` work from the database alone and never touch the scanned
-   `trees` check only that each copy they name still exists, and leave out a
+   filesystem. `scan` is built to run from `cron`. The reports run at any time,
-   copy that is gone. `scan` is built to run from `cron`. The reports run at any
+   against what the database holds.
-   time, against what the database holds.
 4. **Keep the streams apart.** Everything on stdout is machine-readable data.
    Everything for a human reader, such as progress and warnings, goes to stderr.
 
@@ -305,10 +299,7 @@ The reference below is also the program's specification.
   such as `/var/tmp` on Linux (see "Rules for the walk").
 - `--exclude PATH` (`scan`) keeps the walk out of `PATH` and everything below
   it. `PATH` may be a directory or a file. The flag may be given more than once.
-  The walk knows `PATH` by its device ID and inode number, as it knows the
+  `PATH` is resolved to its real path, as an operand is. An empty `PATH`, as in
-  database files (see "Rules for the walk"). So the walk leaves `PATH` out
-  whatever path leads to it. That includes a hard link to a file given as
-  `PATH`. A symlink given as `PATH` excludes its target. An empty `PATH`, as in
   `--exclude ""`, is a usage error, reported in one line on stderr with exit 2
   before anything is scanned. A `PATH` that does not exist, or whose real path
   `scan` cannot find, is a fatal error. So is an operand at or below one (see
@@ -316,11 +307,9 @@ The reference below is also the program's specification.
 - `--version`, `-v` prints `sfdupes VERSION` (see "Install") to stdout and
   exits 0. It writes nothing to stderr.
 - `--help`, `-h`, alone or after a subcommand, prints the help text to stderr
-  and exits 0. It writes nothing to stdout. The help of `sfdupes` and of `scan`
+  and exits 0. It writes nothing to stdout. `sfdupes scan --help` also lists the
-  names the database. The help of `report`, `trees`, `info` and `dwim` says what
+  default excludes of the system it runs on, and the filesystem types the walk
-  each prints. `sfdupes scan --help` also lists the default excludes of the
+  never records anything on.
-  system it runs on, and the filesystem types the walk never records anything
-  on.
 
 ### Duplicate detection
 
@@ -374,9 +363,7 @@ default. An operand may be a directory or a regular file.
   target does not exist. `scan` then stops before it walks anything, and exits
   with code 1.
 - An operand at or below an `--exclude` path is a fatal error too. The message
-  names the operand and the `--exclude` path. `scan` compares the operand and
+  names the operand and the `--exclude` path. Both are compared as real paths.
-  each directory above it with the `--exclude` paths by device ID and inode
-  number, not by name.
 - Each operand is resolved to its real path before the walk, as `realpath`
   prints it. A relative operand is joined to the working directory as `pwd -P`
   prints it. Every symlink in the path is then followed. A `..` after a symlink
@@ -432,16 +419,17 @@ operands:
 
 - A file not yet in the database is hashed and inserted.
 - A file already in the database is not read again when its size and mtime match
-  its record. This is what makes a daily rescan cheap.
+  its record. The mtime matches when it is not newer than the recorded one. This
+  is what makes a daily rescan cheap.
 - When such a file's size on disk differs from its recorded `disk_size`, `scan`
   updates `disk_size` alone. It still does not read the file, and counts it as
   unchanged. ZFS, for example, counts a new file's blocks up to seconds after
   the write. A block is the unit in which a filesystem allocates disk space. A
   file scanned within those seconds gets its real `disk_size` at the next scan.
-- `scan` hashes a file again when its size or its mtime differs from its record.
+- `scan` hashes a file again when its size differs or its mtime is newer. The
-  An older mtime counts as much as a newer one. A file put back by `cp -p`,
+  mtime is compared to the nanosecond, as finely as the filesystem records it. A
-  `rsync -a` or a restore from backup often has an older mtime. The mtime is
+  same-size rewrite counts as a change whenever the filesystem gives it a later
-  compared to the nanosecond, as finely as the filesystem records it.
+  mtime, even within the same second.
 - The scan deletes each record under a scanned operand whose file it could not
   verify. That covers deleted files, and paths the scan could not stat or read
   this run. To stat a file is to read its details, such as its size, without
@@ -689,29 +677,21 @@ and `scan` leaves it ignored.
 
 `report` reads every record from the database. It takes no positional arguments.
 A positional argument is anything on the command line that is not a flag, such
-as the paths `scan` takes. `report` never opens a scanned file. It checks that
+as the paths `scan` takes. `report` never touches the scanned filesystem. It
-each path in a group still exists, and looks at no other path. The check is
+neither stats nor opens any path in the records. It reads the database and
-`lstat`, the system call that looks up a path without following a symlink:
+writes to stdout and stderr, and nothing else. Its output is the same whether or
-
+not the scanned filesystem is still mounted.
-- A path is gone when `lstat` finds that it, or a directory above it, does not
-  exist.
-- Any other error, such as a permission error, counts as present. So a user who
-  may not look inside a directory still sees its copies.
-
-The check does not notice a file that changed after the scan. Run `scan` again
-to bring the report up to date.
 
 Processing:
 
 - Records are grouped by signature, the four values
   `(size, head, tail, content)`.
-- In a group with two or more paths, a path that is gone is left out. A group
+- Every group with two or more paths is a duplicate group.
-  that still has two or more paths is a duplicate group.
 - Empty files form no group, because removing one frees nothing.
 - Within a group, paths are sorted in byte order. The first is `first`, and
   every other path is a `dupe`.
 - Groups are ordered by size, largest first, then by `first` path. The output is
-  the same for the same database contents and the same paths on disk.
+  the same for the same database contents.
 
 `report` has two phases, each with its own progress display on stderr (see
 "Progress"). `open` opens the database. `read` gets the number of records from
@@ -764,9 +744,8 @@ report: 14 records read, 4 duplicate groups, 7 dupe files, 10.0 KiB reclaimable
 `trees` reads the same database as `report` and takes no positional arguments.
 It reports whole duplicate directory trees. Two directories are duplicate trees
 when they hold the same relative paths, and each path holds a file with the same
-signature in both. It rebuilds the directory tree from the paths in the records,
+signature in both. Like `report`, it never touches the scanned filesystem. It
-split on `/`. Like `report`, it never opens a scanned file. It checks only that
+rebuilds the directory tree from the paths in the records, split on `/`.
-the directory at the top of each copy still exists, as `report` checks a path.
 
 Definitions:
 
@@ -793,13 +772,10 @@ Processing:
   directories that all have the same digest. The parents' group, or an
   ancestor's, already implies it. A group is always reported when it holds
   sibling directories, or when its members' parents have different digests.
-- A directory that is gone is dropped from its group. A group left with fewer
-  than two directories is not reported.
 - Within a group, paths are sorted in byte order. The first is `first`, and
   every other path is a `dupe`.
 - Groups are ordered by total tree size, largest first, then by `first` path.
-  The output is the same for the same database contents and the same paths on
+  The output is the same for the same database contents.
-  disk.
 
 Two limitations are accepted:
 
@@ -813,9 +789,8 @@ Two limitations are accepted:
 `trees` has four phases, each with its own progress display on stderr (see
 "Progress"). `open` opens the database. `read` gets the number of records from
 the `totals` table, then reads them in path order. It builds the directory tree
-and computes the digests as it goes. `group` groups the directories by digest,
+and computes the digests as it goes. `group` groups the directories by digest
-picks the groups to report and checks that their directories still exist.
+and picks the groups to report. `write` writes them to stdout.
-`write` writes the groups to stdout.
 
 #### Trees output format
 
@@ -873,8 +848,8 @@ The report goes to stdout, exactly as `trees` prints it. On stderr comes what
 dwim: run "sfdupes trees" to print this report again
 ```
 
-The database keeps the scan, so `sfdupes trees` prints the report again later,
+The database keeps the scan, so `sfdupes trees` prints the same report later,
-even after the terminal is gone. It then leaves out a copy deleted in between.
+even after the terminal is gone.
 
 `SIGINT` or `SIGTERM` stops the scan as it stops `scan` (see "Stopping a scan").
 `dwim` then prints no report and exits 1. A fatal scan error also ends it before
@@ -1166,10 +1141,9 @@ in, and a phase that may wait in two places names both, as `disk/db`:
 - `hash` says `disk/db`, because it reads files and writes their records to the
   database between them.
 - `load`, `update` and the `read` phase of `trees` say `db`.
-- The `read` phase of `report` says `db/disk/out`. It checks that the paths of
+- The `read` phase of `report` says `db/out`, because it writes the report to
-  each group still exist, and writes the report to stdout, while it reads.
+  stdout while it reads.
-- `group` of `trees` says `cpu/disk`, for work in memory and the check that each
+- `group` of `trees` says `cpu`, for work in memory, and its `write` says `out`.
-  copy still exists. Its `write` says `out`.
 - A phase still waiting for its total says what it waits for, and nothing more.
 
 On a terminal:
@@ -1413,8 +1387,8 @@ commands of their own:
   not a goal. `modernc.org/sqlite` is pure Go too, so the binary builds without
   cgo. The `Makefile` exports `CGO_ENABLED=0`. The test build is the one
   exception, because the race detector needs cgo (see `script/test`).
-- `report` and `trees` give the same output for the same database contents and
+- `report` and `trees` give the same output for the same database contents,
-  the same paths on disk, whatever order the records were inserted in.
+  whatever order the records were inserted in.
 
 ### Definition of done
 
@@ -1479,7 +1453,7 @@ All of the following, run in this directory, must pass:
 
     The test suite automates this scenario (see
     `internal/sfdupes/scan_test.go`). It also checks that `report` and `trees`
-    leave out a copy removed after the scan.
+    never touch the scanned filesystem.
 
 ## TODO
 

TODO.md

@@ -29,24 +29,11 @@
 Newest first. An entry ends with its date and its issue or branch, where those
 are known.
 
-- The help of `sfdupes` and of `scan` names the database, its default path and
-  `SFDUPES_DATABASE`. The help of `report` and `trees` lists the columns, the
-  order of the rows and the escapes. The help of `info` lists its lines. The
-  help of `dwim` says that it scans `/`, should run as root and keeps the scan
-  in the database (2026-11-11, https://git.eeqj.de/sneak/sfdupes/issues/177)
 - New `scan` flag `--exclude PATH`, which may be repeated. The walk neither
   enters nor records an excluded path, and keeps the records below it. An
   operand at or below one is a fatal error (2026-11-11,
   https://git.eeqj.de/sneak/sfdupes/issues/163)
 
-- `report` and `trees` leave out a copy that was deleted after the scan. Each
-  checks only the copy itself with `lstat`: the file, or the directory at the
-  top of a tree. A group left with one copy is not reported. A missing `scan`
-  operand is still a fatal error (2026-11-11,
-  https://git.eeqj.de/sneak/sfdupes/issues/173)
-- The usage line of `scan` no longer ends in `[flags]`. It is the line
-  `README.md` shows under "Subcommands" (2026-11-11,
-  https://git.eeqj.de/sneak/sfdupes/issues/169)
 - `report` and `trees` leave out empty files. `report` writes no group of size
   0, and `trees` writes no group whose trees hold 0 bytes. An empty file still
   counts toward a tree's digest (2026-11-11,

internal/sfdupes/cli.go

@@ -32,69 +32,6 @@ const (
 	cmdDwim   = "dwim"
 )
 
-// databaseHelp is the paragraph of the root and scan help that names
-// the database (README "Location").
-const databaseHelp = "scan and dwim store what they find in a database " +
-	"file. report, trees\nand info read it. The file is $" + databaseEnv +
-	" when that is set and\nnot empty, and otherwise " +
-	defaultDatabasePath + ", where creating it\nneeds root.\n"
-
-// escapesHelp is the paragraph of the report and trees help on how
-// paths are escaped (README "Report output format").
-const escapesHelp = `Four characters in a path are escaped, so each row stays one line:
-
-  \\  a backslash
-  \t  a tab
-  \n  a newline
-  \r  a carriage return
-`
-
-// reportHelp, treesHelp, infoHelp and dwimHelp follow the one-line
-// summary in the help of their subcommands.
-const (
-	reportHelp = `The report is tab-separated text on stdout: a header line, then one
-row per duplicate file. The columns are:
-
-  first   the path that sorts first, byte by byte, in its group of copies
-  dupe    another copy of that file
-  size    the file's size in bytes
-
-Rows are ordered by size, largest first, then by path.
-
-` + escapesHelp
-
-	treesHelp = `The report is tab-separated text on stdout: a header line, then one
-row per duplicate directory tree. The columns are:
-
-  first      the path that sorts first, byte by byte, in its group of copies
-  dupe       another copy of that tree
-  files      the number of regular files in one copy
-  size       their total size in bytes
-  disk_size  the bytes the dupe copy takes on disk
-
-Rows are ordered by size, largest first, then by path.
-
-` + escapesHelp
-
-	infoHelp = `The details go to stdout, one per line. Each line holds a name and its
-value, separated by a tab:
-
-  database                the path, and where it came from
-  database file size      in bytes, then rounded, as 2147483648 (2.0 GiB)
-  -wal file size          in bytes, then rounded; only if a -wal file exists
-  modified                when the database file last changed, in UTC
-  schema version          the version of the database's layout
-  records                 the number of records
-  size of recorded files  their total size, in bytes, then rounded
-`
-
-	dwimHelp = `dwim runs what "sfdupes scan /" runs, then what "sfdupes trees" runs.
-Run it as root, so that the scan can read every file. The scan is stored
-in the database, as scan stores it, so "sfdupes trees" prints the report
-again later.
-`
-)
-
 // errNoSubcommand is returned by the root command when it is invoked
 // without a subcommand. That is a usage error, and the usage text
 // cobra prints for it is the whole message.
@@ -265,21 +202,15 @@ func newRootCommand(stdout, stderr io.Writer) *cobra.Command {
 		}),
 	}
 
-	root.Long = root.Short + ".\n\n" + databaseHelp
-	reportCmd.Long = reportCmd.Short + ".\n\n" + reportHelp
-	treesCmd.Long = treesCmd.Short + ".\n\n" + treesHelp
-	infoCmd.Long = infoCmd.Short + ".\n\n" + infoHelp
-	dwimCmd.Long = dwimCmd.Short + ".\n\n" + dwimHelp
-
 	root.AddCommand(newScanCommand(), reportCmd, treesCmd, infoCmd, dwimCmd)
 
 	return root
 }
 
 // newScanCommand builds the scan subcommand, with its --workers, -x,
-// --no-default-excludes and --exclude flags. Its help names the
+// --no-default-excludes and --exclude flags. Its help lists the default
-// database, and lists the default excludes of the system it runs on and
+// excludes of the system it runs on, and the filesystem types it never
-// the filesystem types it never records anything on.
+// records anything on.
 func newScanCommand() *cobra.Command {
 	var (
 		scanWorkers           int
@@ -293,12 +224,8 @@ func newScanCommand() *cobra.Command {
 	scanCmd := &cobra.Command{
 		Use: cmdScan + " [--workers N] [-x] [--no-default-excludes] " +
 			"[--exclude PATH]... PATH...",
-		// The Use line already names every flag, so cobra must not
-		// append its generic "[flags]" to it.
-		DisableFlagsInUseLine: true,
 		Short: short,
-		Long: short + ".\n\n" + databaseHelp + "\n" +
+		Long:  short + ".\n\n" + defaultExcludesHelp(runtime.GOOS),
-			defaultExcludesHelp(runtime.GOOS),
 		Args:  cobra.MinimumNArgs(1),
 		PreRunE: func(cmd *cobra.Command, _ []string) error {
 			err := checkScanWorkers(cmd, scanWorkers)
@@ -345,8 +272,8 @@ func checkScanWorkers(cmd *cobra.Command, workers int) error {
 
 // rejectEmptyExcludeValue rejects an empty scan --exclude value. That
 // is a usage error reported in one line, as for --workers below 1.
-func rejectEmptyExcludeValue(cmd *cobra.Command, excludePaths []string) error {
+func rejectEmptyExcludeValue(cmd *cobra.Command, excluded []string) error {
-	if !slices.Contains(excludePaths, "") {
+	if !slices.Contains(excluded, "") {
 		return nil
 	}
 

internal/sfdupes/cli_test.go

@@ -22,9 +22,6 @@ import (
 // error prints and a runtime failure must not.
 const usageMarker = "Usage:"
 
-// helpFlag asks for the help text.
-const helpFlag = "--help"
-
 // TestMain stops the tests at once, saying why, when their temporary
 // directory is not on a persistent filesystem: scan records nothing
 // there (README "Rules for the walk"), so most scan tests would fail
@@ -696,7 +693,7 @@ func TestRunHelp(t *testing.T) {
 
 	// README §Settings: help goes to stderr, exits 0, and leaves stdout
 	// empty.
-	cases := [][]string{{helpFlag}, {"-h"}, {cmdScan, helpFlag}}
+	cases := [][]string{{"--help"}, {"-h"}, {cmdScan, "--help"}}
 
 	for _, args := range cases {
 		var stdout, stderr bytes.Buffer
@@ -728,102 +725,6 @@ func TestRunHelp(t *testing.T) {
 	}
 }
 
-func TestRunScanUsageLine(t *testing.T) {
-	t.Parallel()
-
-	// README §Subcommands shows this usage line for scan, and the help
-	// and the usage error both print it.
-	const want = "\n  sfdupes scan [--workers N] [-x] [--no-default-excludes] " +
-		"[--exclude PATH]... PATH...\n"
-
-	cases := map[string][]string{
-		"help":          {cmdScan, "-h"},
-		"missing paths": {cmdScan},
-	}
-
-	for name, args := range cases {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			var stdout, stderr bytes.Buffer
-
-			run(args, &stdout, &stderr)
-
-			if !strings.Contains(stderr.String(), want) {
-				t.Errorf("run(%v) stderr = %q, want the usage line %q",
-					args, stderr.String(), want)
-			}
-		})
-	}
-}
-
-func TestRunHelpDescribesDatabaseAndOutput(t *testing.T) {
-	t.Parallel()
-
-	// README §Settings: the help names the database, and says what
-	// report, trees, info and dwim print.
-	database := []string{
-		"scan and dwim store", databaseEnv, defaultDatabasePath, "needs root",
-	}
-	escapes := []string{`\\`, `\t`, `\n`, `\r`}
-
-	// The subcommand whose help is printed; none for the root.
-	cases := []struct {
-		subcommand []string
-		want       []string
-	}{
-		{nil, database},
-		{[]string{cmdScan}, database},
-		{
-			[]string{cmdReport},
-			append([]string{
-				"tab-separated", "\n  first ", "\n  dupe ", "\n  size ",
-				"largest first",
-			}, escapes...),
-		},
-		{
-			[]string{cmdTrees},
-			append([]string{
-				"tab-separated", "\n  first ", "\n  dupe ", "\n  files ",
-				"\n  size ", "\n  disk_size ", "largest first",
-			}, escapes...),
-		},
-		{
-			[]string{cmdInfo},
-			[]string{
-				"\n  database ", "\n  database file size ",
-				"\n  -wal file size ", "\n  modified ",
-				"\n  schema version ", "\n  records ",
-				"\n  size of recorded files ",
-			},
-		},
-		{
-			[]string{cmdDwim},
-			[]string{
-				"sfdupes scan /", "as root", "sfdupes trees", "database",
-			},
-		},
-	}
-
-	for _, tc := range cases {
-		var stdout, stderr bytes.Buffer
-
-		args := slices.Concat(tc.subcommand, []string{helpFlag})
-
-		code := run(args, &stdout, &stderr)
-		if code != exitOK {
-			t.Fatalf("run(%v) = %d, want %d", args, code, exitOK)
-		}
-
-		for _, want := range tc.want {
-			if !strings.Contains(stderr.String(), want) {
-				t.Errorf("run(%v) help lacks %q:\n%s",
-					args, want, stderr.String())
-			}
-		}
-	}
-}
-
 func TestRunVersion(t *testing.T) {
 	t.Parallel()
 

internal/sfdupes/exclude.go

@@ -13,7 +13,6 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
-	"os"
 	"path/filepath"
 	"slices"
 	"strings"
@@ -50,18 +49,16 @@ var errMountInfoLine = errors.New("unexpected line")
 var errExcludedOperand = errors.New("operand excluded by --exclude")
 
 // walkRules holds the rules for the walk that a scan sets up as it
-// starts. excludePaths are the paths given with --exclude, each with
+// starts. excluded are the real paths given with --exclude, which the
-// the device ID and inode number of the file it names (see
+// walk neither enters nor records. excludes are the default excludes,
-// excludePathInodes), which the walk neither enters nor records,
+// or none with --no-default-excludes. nonPersistent maps the device ID
-// whatever path leads to them. defaultExcludes are the default
+// of every mounted filesystem that is not persistent to its type; the
-// excludes, or none with --no-default-excludes. nonPersistent maps the
+// scan records and reads nothing on one of those, whatever the flags.
-// device ID of every mounted filesystem that is not persistent to its
+// databaseFiles are the scan's own database files, which the walk
-// type; the scan records and reads nothing on one of those, whatever
+// passes over (see databaseFiles in db.go).
-// the flags. databaseFiles are the scan's own database files, which the
-// walk passes over (see databaseFiles in db.go).
 type walkRules struct {
-	excludePaths    []fileRec
+	excluded      []string
-	defaultExcludes []string
+	excludes      []string
 	nonPersistent map[uint64]string
 	databaseFiles []fileRec
 }
@@ -107,82 +104,25 @@ func isDefaultExclude(path string, excludes []string) bool {
 	return false
 }
 
-// excludePathInodes returns each of paths, the --exclude values, as its
-// real path (see realPaths) with the device ID and inode number of the
-// file there. The walk compares what it reaches with those, as it does
-// with the database files, so it also leaves out an --exclude path
-// spelled another way, such as in another letter case on macOS.
-func excludePathInodes(paths []string) ([]fileRec, error) {
-	resolved, err := realPaths(paths)
-	if err != nil {
-		return nil, err
-	}
-
-	files := make([]fileRec, 0, len(resolved))
-
-	for _, path := range resolved {
-		fi, err := os.Lstat(path)
-		if err != nil {
-			return nil, err
-		}
-
-		dev, ino := inodeOfInfo(fi)
-		files = append(files, fileRec{path: path, dev: dev, ino: ino})
-	}
-
-	return files, nil
-}
-
-// matchingExcludePath returns the path of the one of excludePaths with
-// the device ID and inode number of fi, an lstat result, or "" when
-// there is none.
-func matchingExcludePath(fi fs.FileInfo, excludePaths []fileRec) string {
-	dev, ino := inodeOfInfo(fi)
-	f := fileRec{dev: dev, ino: ino}
-
-	for _, exclude := range excludePaths {
-		if sameInode(exclude, f) {
-			return exclude.path
-		}
-	}
-
-	return ""
-}
-
 // checkOperandsNotExcluded returns an error when one of roots, the
-// operands, or a directory above it is one of excludePaths, the
+// operands, is at or below one of excluded, the --exclude values. The
-// --exclude paths, by device ID and inode number. The error names the
+// error names both. Both lists hold real paths.
-// operand and the --exclude path. The roots are absolute, so the
+func checkOperandsNotExcluded(roots, excluded []string) error {
-// directories above each one end at /. A path here that lstat cannot
-// read is an error too.
-func checkOperandsNotExcluded(roots []string, excludePaths []fileRec) error {
 	for _, root := range roots {
-		for path := root; ; path = filepath.Dir(path) {
+		exclude := deepestRoot(root, excluded)
-			fi, err := os.Lstat(path)
-			if err != nil {
-				return fmt.Errorf("scan %s: %w", root, err)
-			}
-
-			exclude := matchingExcludePath(fi, excludePaths)
 		if exclude != "" {
 			return fmt.Errorf("scan %s: %w %s", root, errExcludedOperand,
 				exclude)
 		}
-
-			if path == "/" {
-				break
-			}
-		}
 	}
 
 	return nil
 }
 
-// excludePathLine returns the line the scan prints for path when fi,
+// excludedLine returns the line the scan prints for path when it is one
-// its lstat, makes it one of rules.excludePaths, and "" when it does
+// of rules.excluded, and "" when it is not.
-// not.
+func (rules walkRules) excludedLine(path string) string {
-func (rules walkRules) excludePathLine(path string, fi fs.FileInfo) string {
+	if !slices.Contains(rules.excluded, path) {
-	if matchingExcludePath(fi, rules.excludePaths) == "" {
 		return ""
 	}
 

internal/sfdupes/exclude_test.go

@@ -191,7 +191,7 @@ func TestScanDoesNotEnterDefaultExclude(t *testing.T) {
 	unseen := writeFile(t, excluded, "new", pattern(2, 10))
 
 	st, err := syncScan(t.Context(), db, []string{dir}, 1, false,
-		walkRules{defaultExcludes: []string{excluded}})
+		walkRules{excludes: []string{excluded}})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -237,7 +237,7 @@ func TestScanWalksOperandInDefaultExclude(t *testing.T) {
 			db := openTestDB(t)
 
 			st, err := syncScan(t.Context(), db, roots, 1, false,
-				walkRules{defaultExcludes: []string{excluded}})
+				walkRules{excludes: []string{excluded}})
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -265,7 +265,7 @@ func TestScanNamesNoDefaultExcludeThatIsAnOperand(t *testing.T) {
 	f := writeFile(t, excluded, "f", pattern(1, 10))
 
 	st, err := syncScan(t.Context(), db, []string{dir, excluded}, 1, false,
-		walkRules{defaultExcludes: []string{excluded}})
+		walkRules{excludes: []string{excluded}})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -415,64 +415,13 @@ func TestRunScanExcludeRepeated(t *testing.T) {
 	assertRecorded(t, path, kept, true)
 }
 
-// TestRunScanExcludeReachedByAnotherPath gives --exclude a directory
-// through a symlink and a file through "..", so the walk reaches
-// neither by the path given. The walk also reaches the file through a
-// hard link. It records none of these, prints a line naming each, and
-// records the file beside them.
-func TestRunScanExcludeReachedByAnotherPath(t *testing.T) {
-	path := testDBPath(t)
-	t.Setenv(databaseEnv, path)
-
-	dir := realTempDir(t)
-	inDir := writeFile(t, dir, "a/cache/f", pattern(1, 10))
-	file := writeFile(t, dir, "a/big", pattern(2, 10))
-	kept := writeFile(t, dir, "keep", pattern(3, 10))
-
-	hardLink := filepath.Join(dir, "big-link")
-
-	err := os.Link(file, hardLink)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	link := filepath.Join(t.TempDir(), "link")
-	symlink(t, filepath.Join(dir, "a"), link)
-
-	// Joined as text, since filepath.Join would drop the "..".
-	dotDot := dir + "/a/cache/../big"
-
-	stderr := scanOK(t, excludeFlag, filepath.Join(link, "cache"),
-		excludeFlag, dotDot, dir)
-
-	for _, skipped := range []string{filepath.Dir(inDir), file, hardLink} {
-		line := "scan: skipped " + skipped + " (--exclude)\n"
-		if !strings.Contains(stderr, line) {
-			t.Errorf("stderr = %q, want %q", stderr, line)
-		}
-	}
-
-	assertRecorded(t, path, inDir, false)
-	assertRecorded(t, path, file, false)
-	assertRecorded(t, path, hardLink, false)
-	assertRecorded(t, path, kept, true)
-}
-
 // TestRunScanExcludedOperand checks that an operand at or below an
 // --exclude path is a fatal error that names both, and so is an
-// --exclude path that does not exist. An operand that is a hard link to
+// --exclude path that does not exist. Neither scan writes a database.
-// an --exclude file is at it. Neither scan writes a database.
 func TestRunScanExcludedOperand(t *testing.T) {
 	dir := realTempDir(t)
 	sub := filepath.Join(dir, "sub")
-	f := writeFile(t, sub, "f", pattern(1, 10))
+	writeFile(t, sub, "f", pattern(1, 10))
-
-	hardLink := filepath.Join(dir, "f-link")
-
-	err := os.Link(f, hardLink)
-	if err != nil {
-		t.Fatal(err)
-	}
 
 	cases := map[string]struct {
 		args []string
@@ -490,10 +439,6 @@ func TestRunScanExcludedOperand(t *testing.T) {
 			[]string{dir, excludeFlag, sub, sub},
 			"scan " + sub + ": operand excluded by --exclude " + sub + "\n",
 		},
-		"a hard link to it": {
-			[]string{excludeFlag, f, hardLink},
-			"scan " + hardLink + ": operand excluded by --exclude " + f + "\n",
-		},
 		"exclude missing": {
 			[]string{excludeFlag, filepath.Join(dir, "nope"), dir},
 			"--exclude: resolve " + filepath.Join(dir, "nope") + ": ",

internal/sfdupes/progress_test.go

@@ -642,9 +642,9 @@ func TestTerminalStalledLines(t *testing.T) {
 		{label: scanPhase("hash"), stalledOn: hashStalledOn},
 		{label: scanPhase("update"), stalledOn: "db"},
 		{label: treesPhase("read"), stalledOn: "db"},
-		{label: treesPhase("group"), stalledOn: "cpu/disk"},
+		{label: treesPhase("group"), stalledOn: "cpu"},
 		{label: treesPhase("write"), stalledOn: "out"},
-		{label: reportPhase("read"), stalledOn: "db/disk/out"},
+		{label: reportPhase("read"), stalledOn: "db/out"},
 	}
 
 	for _, params := range phases {

internal/sfdupes/report.go

@@ -4,14 +4,11 @@ import (
 	"context"
 	"crypto/sha256"
 	"database/sql"
-	"errors"
 	"fmt"
 	"io"
-	"io/fs"
 	"os"
 	"slices"
 	"strings"
-	"syscall"
 	"time"
 )
 
@@ -44,10 +41,10 @@ func reportPhase(name string) string {
 }
 
 // runReport implements the report subcommand: it prints the file-level
-// duplicates report as TSV on stdout. Of the scanned filesystem it
+// duplicates report as TSV on stdout. It never touches the scanned
-// only checks, with pathExists, that each path in a duplicate group is
+// filesystem; its only I/O is the database, stdout, and stderr. It
-// still there. It names the database on stderr before it opens it. Any
+// names the database on stderr before it opens it. Any database
-// database problem, including a missing database, is fatal.
+// problem, including a missing database, is fatal.
 //
 // The work runs in two phases, each under a progress display of its
 // own on stderr: open (open the database) and read (read the number of
@@ -80,14 +77,13 @@ func runReport(ctx context.Context, stdout io.Writer) error {
 
 	defer func() { _ = db.Close() }()
 
-	// The read phase checks the paths of each duplicate group on disk
+	// The read phase writes the report to stdout while it reads the
-	// and writes the report to stdout while it reads the records, so it
+	// records, so it may wait on either.
-	// may wait on any of the three.
 	prog = newProgress(progressParams{
 		label: reportPhase("read"), unit: "records", total: -1,
-		waitingFor: countingRecords, stalledOn: "db/disk/out",
+		waitingFor: countingRecords, stalledOn: "db/out",
 	})
-	report, err := readReport(ctx, db, dbPath, stdout, pathExists, prog)
+	report, err := readReport(ctx, db, dbPath, stdout, prog)
 
 	prog.finish()
 
@@ -108,15 +104,14 @@ func runReport(ctx context.Context, stdout io.Writer) error {
 // dbPath, as its total, then reads every record in signature order,
 // counting each on prog, and writes the report to stdout: the header
 // line, then the rows of each size's duplicate groups once that size is
-// read. A path for which exists returns false is left out of its group.
+// read. stdout may be the terminal prog is drawn on, so the lines go
-// stdout may be the terminal prog is drawn on, so the lines go through
+// through prog's writer. It returns what it wrote, with the totals for
-// prog's writer. It returns what it wrote, with the totals for the
+// the summary line.
-// summary line.
 func readReport(ctx context.Context, db *sql.DB, dbPath string,
-	stdout io.Writer, exists func(path string) bool, prog *progress,
+	stdout io.Writer, prog *progress,
 ) (*reportWriter, error) {
 	out := prog.writer(stdout)
-	report := &reportWriter{out: out, exists: exists}
+	report := &reportWriter{out: out}
 
 	_, err := fmt.Fprintln(out, "first\tdupe\tsize")
 	if err != nil {
@@ -163,10 +158,6 @@ func readReport(ctx context.Context, db *sql.DB, dbPath string,
 type reportWriter struct {
 	out io.Writer
 
-	// exists reports whether a path is still on disk. A path that is
-	// gone is left out of its group.
-	exists func(path string) bool
-
 	sig    scanRec    // the signature being read; its path is not used
 	paths  []string   // the paths read so far with sig
 	groups [][]string // the duplicate groups of sig.size, each sorted
@@ -203,18 +194,10 @@ func (w *reportWriter) add(r scanRec) error {
 	return nil
 }
 
-// endGroup ends the paths read with w.sig: two or more that are still
+// endGroup ends the paths read with w.sig: two or more are a duplicate
-// on disk are a duplicate group, held with its paths sorted until
+// group, held with its paths sorted until writeGroups writes it. Empty
-// writeGroups writes it. Empty files form no group, since removing one
+// files form no group, since removing one frees nothing.
-// frees nothing. Only the paths of a possible group are checked, never
-// a path with no duplicate or an empty file.
 func (w *reportWriter) endGroup() {
-	if len(w.paths) >= minGroupSize && w.sig.size > 0 {
-		w.paths = slices.DeleteFunc(w.paths, func(p string) bool {
-			return !w.exists(p)
-		})
-	}
-
 	if len(w.paths) < minGroupSize || w.sig.size == 0 {
 		// The paths are dropped, and their slice reused.
 		w.paths = w.paths[:0]
@@ -263,16 +246,6 @@ func (w *reportWriter) finish() error {
 	return w.writeGroups()
 }
 
-// pathExists reports whether path is still on disk, for report and
-// trees. It is false only when lstat finds that the path, or a
-// directory above it, is gone. Any other error counts as present, so
-// a user who may not look inside a directory still sees its copies.
-func pathExists(path string) bool {
-	_, err := os.Lstat(path)
-
-	return !errors.Is(err, fs.ErrNotExist) && !errors.Is(err, syscall.ENOTDIR)
-}
-
 // escapePath returns a path as it is written in a report column (README
 // "Report output format"): a backslash, tab, newline or carriage return
 // becomes \\, \t, \n or \r, and every other byte is kept as it is.

internal/sfdupes/report_test.go

@@ -72,37 +72,15 @@ type dupeGroup struct {
 	paths []string
 }
 
-// everyPathExists stands in for pathExists where a test's records name
-// made-up paths that are not on disk.
-func everyPathExists(string) bool { return true }
-
-// recsOnDisk returns a new directory and recs with each path moved
-// under it, after creating an empty file at each moved path: report and
-// trees then find every path still on disk.
-func recsOnDisk(t *testing.T, recs []scanRec) (string, []scanRec) {
-	t.Helper()
-
-	dir := realTempDir(t)
-	moved := make([]scanRec, len(recs))
-
-	for i, r := range recs {
-		r.path = writeFile(t, dir, r.path, nil)
-		moved[i] = r
-	}
-
-	return dir, moved
-}
-
 // dupeGroups returns the duplicate groups report reads from db, in
 // report order, from the rows it writes: a group's rows come together,
-// each naming the group's first path. Every path counts as still on
+// each naming the group's first path.
-// disk.
 func dupeGroups(t *testing.T, db *sql.DB) []dupeGroup {
 	t.Helper()
 
 	var out bytes.Buffer
 
-	_, err := readReport(t.Context(), db, "", &out, everyPathExists, nil)
+	_, err := readReport(t.Context(), db, "", &out, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -149,8 +127,7 @@ func dupeGroupsOf(t *testing.T, recs []scanRec) []dupeGroup {
 }
 
 func TestRunReportEscapesPaths(t *testing.T) {
-	dir, recs := recsOnDisk(t, awkwardPairRecs())
+	t.Setenv(databaseEnv, seedDatabase(t, awkwardPairRecs()))
-	t.Setenv(databaseEnv, seedDatabase(t, recs))
 
 	var stdout, stderr bytes.Buffer
 
@@ -161,7 +138,7 @@ func TestRunReportEscapesPaths(t *testing.T) {
 	}
 
 	want := "first\tdupe\tsize\n" +
-		dir + `/d/\tone\ntwo\rthree\\four/f` + "\t" + dir + "/d/A/f\t5\n"
+		`/d/\tone\ntwo\rthree\\four/f` + "\t/d/A/f\t5\n"
 	if got := stdout.String(); got != want {
 		t.Errorf("stdout = %q, want %q", got, want)
 	}
@@ -195,8 +172,7 @@ func TestReportStdoutFailsWhileReading(t *testing.T) {
 	// Counts the records read, and draws nothing.
 	prog := &progress{now: time.Now}
 
-	_, err = readReport(t.Context(), db, "", failingWriter{},
+	_, err = readReport(t.Context(), db, "", failingWriter{}, prog)
-		everyPathExists, prog)
 	if !errors.Is(err, errWriteFailed) ||
 		!strings.HasPrefix(err.Error(), "write stdout: ") {
 		t.Errorf("error = %v, want write stdout: %v", err, errWriteFailed)
@@ -227,8 +203,7 @@ const smokeReport = "first\tdupe\tsize\n" +
 // it ends; read counts the 6 records before it reads them. The summary
 // comes last, and stdout holds the report alone.
 func TestRunReportProgressNamesEachPhase(t *testing.T) {
-	dir, recs := recsOnDisk(t, smokeTreeRecs())
+	path := seedDatabase(t, smokeTreeRecs())
-	path := seedDatabase(t, recs)
 	t.Setenv(databaseEnv, path)
 
 	stderr := captureStderr(t)
@@ -241,9 +216,8 @@ func TestRunReportProgressNamesEachPhase(t *testing.T) {
 			code, exitOK, stderr())
 	}
 
-	report := strings.ReplaceAll(smokeReport, "/d/", dir+"/d/")
+	if got := stdout.String(); got != smokeReport {
-	if got := stdout.String(); got != report {
+		t.Errorf("stdout = %q, want %q", got, smokeReport)
-		t.Errorf("stdout = %q, want %q", got, report)
 	}
 
 	// How each line starts; the rate at the end of a phase varies.
@@ -292,7 +266,7 @@ func TestReadReportOnTerminal(t *testing.T) {
 		waitingFor: countingRecords,
 	}, terminalWidth, time.Hour, time.Now)
 
-	_, err = readReport(t.Context(), db, "", os.Stderr, everyPathExists, p)
+	_, err = readReport(t.Context(), db, "", os.Stderr, p)
 
 	p.finish()
 
@@ -327,8 +301,6 @@ func TestRunReportsIgnoreInsertionOrder(t *testing.T) {
 		scanRec{size: 50, head: a, tail: a, content: a, path: "/x/1"},
 	)
 
-	_, recs = recsOnDisk(t, recs)
-
 	reversed := slices.Clone(recs)
 	slices.Reverse(reversed)
 
@@ -483,119 +455,6 @@ func TestDupeGroupsLeavesOutEmptyFiles(t *testing.T) {
 	}
 }
 
-// TestReadReportChecksOnlyPossibleDuplicates checks that report asks
-// whether a path is on disk only when its signature has two or more
-// records, and never for an empty file.
-func TestReadReportChecksOnlyPossibleDuplicates(t *testing.T) {
-	t.Parallel()
-
-	a, u, e := testHash("a"), testHash("u"), sha256.Sum256(nil)
-	recs := []scanRec{
-		{size: 9, head: a, tail: a, content: a, path: "/copy/1"},
-		{size: 9, head: a, tail: a, content: a, path: "/copy/2"},
-		{size: 9, head: a, tail: a, content: a, path: "/copy/3"},
-		{size: 9, head: u, tail: u, content: u, path: "/lonely"},
-		{size: 0, head: e, tail: e, content: e, path: "/empty1"},
-		{size: 0, head: e, tail: e, content: e, path: "/empty2"},
-	}
-
-	db := openTestDB(t)
-
-	err := applyChanges(t.Context(), db, recs, nil, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var checked []string
-
-	exists := func(path string) bool {
-		checked = append(checked, path)
-
-		return true
-	}
-
-	_, err = readReport(t.Context(), db, "", io.Discard, exists, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	slices.Sort(checked)
-
-	want := []string{"/copy/1", "/copy/2", "/copy/3"}
-	if !slices.Equal(checked, want) {
-		t.Errorf("paths checked on disk = %q, want %q", checked, want)
-	}
-}
-
-// TestReadReportDropsGroupLeftWithOnePath checks that a group of two
-// paths, one of them gone, is no duplicate group. If kept, it would
-// write no row, but the summary line would count it.
-func TestReadReportDropsGroupLeftWithOnePath(t *testing.T) {
-	t.Parallel()
-
-	a := testHash("a")
-	recs := []scanRec{
-		{size: 9, head: a, tail: a, content: a, path: "/a/kept"},
-		{size: 9, head: a, tail: a, content: a, path: "/a/gone"},
-	}
-
-	db := openTestDB(t)
-
-	err := applyChanges(t.Context(), db, recs, nil, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	exists := func(path string) bool { return path != "/a/gone" }
-
-	report, err := readReport(t.Context(), db, "", io.Discard, exists, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if report.dupeGroups != 0 {
-		t.Errorf("duplicate groups = %d, want 0", report.dupeGroups)
-	}
-}
-
-// TestReadReportKeepsGroupLeftWithTwoPaths checks that a group of three
-// paths, one of them gone, is a duplicate group of the other two.
-func TestReadReportKeepsGroupLeftWithTwoPaths(t *testing.T) {
-	t.Parallel()
-
-	a := testHash("a")
-	recs := []scanRec{
-		{size: 9, head: a, tail: a, content: a, path: "/b/kept1"},
-		{size: 9, head: a, tail: a, content: a, path: "/b/gone"},
-		{size: 9, head: a, tail: a, content: a, path: "/b/kept2"},
-	}
-
-	db := openTestDB(t)
-
-	err := applyChanges(t.Context(), db, recs, nil, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	exists := func(path string) bool { return path != "/b/gone" }
-
-	var out bytes.Buffer
-
-	report, err := readReport(t.Context(), db, "", &out, exists, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if report.dupeGroups != 1 {
-		t.Errorf("duplicate groups = %d, want 1", report.dupeGroups)
-	}
-
-	want := "first\tdupe\tsize\n/b/kept1\t/b/kept2\t9\n"
-	if got := out.String(); got != want {
-		t.Errorf("stdout = %q, want %q", got, want)
-	}
-}
-
 func TestDupeGroupsContentSeparates(t *testing.T) {
 	t.Parallel()
 

internal/sfdupes/scan.go

@@ -103,11 +103,11 @@ func scanPhase(name string) string {
 // scan lists the filesystems that are not persistent, on which the walk
 // records nothing; unless noDefaultExcludes is set, the walk does not
 // enter the default excludes either. The walk neither enters nor
-// records the paths in excludePaths, the --exclude values; an operand
+// records the paths in excluded, the --exclude values; an operand at or
-// at or below one is a fatal error. Once the database is open, the scan
+// below one is a fatal error. Once the database is open, the scan notes
-// notes its files, which the walk passes over.
+// its files, which the walk passes over.
 func runScan(ctx context.Context, roots []string, workers int,
-	oneFS, noDefaultExcludes bool, excludePaths []string,
+	oneFS, noDefaultExcludes bool, excluded []string,
 ) error {
 	dbPath, source, err := databasePath()
 	if err != nil {
@@ -121,25 +121,24 @@ func runScan(ctx context.Context, roots []string, workers int,
 		return err
 	}
 
-	var rules walkRules
+	excluded, err = realPaths(excluded)
-
-	rules.excludePaths, err = excludePathInodes(excludePaths)
 	if err != nil {
 		return fmt.Errorf("--exclude: %w", err)
 	}
 
-	err = checkOperandsNotExcluded(roots, rules.excludePaths)
+	err = checkOperandsNotExcluded(roots, excluded)
 	if err != nil {
 		return err
 	}
 
-	rules.nonPersistent, err = nonPersistentFilesystems()
+	nonPersistent, err := nonPersistentFilesystems()
 	if err != nil {
 		return fmt.Errorf("list the mounted filesystems: %w", err)
 	}
 
+	rules := walkRules{excluded: excluded, nonPersistent: nonPersistent}
 	if !noDefaultExcludes {
-		rules.defaultExcludes = defaultExcludes(runtime.GOOS)
+		rules.excludes = defaultExcludes(runtime.GOOS)
 	}
 
 	lock, err := lockScanDatabase(dbPath)
@@ -315,7 +314,7 @@ func walkReaches(above, r string, oneFS bool, rules walkRules,
 	}
 
 	for ; dir != above; dir = filepath.Dir(dir) {
-		if isDefaultExclude(dir, rules.defaultExcludes) {
+		if isDefaultExclude(dir, rules.excludes) {
 			return false
 		}
 
@@ -566,7 +565,7 @@ func (s *scanState) walkPhase(events <-chan walkEvent, roots []string) {
 		prog.increment()
 
 		old, ok := s.existing[ev.rec.path]
-		if !ok || old.size != ev.rec.size || !ev.rec.mtime.Equal(old.mtime) {
+		if !ok || old.size != ev.rec.size || mtimeAfter(ev.rec.mtime, old.mtime) {
 			s.toHash = append(s.toHash, ev.rec)
 
 			continue
@@ -801,6 +800,16 @@ func (s *scanState) updatePhase(ctx context.Context) error {
 	return applyChanges(ctx, s.db, nil, deletes, prog)
 }
 
+// mtimeAfter reports whether mtime a is later than mtime b.
+// Not a.After(b): time.Time wraps an mtime past year 292 billion; Unix() undoes it.
+func mtimeAfter(a, b time.Time) bool {
+	if a.Unix() != b.Unix() {
+		return a.Unix() > b.Unix()
+	}
+
+	return a.Nanosecond() > b.Nanosecond()
+}
+
 // underAnyRoot reports whether path is any of the roots or lies under
 // one of them.
 func underAnyRoot(path string, roots []string) bool {
@@ -1139,9 +1148,8 @@ func walkOneDir(ctx context.Context, job dirJob, oneFS bool,
 // no longer exists, and one that has stopped being a regular file is
 // skipped. A file on a filesystem in rules that is not persistent, as
 // through a bind mount of one file, is not recorded: it gets an event
-// naming it instead, and so does a file given with --exclude, reached
+// naming it instead, and so does a file given with --exclude. One of
-// by any path, a hard link to it included. One of the scan's own
+// the scan's own database files in rules gets no event at all.
-// database files in rules gets no event at all.
 func emitFile(ctx context.Context, p string, e fs.DirEntry,
 	rules walkRules, events chan<- walkEvent,
 ) {
@@ -1166,7 +1174,7 @@ func emitFile(ctx context.Context, p string, e fs.DirEntry,
 
 	line := rules.nonPersistentLine(p, info)
 	if line == "" {
-		line = rules.excludePathLine(p, info)
+		line = rules.excludedLine(p)
 	}
 
 	if line != "" {
@@ -1223,7 +1231,7 @@ func subdirJob(ctx context.Context, p string, e fs.DirEntry,
 
 	line := rules.nonPersistentLine(p, info)
 	if line == "" {
-		line = rules.excludePathLine(p, info)
+		line = rules.excludedLine(p)
 	}
 
 	if line != "" {
@@ -1232,7 +1240,7 @@ func subdirJob(ctx context.Context, p string, e fs.DirEntry,
 		return dirJob{}, false
 	}
 
-	if isDefaultExclude(p, rules.defaultExcludes) {
+	if isDefaultExclude(p, rules.excludes) {
 		sendEvent(ctx, events, walkEvent{
 			leftOut: p,
 			warn:    fmt.Sprintf("scan: skipped %s (default exclude)", p),

internal/sfdupes/scan_test.go

@@ -1215,7 +1215,7 @@ func assertSmokeTreeGroups(t *testing.T, dir string, db *sql.DB) {
 
 	super, dirs := dbTree(t, db)
 
-	tg := collectTreeGroups(dirs, super, everyPathExists, nil)
+	tg := collectTreeGroups(dirs, super, nil)
 	if len(tg) != 1 {
 		t.Fatalf("len(tree groups) = %d, want 1", len(tg))
 	}
@@ -1384,47 +1384,6 @@ func TestSyncScanMtimeBump(t *testing.T) {
 	}
 }
 
-// TestSyncScanMtimeMovedBack replaces a file with other content of the
-// same size and an older mtime, as cp -p or a restore from backup does.
-// The next scan must hash the file again.
-func TestSyncScanMtimeMovedBack(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	db := openTestDB(t)
-	a := writeFile(t, dir, "a.bin", pattern(1, 500))
-
-	recorded := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-
-	err := os.Chtimes(a, recorded, recorded)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	syncTree(t, db, dir)
-
-	replaced := pattern(3, 500)
-	writeFile(t, dir, "a.bin", replaced)
-
-	older := recorded.Add(-time.Hour)
-
-	err = os.Chtimes(a, older, older)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	st := syncTree(t, db, dir)
-	if st != (scanStats{walked: 1, updated: 1}) {
-		t.Fatalf("rescan stats = %+v, want 1 updated", st)
-	}
-
-	assertWholeFileHashed(t, db, a, replaced)
-
-	if r := recordByPath(t, dbRecords(t, db), a); !r.mtime.Equal(older) {
-		t.Fatalf("mtime = %v, want %v", r.mtime, older)
-	}
-}
-
 // assertWholeFileHashed fails unless the record for path holds the
 // whole-file hash of data as its head, tail, and content.
 func assertWholeFileHashed(t *testing.T, db *sql.DB, path string,
@@ -2289,7 +2248,7 @@ func TestPruneRoots(t *testing.T) {
 
 	// The walk of /p does not enter /p/q when it is a default exclude, so
 	// /p/q is kept, without -x too; /p/q/r lies under it and is dropped.
-	got = pruneRoots(nested, false, walkRules{defaultExcludes: []string{pqRoot}},
+	got = pruneRoots(nested, false, walkRules{excludes: []string{pqRoot}},
 		device)
 	if !slices.Equal(got, want) {
 		t.Fatalf("pruneRoots excluding %s = %q, want %q", pqRoot, got, want)
@@ -2307,86 +2266,23 @@ func TestPruneRoots(t *testing.T) {
 	}
 }
 
-// TestRunReportsLeaveOutRemovedCopies scans the smoke tree, then
+func TestReportsNeverTouchFilesystem(t *testing.T) {
-// removes copies the reports name. report leaves out each removed file,
-// and a group left with one path. trees checks only the root of each
-// duplicate tree: with a file under t2 removed it still names t2, and
-// with t2 removed it names nothing.
-func TestRunReportsLeaveOutRemovedCopies(t *testing.T) {
-	t.Setenv(databaseEnv, testDBPath(t))
-
-	dir := buildSmokeTree(t)
-	p := func(name string) string { return filepath.Join(dir, name) }
-
-	scanOK(t, dir)
-
-	for _, name := range []string{"b/copy2.bin", "tiny2", "t2/sub/f2"} {
-		err := os.Remove(p(name))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	want := "first\tdupe\tsize\n" +
-		p("t1/f1") + "\t" + p("t2/f1") + "\t3000\n" +
-		p("t1/f1") + "\t" + p("t3/f1") + "\t3000\n" +
-		p("a/one.bin") + "\t" + p("b/copy.bin") + "\t2000\n" +
-		p("t1/sub/f2") + "\t" + p("t3/sub/f2renamed") + "\t100\n"
-	if got := runStdout(t, cmdReport); got != want {
-		t.Errorf("report stdout = %q, want %q", got, want)
-	}
-
-	// disk_size, the last column, depends on the filesystem.
-	header := "first\tdupe\tfiles\tsize\tdisk_size\n"
-
-	want = header + p("t1") + "\t" + p("t2") + "\t2\t3100\t"
-	if got := runStdout(t, cmdTrees); !strings.HasPrefix(got, want) ||
-		strings.Count(got, "\n") != 2 {
-		t.Errorf("trees stdout = %q, want one row starting %q", got, want)
-	}
-
-	err := os.RemoveAll(p("t2"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if got := runStdout(t, cmdTrees); got != header {
-		t.Errorf("trees stdout after removing t2 = %q, want %q", got, header)
-	}
-}
-
-func TestPathExists(t *testing.T) {
 	t.Parallel()
 
-	dir := t.TempDir()
+	dir := buildSmokeTree(t)
-	file := writeFile(t, dir, "file", nil)
+	db := openTestDB(t)
-	locked := writeFile(t, dir, "locked/file", nil)
 
-	// Without search permission on its directory, a file cannot be
+	syncTree(t, db, dir)
-	// looked at by anyone but root.
+
-	err := os.Chmod(filepath.Dir(locked), 0)
+	// Remove the scanned tree entirely; the analysis must be
+	// unaffected because it reads the database alone.
+	err := os.RemoveAll(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	// Runs before t.TempDir's own cleanup, which must delete the files.
+	assertSmokeDupeGroups(t, dir, db)
-	t.Cleanup(func() {
+	assertSmokeTreeGroups(t, dir, db)
-		//nolint:gosec // removing the directory needs its search bit back
-		_ = os.Chmod(filepath.Dir(locked), 0o700)
-	})
-
-	cases := map[string]bool{
-		dir:                                 true,
-		file:                                true,
-		locked:                              true,
-		filepath.Join(dir, "gone"):          false,
-		filepath.Join(file, "under-a-file"): false,
-	}
-	for path, want := range cases {
-		if got := pathExists(path); got != want {
-			t.Errorf("pathExists(%q) = %v, want %v", path, got, want)
-		}
-	}
 }
 
 func TestUnderRoot(t *testing.T) {

internal/sfdupes/trees.go

@@ -38,11 +38,10 @@ func treesPhase(name string) string {
 // runTrees implements the trees subcommand: it reads every record from
 // the database in path order, reconstructs the directory hierarchy from
 // the record paths, computes a Merkle-style digest per directory, and
-// prints maximal duplicate-tree groups as TSV on stdout. Of the scanned
+// prints maximal duplicate-tree groups as TSV on stdout. It never
-// filesystem it only checks, with pathExists, that the root of each
+// touches the scanned filesystem; its only I/O is the database, stdout,
-// duplicate tree is still there, never the files below it. It names the
+// and stderr. It names the database on stderr before it opens it. Any
-// database on stderr before it opens it. Any database problem,
+// database problem, including a missing database, is fatal.
-// including a missing database, is fatal.
 //
 // The work runs in four phases, each under a progress display of its
 // own on stderr: open (open the database), read (read the number of
@@ -87,13 +86,13 @@ func runTrees(ctx context.Context, stdout io.Writer) error {
 		return fmt.Errorf("database %s: %w", dbPath, err)
 	}
 
-	// Grouping works in memory, then checks the root of each duplicate
+	// Grouping works in memory, so it waits on nothing but the
-	// tree on disk, so it waits on the processor or the disk.
+	// processor.
 	prog = newProgress(progressParams{
 		label: treesPhase("group"), unit: "directories",
-		total: int64(len(allDirs)), stalledOn: "cpu/disk",
+		total: int64(len(allDirs)), stalledOn: "cpu",
 	})
-	dupes := collectTreeGroups(allDirs, super, pathExists, prog)
+	dupes := collectTreeGroups(allDirs, super, prog)
 
 	prog.finish()
 
@@ -301,14 +300,12 @@ func fileEntry(name string, r scanRec) string {
 
 // collectTreeGroups groups directories by digest, counting each one on
 // prog as it is grouped, and returns every maximal group with two or
-// more members for which exists returns true, each group's members
+// more members, each group's members sorted by path, groups ordered by
-// sorted by path, groups ordered by tree size descending then by first
+// tree size descending then by first path ascending. A group whose
-// path ascending. A group whose trees hold 0 bytes is left out, since
+// trees hold 0 bytes is left out, since removing one frees nothing. The
-// removing one frees nothing. The groups it implies hold 0 bytes too,
+// groups it implies hold 0 bytes too, so leaving it out hides nothing.
-// so leaving it out hides nothing. exists is called only on the members
-// of maximal groups.
 func collectTreeGroups(allDirs []*treeNode, super *treeNode,
-	exists func(path string) bool, prog *progress,
+	prog *progress,
 ) [][]*treeNode {
 	groups := make(map[[sha256.Size]byte][]*treeNode)
 	for _, d := range allDirs {
@@ -326,16 +323,6 @@ func collectTreeGroups(allDirs []*treeNode, super *treeNode,
 			continue
 		}
 
-		// A member that is gone leaves the group. A suppressed group is
-		// still implied: its members still on disk have parents still
-		// on disk, and those parents' group is checked the same way.
-		g = slices.DeleteFunc(g, func(n *treeNode) bool {
-			return !exists(n.path)
-		})
-		if len(g) < minGroupSize {
-			continue
-		}
-
 		slices.SortFunc(g, func(a, b *treeNode) int {
 			return strings.Compare(a.path, b.path)
 		})

internal/sfdupes/trees_test.go

@@ -6,7 +6,6 @@ import (
 	"database/sql"
 	"os"
 	"slices"
-	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -180,7 +179,7 @@ func TestTreeNamesSortingBeforeSlash(t *testing.T) {
 		t.Fatalf("directory paths = %q, want %q", got, want)
 	}
 
-	groups := collectTreeGroups(dirs, super, everyPathExists, nil)
+	groups := collectTreeGroups(dirs, super, nil)
 
 	gotGroups := groupPaths(groups)
 	wantGroups := [][]string{{"/a", "/c"}}
@@ -196,8 +195,7 @@ func TestTreeNamesSortingBeforeSlash(t *testing.T) {
 }
 
 func TestRunTreesEscapesPaths(t *testing.T) {
-	dir, recs := recsOnDisk(t, awkwardPairRecs())
+	t.Setenv(databaseEnv, seedDatabase(t, awkwardPairRecs()))
-	t.Setenv(databaseEnv, seedDatabase(t, recs))
 
 	var stdout, stderr bytes.Buffer
 
@@ -208,7 +206,7 @@ func TestRunTreesEscapesPaths(t *testing.T) {
 	}
 
 	want := "first\tdupe\tfiles\tsize\tdisk_size\n" +
-		dir + `/d/\tone\ntwo\rthree\\four` + "\t" + dir + "/d/A\t1\t5\t4096\n"
+		`/d/\tone\ntwo\rthree\\four` + "\t/d/A\t1\t5\t4096\n"
 	if got := stdout.String(); got != want {
 		t.Errorf("stdout = %q, want %q", got, want)
 	}
@@ -226,11 +224,9 @@ func TestRunTreesDiskSize(t *testing.T) {
 		{size: 20, diskSize: 1024, head: g, tail: g, content: g, path: "/b/sub/g"},
 	}
 
-	dir, recs := recsOnDisk(t, recs)
 	t.Setenv(databaseEnv, seedDatabase(t, recs))
 
-	want := "first\tdupe\tfiles\tsize\tdisk_size\n" +
+	want := "first\tdupe\tfiles\tsize\tdisk_size\n/a\t/b\t2\t30\t1536\n"
-		dir + "/a\t" + dir + "/b\t2\t30\t1536\n"
 	if got := runStdout(t, cmdTrees); got != want {
 		t.Errorf("stdout = %q, want %q", got, want)
 	}
@@ -241,11 +237,10 @@ func TestRunTreesDiskSize(t *testing.T) {
 // there. After the line naming the database, each phase prints a line
 // naming it with its place among the four as it starts and another as
 // it ends. read counts the 6 records before it reads them, group counts
-// the directories, and write the 1 group. The summary comes last, and
+// the 8 directories, and write the 1 group. The summary comes last, and
 // stdout holds the report alone.
 func TestRunTreesProgressNamesEachPhase(t *testing.T) {
-	dir, recs := recsOnDisk(t, smokeTreeRecs())
+	path := seedDatabase(t, smokeTreeRecs())
-	path := seedDatabase(t, recs)
 	t.Setenv(databaseEnv, path)
 
 	stderr := captureStderr(t)
@@ -259,15 +254,11 @@ func TestRunTreesProgressNamesEachPhase(t *testing.T) {
 	}
 
 	report := "first\tdupe\tfiles\tsize\tdisk_size\n" +
-		dir + "/d/t1\t" + dir + "/d/t2\t2\t3100\t8192\n"
+		"/d/t1\t/d/t2\t2\t3100\t8192\n"
 	if got := stdout.String(); got != report {
 		t.Errorf("stdout = %q, want %q", got, report)
 	}
 
-	// The smoke-test records name 8 directories, / included. Moved under
-	// dir, they name one more for each slash in dir.
-	dirs := strconv.Itoa(8 + strings.Count(dir, "/"))
-
 	// How each line starts; the rate at the end of a phase varies.
 	want := []string{
 		"trees: database " + path + " (from " + databaseEnv + ")",
@@ -275,9 +266,8 @@ func TestRunTreesProgressNamesEachPhase(t *testing.T) {
 		treesOpenLine,
 		"[2/4] read: counting the records, elapsed 0s, remain unknown",
 		"[2/4] read: [6/6] 100%, ",
-		"[3/4] group: [0/" + dirs + "] 0%, 0 directories/s, elapsed 0s, " +
+		"[3/4] group: [0/8] 0%, 0 directories/s, elapsed 0s, remain unknown",
-			"remain unknown",
+		"[3/4] group: [8/8] 100%, ",
-		"[3/4] group: [" + dirs + "/" + dirs + "] 100%, ",
 		"[4/4] write: [0/1] 0%, 0 groups/s, elapsed 0s, remain unknown",
 		"[4/4] write: [1/1] 100%, ",
 		"trees: 6 records read, 1 duplicate tree groups, 1 dupe trees, ",
@@ -306,7 +296,7 @@ func TestRunTreesProgressNamesEachPhase(t *testing.T) {
 func TestWriteTreeGroupsOnTerminal(t *testing.T) {
 	stderr := captureStderr(t)
 	super, dirs := treeOf(t, smokeTreeRecs())
-	dupes := collectTreeGroups(dirs, super, everyPathExists, nil)
+	dupes := collectTreeGroups(dirs, super, nil)
 
 	// No timed draws: the display is drawn as it starts and as it ends.
 	p := startProgress(progressParams{
@@ -387,7 +377,7 @@ func TestCollectTreeGroupsMaximal(t *testing.T) {
 
 	super, dirs := treeOf(t, smokeTreeRecs())
 
-	groups := collectTreeGroups(dirs, super, everyPathExists, nil)
+	groups := collectTreeGroups(dirs, super, nil)
 
 	want := [][]string{{"/d/t1", "/d/t2"}}
 	if got := groupPaths(groups); !slices.EqualFunc(got, want,
@@ -411,16 +401,14 @@ func TestCollectTreeGroupsDeterministic(t *testing.T) {
 
 	super, dirs := treeOf(t, recs)
 
-	forward := groupPaths(collectTreeGroups(dirs, super, everyPathExists,
+	forward := groupPaths(collectTreeGroups(dirs, super, nil))
-		nil))
 
 	reversed := slices.Clone(recs)
 	slices.Reverse(reversed)
 
 	superR, dirsR := treeOf(t, reversed)
 
-	backward := groupPaths(collectTreeGroups(dirsR, superR, everyPathExists,
+	backward := groupPaths(collectTreeGroups(dirsR, superR, nil))
-		nil))
 	if !slices.EqualFunc(forward, backward, slices.Equal) {
 		t.Fatalf("output depends on record order: %v vs %v",
 			forward, backward)
@@ -440,7 +428,7 @@ func TestCollectTreeGroupsSiblings(t *testing.T) {
 
 	super, dirs := treeOf(t, recs)
 
-	got := groupPaths(collectTreeGroups(dirs, super, everyPathExists, nil))
+	got := groupPaths(collectTreeGroups(dirs, super, nil))
 
 	want := [][]string{{"/p/x1", "/p/x2"}}
 	if !slices.EqualFunc(got, want, slices.Equal) {
@@ -469,7 +457,7 @@ func TestCollectTreeGroupsLeavesOutEmptyTrees(t *testing.T) {
 
 	super, dirs := treeOf(t, recs)
 
-	got := groupPaths(collectTreeGroups(dirs, super, everyPathExists, nil))
+	got := groupPaths(collectTreeGroups(dirs, super, nil))
 
 	want := [][]string{{"/p/x1", "/p/x2"}}
 	if !slices.EqualFunc(got, want, slices.Equal) {
@@ -492,98 +480,10 @@ func TestCollectTreeGroupsDifferingParents(t *testing.T) {
 
 	super, dirs := treeOf(t, recs)
 
-	got := groupPaths(collectTreeGroups(dirs, super, everyPathExists, nil))
+	got := groupPaths(collectTreeGroups(dirs, super, nil))
 
 	want := [][]string{{"/p/a/x", "/q/b/x"}}
 	if !slices.EqualFunc(got, want, slices.Equal) {
 		t.Fatalf("groups = %v, want %v", got, want)
 	}
 }
-
-// TestCollectTreeGroupsChecksOnlyReportedCopies checks that trees asks
-// whether a directory is on disk only for the members of the groups it
-// returns. It never asks about /a/proj/sub, which lies inside a copy
-// and whose group the group of /a/proj implies.
-func TestCollectTreeGroupsChecksOnlyReportedCopies(t *testing.T) {
-	t.Parallel()
-
-	f, g, u := testHash("f"), testHash("g"), testHash("u")
-	recs := []scanRec{
-		{size: 10, head: f, tail: f, content: f, path: "/a/proj/f"},
-		{size: 20, head: g, tail: g, content: g, path: "/a/proj/sub/g"},
-		{size: 10, head: f, tail: f, content: f, path: "/b/proj/f"},
-		{size: 20, head: g, tail: g, content: g, path: "/b/proj/sub/g"},
-		// /a lacks this file, so /a and /b are no copies of each other.
-		{size: 30, head: u, tail: u, content: u, path: "/b/lonely"},
-	}
-
-	super, dirs := treeOf(t, recs)
-
-	var checked []string
-
-	exists := func(path string) bool {
-		checked = append(checked, path)
-
-		return true
-	}
-
-	got := groupPaths(collectTreeGroups(dirs, super, exists, nil))
-
-	want := [][]string{{"/a/proj", "/b/proj"}}
-	if !slices.EqualFunc(got, want, slices.Equal) {
-		t.Fatalf("groups = %v, want %v", got, want)
-	}
-
-	slices.Sort(checked)
-
-	if !slices.Equal(checked, want[0]) {
-		t.Errorf("directories checked on disk = %q, want %q",
-			checked, want[0])
-	}
-}
-
-// TestCollectTreeGroupsDropsGroupLeftWithOneCopy checks that a group of
-// two copies, one of them gone, is not returned. If kept, it would
-// write no row, but the summary line would count it.
-func TestCollectTreeGroupsDropsGroupLeftWithOneCopy(t *testing.T) {
-	t.Parallel()
-
-	f := testHash("f")
-	recs := []scanRec{
-		{size: 10, head: f, tail: f, content: f, path: "/c/kept/f"},
-		{size: 10, head: f, tail: f, content: f, path: "/c/gone/f"},
-	}
-
-	super, dirs := treeOf(t, recs)
-
-	exists := func(path string) bool { return path != "/c/gone" }
-
-	got := groupPaths(collectTreeGroups(dirs, super, exists, nil))
-	if len(got) != 0 {
-		t.Errorf("groups = %v, want none", got)
-	}
-}
-
-// TestCollectTreeGroupsKeepsGroupLeftWithTwoCopies checks that a group
-// of three copies, one of them gone, is returned with the other two.
-func TestCollectTreeGroupsKeepsGroupLeftWithTwoCopies(t *testing.T) {
-	t.Parallel()
-
-	f := testHash("f")
-	recs := []scanRec{
-		{size: 10, head: f, tail: f, content: f, path: "/d/kept1/f"},
-		{size: 10, head: f, tail: f, content: f, path: "/d/gone/f"},
-		{size: 10, head: f, tail: f, content: f, path: "/d/kept2/f"},
-	}
-
-	super, dirs := treeOf(t, recs)
-
-	exists := func(path string) bool { return path != "/d/gone" }
-
-	got := groupPaths(collectTreeGroups(dirs, super, exists, nil))
-
-	want := [][]string{{"/d/kept1", "/d/kept2"}}
-	if !slices.EqualFunc(got, want, slices.Equal) {
-		t.Errorf("groups = %v, want %v", got, want)
-	}
-}