Say in --help where the database is and what each report prints (closes #177 )

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 four 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. The README's opening drops its sentence on copies deleted after the scan, an edge case that its report and trees sections already cover. Model: opus-5-5
2026-11-11 05:57:25 +00:00
13 changed files with 126 additions and 575 deletions
@@ -254,14 +254,15 @@ In order:
 - `report` prints the file-level duplicate report from the database.
 - `trees` prints the duplicate-tree report from the database.
 - `info` prints the database's details.
- `dwim` scans `/`, then prints the duplicate-tree report.
+- `dwim` scans `/` with the default excludes, then prints the duplicate-tree
+  report.

 ```
 sfdupes scan [--workers N] [-x] [--no-default-excludes] [--exclude PATH]... PATH...
 sfdupes report > dupes.tsv
 sfdupes trees > dupetrees.tsv
 sfdupes info
-sfdupes dwim [--workers N] [-x] [--no-default-excludes] [--exclude PATH]...
+sfdupes dwim
 sfdupes --version
 sfdupes [command] --help
 ```
@@ -291,20 +292,20 @@ The reference below is also the program's specification.
  database is `/var/lib/sfdupes/db.sqlite`. There is no command-line flag for
  it. The path names the file exactly, whatever characters it holds. A relative
  path is relative to the working directory.
- `--workers N` (`scan`, `dwim`) sets how many directories `scan` reads at once
-  while it lists the trees. It also sets how many files `scan` reads at once
-  while it hashes them. The default is the number of CPUs. `N` must be at
-  least 1. A smaller value is a usage error, reported in one line on stderr with
-  exit 2 before anything is scanned.
- `-x`, `--one-file-system` (`scan`, `dwim`) keeps the walk of each operand out
-  of directories on other filesystems, as the same flag does for `du` and
-  `rsync`. By default the walk also enters directories on other filesystems.
- `--no-default-excludes` (`scan`, `dwim`) lets the walk enter the default
-  excludes. Those are the system and temporary directories the walk otherwise
-  leaves out, such as `/var/tmp` on Linux (see "Rules for the walk").
- `--exclude PATH` (`scan`, `dwim`) 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
+- `--workers N` (`scan`) sets how many directories `scan` reads at once while it
+  lists the trees. It also sets how many files `scan` reads at once while it
+  hashes them. The default is the number of CPUs. `N` must be at least 1. A
+  smaller value is a usage error, reported in one line on stderr with exit 2
+  before anything is scanned.
+- `-x`, `--one-file-system` (`scan`) keeps the walk of each operand out of
+  directories on other filesystems, as the same flag does for `du` and `rsync`.
+  By default the walk also enters directories on other filesystems.
+- `--no-default-excludes` (`scan`) lets the walk enter the default excludes.
+  Those are the system and temporary directories the walk otherwise leaves out,
+  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
  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
@@ -317,9 +318,9 @@ The reference below is also the program's specification.
 - `--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`
  names the database. The help of `report`, `trees`, `info` and `dwim` says what
-  each prints. `sfdupes scan --help` and `sfdupes dwim --help` also list the
-  default excludes of the system they run on, and the filesystem types the walk
-  never records anything on.
+  each prints. `sfdupes scan --help` also lists the default excludes of the
+  system it runs on, and the filesystem types the walk never records anything
+  on.

 ### Duplicate detection

@@ -857,25 +858,14 @@ trees: 14 records read, 1 duplicate tree groups, 1 dupe trees, 3.0 KiB reclaimab
 ### `dwim` mode

 `dwim`, short for "do what I mean", scans a new machine and reports its
-duplicate trees in one command. It takes no positional arguments. Like `scan`,
-it should run as root, so that it can read every file.
+duplicate trees in one command. It takes no positional arguments and no flags of
+its own. Like `scan`, it should run as root, so that it can read every file.

-`dwim` takes these flags of `scan`, with the same meaning (see "Settings"):
-
- `--workers N`;
- `-x`, `--one-file-system`;
- `--no-default-excludes`;
- `--exclude PATH`, which may be given more than once.
-
-`dwim` runs what `sfdupes scan /` runs with the same flags. With no flags, the
-walk skips the default excludes and crosses into other filesystems. The
+`dwim` runs what `sfdupes scan /` runs with no flags. The walk skips the default
+excludes and crosses into other filesystems. `--workers` keeps its default. The
 database, its creation and the scan lock are those of `scan`. Then `dwim` runs
 what `sfdupes trees` runs. The largest trees come first.

-```
-sfdupes dwim -x --exclude /srv/cache
-```
-
 The report goes to stdout, exactly as `trees` prints it. On stderr comes what
 `scan` prints, then what `trees` prints, then one last line:

@@ -1201,14 +1191,6 @@ On a terminal:
    ⠹ [3/4] hash: [12345/98765], 92 files/s, elapsed 2m32s, remain 17m44s            12% |█         |
    ```

- During `scan`'s `walk`, the line below the display shows the path of the last
-  file the walk found. Each draw shows the path of that moment, cut short before
-  the terminal's last column. The path is escaped as in the reports (see "Report
-  output format"). Each control character left after that is written as `\x` and
-  its code in two hexadecimal digits, such as `\x1b` for the escape character. A
-  control character is one that a terminal acts on instead of showing. The line
-  is erased when the walk ends, and the next phase is drawn on it.
-
 - No line reaches the terminal's last column. A line too wide for the terminal
  first leaves out its rate, the words of a stalled phase, or what the phase is
  waiting for. It leaves out its bar next. It is cut short at the edge only when
@@ -29,16 +29,6 @@
 Newest first. An entry ends with its date and its issue or branch, where those
 are known.

- On a terminal, the line below the `walk` display shows the path of the last
-  file the walk found, at each draw. Its control characters are written out, as
-  `\t` or `\x1b`, so that the terminal does not act on them. The line is erased
-  when the walk ends, and the next phase is drawn on it (2026-11-11,
-  https://git.eeqj.de/sneak/sfdupes/issues/160)
-
- `dwim` takes the `scan` flags `--workers`, `-x`, `--no-default-excludes` and
-  `--exclude`, with the same meaning. Both commands register and check them with
-  the same code (2026-11-11, https://git.eeqj.de/sneak/sfdupes/issues/162)
-
 - 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
@@ -3,7 +3,6 @@ module sneak.berlin/go/sfdupes
 go 1.25.7

 require (
-	github.com/rivo/uniseg v0.4.7
 	github.com/schollz/progressbar/v3 v3.19.1
 	github.com/spf13/cobra v1.10.2
 	golang.org/x/sys v0.46.0
@@ -19,6 +18,7 @@ require (
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.9 // indirect
 	modernc.org/libc v1.74.1 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
@@ -358,9 +358,8 @@ func TestRunScanInterrupted(t *testing.T) {
 	stderr := captureStderr(t)
 	dir := buildSmokeTree(t)

-	opts := scanOptions{workers: walkCancelWorkers}
-
-	err := runScan(t.Context(), []string{dir}, opts)
+	err := runScan(t.Context(), []string{dir}, walkCancelWorkers, false,
+		false, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -383,7 +382,8 @@ func TestRunScanInterrupted(t *testing.T) {
 	go func() {
 		defer close(done)

-		err = runScan(cancelledContext(t), []string{dir}, opts)
+		err = runScan(cancelledContext(t), []string{dir}, walkCancelWorkers,
+			false, false, nil)
 	}()

 	awaitReturn(t, done, "runScan")
@@ -410,7 +410,8 @@ func TestRunScanInterrupted(t *testing.T) {
 			got, before)
 	}

-	err = runScan(t.Context(), []string{dir}, opts)
+	err = runScan(t.Context(), []string{dir}, walkCancelWorkers, false,
+		false, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -436,7 +437,7 @@ func TestRunScanInterruptedMidHash(t *testing.T) {
 	dir := buildWalkCancelTree(t)

 	err := runScan(newWalkClock(hashCancelAtDone), []string{dir},
-		scanOptions{workers: walkCancelWorkers})
+		walkCancelWorkers, false, false, nil)
 	if !errors.Is(err, errInterrupted) {
 		t.Fatalf("runScan interrupted mid-hash = %v, want %v",
 			err, errInterrupted)
@@ -88,10 +88,10 @@ value, separated by a tab:
  size of recorded files  their total size, in bytes, then rounded
 `

-	dwimHelp = `dwim runs what "sfdupes scan /" runs with the same flags, 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.
+	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.
 `
 )

@@ -100,11 +100,12 @@ file. The scan is stored in the database, as scan stores it, so
 // cobra prints for it is the whole message.
 var errNoSubcommand = errors.New("no subcommand")

-// errWorkersBelowOne is the usage error for a --workers value below 1.
+// errWorkersBelowOne is the usage error for a scan --workers value
+// below 1.
 var errWorkersBelowOne = errors.New("--workers must be at least 1")

-// errEmptyExcludeValue is the usage error for an empty --exclude value,
-// as from --exclude "$DIR" with DIR unset. Taken as a path, it
+// errEmptyExcludeValue is the usage error for an empty scan --exclude
+// value, as from --exclude "$DIR" with DIR unset. Taken as a path, it
 // would name the working directory.
 var errEmptyExcludeValue = errors.New("--exclude must not be empty")

@@ -255,116 +256,83 @@ func newRootCommand(stdout, stderr io.Writer) *cobra.Command {
 		}),
 	}

+	dwimCmd := &cobra.Command{
+		Use:   cmdDwim,
+		Short: "Scan / with the default excludes, then print the duplicate-tree report",
+		Args:  cobra.NoArgs,
+		RunE: runE(func(ctx context.Context, _ []string) error {
+			return runDwim(ctx, "/", stdout)
+		}),
+	}
+
 	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,
-		newDwimCommand(stdout))
+	root.AddCommand(newScanCommand(), reportCmd, treesCmd, infoCmd, dwimCmd)

 	return root
 }

-// scanOptions holds the values of the flags that scan and dwim share:
-// --workers, -x, --no-default-excludes and --exclude.
-type scanOptions struct {
-	workers           int
-	oneFS             bool
-	noDefaultExcludes bool
-	excludePaths      []string
-}
-
-// scanFlagsUsage names the flags that scan and dwim share, for their
-// usage lines.
-const scanFlagsUsage = "[--workers N] [-x] [--no-default-excludes] " +
-	"[--exclude PATH]..."
-
-// addScanFlags adds the flags that scan and dwim share to cmd, which
-// stores their values in opts.
-func addScanFlags(cmd *cobra.Command, opts *scanOptions) {
-	cmd.Flags().IntVar(&opts.workers, "workers", runtime.NumCPU(),
-		"concurrent workers for the walk and hash phases")
-	cmd.Flags().BoolVarP(&opts.oneFS, "one-file-system", "x", false,
-		"do not cross filesystem boundaries")
-	cmd.Flags().BoolVar(&opts.noDefaultExcludes, "no-default-excludes",
-		false, "enter the default excludes, the paths listed above")
-	// A string array, not a slice, so a comma in a path is not a
-	// separator.
-	cmd.Flags().StringArrayVar(&opts.excludePaths, "exclude", nil,
-		"never enter or record `PATH` or anything below it; repeatable")
-}
-
-// check rejects the flag values that are usage errors, before the
-// command runs. It is the PreRunE of scan and dwim.
-func (o *scanOptions) check(cmd *cobra.Command, _ []string) error {
-	err := checkScanWorkers(cmd, o.workers)
-	if err != nil {
-		return err
-	}
-
-	return rejectEmptyExcludeValue(cmd, o.excludePaths)
-}
-
-// newScanCommand builds the scan subcommand. Its help names the
+// newScanCommand builds the scan subcommand, with its --workers, -x,
+// --no-default-excludes and --exclude flags. Its help names the
 // database, and lists the default excludes of the system it runs on and
 // the filesystem types it never records anything on.
 func newScanCommand() *cobra.Command {
-	var opts scanOptions
+	var (
+		scanWorkers           int
+		scanOneFS             bool
+		scanNoDefaultExcludes bool
+		scanExclude           []string
+	)

 	short := "Walk trees and synchronize the scan database"

 	scanCmd := &cobra.Command{
-		Use: cmdScan + " " + scanFlagsUsage + " PATH...",
+		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" +
 			defaultExcludesHelp(runtime.GOOS),
-		Args:    cobra.MinimumNArgs(1),
-		PreRunE: opts.check,
+		Args: cobra.MinimumNArgs(1),
+		PreRunE: func(cmd *cobra.Command, _ []string) error {
+			err := checkScanWorkers(cmd, scanWorkers)
+			if err != nil {
+				return err
+			}
+
+			return rejectEmptyExcludeValue(cmd, scanExclude)
+		},
 		RunE: runE(func(ctx context.Context, args []string) error {
 			ctx, stop := interruptContext(ctx)
 			defer stop()

-			return runScan(ctx, args, opts)
+			return runScan(ctx, args, scanWorkers, scanOneFS,
+				scanNoDefaultExcludes, scanExclude)
 		}),
 	}
-	addScanFlags(scanCmd, &opts)
+	scanCmd.Flags().IntVar(&scanWorkers, "workers", runtime.NumCPU(),
+		"concurrent workers for the walk and hash phases")
+	scanCmd.Flags().BoolVarP(&scanOneFS, "one-file-system", "x", false,
+		"do not cross filesystem boundaries")
+	scanCmd.Flags().BoolVar(&scanNoDefaultExcludes, "no-default-excludes",
+		false, "enter the default excludes, the paths listed above")
+	// A string array, not a slice, so a comma in a path is not a
+	// separator.
+	scanCmd.Flags().StringArrayVar(&scanExclude, "exclude", nil,
+		"never enter or record `PATH` or anything below it; repeatable")

 	return scanCmd
 }

-// newDwimCommand builds the dwim subcommand, which takes the scan flags
-// with the meaning they have for scan. Its help says what dwim runs,
-// then lists the default excludes and the filesystem types the scan
-// never records anything on.
-func newDwimCommand(stdout io.Writer) *cobra.Command {
-	var opts scanOptions
-
-	short := "Scan /, then print the duplicate-tree report"
-
-	dwimCmd := &cobra.Command{
-		Use:                   cmdDwim + " " + scanFlagsUsage,
-		DisableFlagsInUseLine: true,
-		Short:                 short,
-		Long: short + ".\n\n" + dwimHelp + "\n" +
-			defaultExcludesHelp(runtime.GOOS),
-		Args:    cobra.NoArgs,
-		PreRunE: opts.check,
-		RunE: runE(func(ctx context.Context, _ []string) error {
-			return runDwim(ctx, "/", opts, stdout)
-		}),
-	}
-	addScanFlags(dwimCmd, &opts)
-
-	return dwimCmd
-}
-
-// checkScanWorkers rejects a --workers value below 1. That is a usage
-// error reported in one line: cobra prints the returned message without
-// the usage text, and run exits 2.
+// checkScanWorkers rejects a scan --workers value below 1. That is a
+// usage error reported in one line: cobra prints the returned message
+// without the usage text, and run exits 2.
 func checkScanWorkers(cmd *cobra.Command, workers int) error {
 	if workers >= 1 {
 		return nil
@@ -375,7 +343,7 @@ func checkScanWorkers(cmd *cobra.Command, workers int) error {
 	return fmt.Errorf("%w, got %d", errWorkersBelowOne, workers)
 }

-// rejectEmptyExcludeValue rejects an empty --exclude value. That
+// 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 {
 	if !slices.Contains(excludePaths, "") {
@@ -25,9 +25,6 @@ const usageMarker = "Usage:"
 // helpFlag asks for the help text.
 const helpFlag = "--help"

-// workersFlag is the scan and dwim flag that sets the worker count.
-const workersFlag = "--workers"
-
 // 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
@@ -576,8 +573,8 @@ func TestRunNamesDefaultDatabase(t *testing.T) {
 	}{
 		cmdScan: {
 			run: func() error {
-				return runScan(t.Context(), []string{missing},
-					scanOptions{workers: 1})
+				return runScan(t.Context(), []string{missing}, 1, false, false,
+					nil)
 			},
 			want: scanWant,
 		},
@@ -668,7 +665,7 @@ func TestRunScanRejectsWorkersBelowOne(t *testing.T) {

 			var stdout, stderr bytes.Buffer

-			args := []string{cmdScan, workersFlag, workers, t.TempDir()}
+			args := []string{cmdScan, "--workers", workers, t.TempDir()}

 			code := run(args, &stdout, &stderr)
 			if code != exitUsage {
@@ -5,20 +5,20 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"runtime"
 )

 // runDwim implements the dwim subcommand: it runs what "sfdupes scan
-// root" runs with the scan flags in opts, then what "sfdupes trees"
-// runs, and ends with a line on stderr saying how to print the report
-// again. The dwim command passes "/" as root. It catches SIGINT and
-// SIGTERM as scan does, but only during the scan. An error from the
-// scan, an interrupt included, ends it before the report. During the
-// report, a signal ends it at once, as it ends trees.
-func runDwim(
-	ctx context.Context, root string, opts scanOptions, stdout io.Writer,
-) error {
+// root" runs with no flags, then what "sfdupes trees" runs, and ends
+// with a line on stderr saying how to print the report again. The dwim
+// command passes "/" as root. It catches SIGINT and SIGTERM as scan
+// does, but only during the scan. An error from the scan, an interrupt
+// included, ends it before the report. During the report, a signal
+// ends it at once, as it ends trees.
+func runDwim(ctx context.Context, root string, stdout io.Writer) error {
 	scanCtx, stop := interruptContext(ctx)
-	err := runScan(scanCtx, []string{root}, opts)
+	err := runScan(scanCtx, []string{root}, runtime.NumCPU(), false, false,
+		nil)

 	stop()

@@ -2,10 +2,7 @@ package sfdupes //nolint:testpackage // calls the unexported runDwim

 import (
 	"bytes"
-	"errors"
-	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"testing"
 )
@@ -31,7 +28,7 @@ func TestRunDwimPrintsLargestTreesFirst(t *testing.T) {

 	stderr := captureStderr(t)

-	err := runDwim(t.Context(), root, scanOptions{workers: 1}, &stdout)
+	err := runDwim(t.Context(), root, &stdout)
 	if err != nil {
 		t.Fatalf("runDwim: %v; stderr: %s", err, stderr())
 	}
@@ -70,7 +67,7 @@ func TestRunDwimScanErrorPrintsNoReport(t *testing.T) {

 	stderr := captureStderr(t)

-	err := runDwim(t.Context(), missing, scanOptions{workers: 1}, &stdout)
+	err := runDwim(t.Context(), missing, &stdout)
 	if err == nil {
 		t.Fatal("runDwim on a missing root: error = nil, want it fatal")
 	}
@@ -84,127 +81,3 @@ func TestRunDwimScanErrorPrintsNoReport(t *testing.T) {
 		t.Errorf("stderr = %q, want nothing from trees or dwim", got)
 	}
 }
-
-func TestRunDwimExcludeLeavesTreeOut(t *testing.T) {
-	// dwim passes its --exclude paths to the scan: an excluded copy is
-	// not recorded, so its pair is not reported.
-	t.Setenv(databaseEnv, testDBPath(t))
-
-	root := realTempDir(t)
-
-	kept := []string{
-		filepath.Dir(writeFile(t, root, "a1/f.bin", pattern(1, 300))),
-		filepath.Dir(writeFile(t, root, "a2/f.bin", pattern(1, 300))),
-	}
-	writeFile(t, root, "b1/f.bin", pattern(2, 5000))
-	excluded := filepath.Dir(writeFile(t, root, "b2/f.bin", pattern(2, 5000)))
-
-	var stdout bytes.Buffer
-
-	stderr := captureStderr(t)
-
-	opts := scanOptions{workers: 1, excludePaths: []string{excluded}}
-
-	err := runDwim(t.Context(), root, opts, &stdout)
-	if err != nil {
-		t.Fatalf("runDwim: %v; stderr: %s", err, stderr())
-	}
-
-	lines := strings.Split(strings.TrimSuffix(stdout.String(), "\n"), "\n")
-	if len(lines) != 2 {
-		t.Fatalf("stdout = %q, want a header and one group",
-			stdout.String())
-	}
-
-	want := kept[0] + "\t" + kept[1] + "\t1\t300\t"
-	if !strings.HasPrefix(lines[1], want) {
-		t.Errorf("group = %q, want it to start %q", lines[1], want)
-	}
-
-	skipped := "scan: skipped " + excluded + " (--exclude)\n"
-	if got := stderr(); !strings.Contains(got, skipped) {
-		t.Errorf("stderr = %q, want it to contain %q", got, skipped)
-	}
-}
-
-func TestRunDwimTakesScanFlags(t *testing.T) {
-	// The dwim command parses and checks the scan flags as scan does.
-	// Each case stops before the walk of / begins, and before the
-	// database is created. "dwim --exclude /" excludes its own operand.
-	cases := map[string]struct {
-		args []string
-		code int
-		want string
-	}{
-		"--exclude /": {
-			[]string{cmdDwim, excludeFlag, "/"},
-			exitFatal,
-			"sfdupes: scan /: operand excluded by --exclude /\n",
-		},
-		"--exclude empty": {
-			[]string{cmdDwim, excludeFlag, ""},
-			exitUsage,
-			"Error: --exclude must not be empty\n",
-		},
-		"--workers 0": {
-			[]string{cmdDwim, workersFlag, "0", "-x", "--no-default-excludes"},
-			exitUsage,
-			"Error: --workers must be at least 1, got 0\n",
-		},
-	}
-
-	for name, tc := range cases {
-		t.Run(name, func(t *testing.T) {
-			path := testDBPath(t)
-			t.Setenv(databaseEnv, path)
-
-			stdout := captureStdout(t)
-			stderr := captureStderr(t)
-
-			code := run(tc.args, os.Stdout, os.Stderr)
-			if code != tc.code {
-				t.Errorf("run(%q) = %d, want %d", tc.args, code, tc.code)
-			}
-
-			if !strings.HasSuffix(stderr(), tc.want) || stdout() != "" {
-				t.Errorf("stdout, stderr = %q, %q, want \"\" and stderr "+
-					"ending %q", stdout(), stderr(), tc.want)
-			}
-
-			_, err := os.Lstat(path)
-			if !errors.Is(err, os.ErrNotExist) {
-				t.Errorf("lstat %s: %v, want no database", path, err)
-			}
-		})
-	}
-}
-
-func TestRunDwimHelpListsScanFlags(t *testing.T) {
-	t.Parallel()
-
-	// README "Subcommands" shows this usage line for dwim.
-	const want = "\n  sfdupes dwim [--workers N] [-x] [--no-default-excludes] " +
-		"[--exclude PATH]...\n"
-
-	var stdout, stderr bytes.Buffer
-
-	run([]string{cmdDwim, "-h"}, &stdout, &stderr)
-
-	if !strings.Contains(stderr.String(), want) {
-		t.Errorf("dwim -h stderr = %q, want the usage line %q",
-			stderr.String(), want)
-	}
-
-	if !strings.Contains(stderr.String(), excludeFlag+" PATH") {
-		t.Errorf("dwim -h stderr = %q, want %s PATH", stderr.String(),
-			excludeFlag)
-	}
-
-	// README "Settings": the help lists the default excludes and the
-	// filesystem types the walk never records anything on.
-	help := strings.TrimSpace(defaultExcludesHelp(runtime.GOOS))
-	if !strings.Contains(stderr.String(), help) {
-		t.Errorf("dwim -h stderr = %q, want it to hold %q", stderr.String(),
-			help)
-	}
-}
@@ -254,7 +254,7 @@ func readMountInfo(mountinfo io.Reader) (map[uint64]string, error) {
 	return devices, lines.Err()
 }

-// defaultExcludesHelp describes, for the scan and dwim help, the
+// defaultExcludesHelp describes, for the scan command's help, the
 // default excludes of the system goos names and, where the scan lists
 // the mounted filesystems, the types it never records anything on.
 func defaultExcludesHelp(goos string) string {
@@ -9,10 +9,8 @@ import (
 	"strings"
 	"sync"
 	"time"
-	"unicode"
 	"unicode/utf8"

-	"github.com/rivo/uniseg"
 	"github.com/schollz/progressbar/v3"
 	"golang.org/x/term"
 )
@@ -118,8 +116,7 @@ type drawnCount struct {
 // terminal's width. A phase with an exact total ends the line with its
 // percent and bar, at the terminal's right edge, when the terminal has
 // room for them. It is drawn again every redrawInterval, so its elapsed
-// time keeps moving while the phase waits for its next item. Each draw
-// of the walk shows the path it reached last on the line below. When
+// time keeps moving while the phase waits for its next item. When
 // stderr is not a TTY it emits no ANSI redraws: it prints line as the
 // phase starts, every plainInterval while it runs, and as it ends.
 //
@@ -144,7 +141,6 @@ type progress struct {
 	estimate   bool
 	waitingFor string
 	stalledOn  string
-	path       string // the path the walk reached last; "" for none
 	count      int64
 	start      time.Time // when the phase started, for the elapsed time
 	rateStart  time.Time // when the count started, for the time remaining
@@ -243,82 +239,6 @@ func (p *progress) draw() {
 	// less the terminal's last column, which spinnerMargin keeps clear. A
 	// bar's cells take one column each but more than one byte.
 	p.widest = max(p.widest, utf8.RuneCountInString(text)+spinnerMargin-1)
-
-	if p.path != "" {
-		// The library draws the path on the line below and returns to
-		// the phase's line. The path is escaped as warnings are, and its
-		// other control characters are written out, so that the terminal
-		// shows them instead of acting on them. It stays clear of the
-		// last column, so that no terminal wraps it.
-		shown := escapeControlChars(escapePath(p.path))
-		_ = p.bar.AddDetail(cutToColumns(shown, width-1))
-	}
-}
-
-// escapeControlChars returns s with each control character written as
-// \x and its code in two hex digits, as \x1b for the escape character.
-// The control characters are U+0000 to U+001F, U+007F and U+0080 to
-// U+009F, as unicode.IsControl reports them. A byte from 0x80 to 0x9F
-// that is not part of a valid UTF-8 character is written the same way,
-// as \x9b, since a terminal not in UTF-8 mode acts on it. Every other
-// byte is kept as it is.
-func escapeControlChars(s string) string {
-	var b strings.Builder
-
-	for rest := s; rest != ""; {
-		char, size := utf8.DecodeRuneInString(rest)
-		if char == utf8.RuneError && size == 1 {
-			// Not part of a valid UTF-8 character. A terminal not in
-			// UTF-8 mode reads the byte as the character with its code,
-			// so that 0x9b is a control character there and 0xe9 is not.
-			char = rune(rest[0])
-		}
-
-		if unicode.IsControl(char) {
-			fmt.Fprintf(&b, `\x%02x`, char)
-		} else {
-			b.WriteString(rest[:size])
-		}
-
-		rest = rest[size:]
-	}
-
-	return b.String()
-}
-
-// cutToColumns returns s cut to at most columns terminal columns, at a
-// character boundary. A wide character, as in Chinese, takes two
-// columns.
-func cutToColumns(s string, columns int) string {
-	used, end, state := 0, 0, -1
-
-	for rest := s; rest != ""; {
-		char, next, width, nextState := uniseg.FirstGraphemeClusterInString(
-			rest, state)
-		if used+width > columns {
-			break
-		}
-
-		used += width
-		end += len(char)
-		rest, state = next, nextState
-	}
-
-	return s[:end]
-}
-
-// clear erases the display from the terminal: its line, and the path on
-// the line below when one is shown. p.mu must be held.
-func (p *progress) clear() {
-	if p.bar == nil {
-		return
-	}
-
-	if p.path != "" {
-		_ = p.bar.AddDetail("")
-	}
-
-	_ = p.bar.Clear()
 }

 // newBar has the library make what draw draws: its spinner, followed by
@@ -343,8 +263,6 @@ func (p *progress) newBar(width int) {
 		// The text carries the elapsed time and the time remaining.
 		progressbar.OptionSetElapsedTime(false),
 		progressbar.OptionSetPredictTime(false),
-		// The line below the phase's line, for the walk's path.
-		progressbar.OptionSetMaxDetailRow(1),
 	)
 	p.widest = 0
 }
@@ -396,19 +314,6 @@ func (p *progress) increment() {
 	p.lastItem = now
 }

-// setPath records the path the walk reached last, which a display on a
-// terminal shows at its next draw.
-func (p *progress) setPath(path string) {
-	if p == nil {
-		return
-	}
-
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	p.path = path
-}
-
 // warnf prints a one-line warning to stderr without corrupting the
 // display. The whole message is escaped like a report's path columns,
 // so a path holding a newline cannot split the warning.
@@ -422,9 +327,11 @@ func (p *progress) warnf(format string, args ...any) {
 	p.mu.Lock()
 	defer p.mu.Unlock()

-	// The warning takes the display's line; the next draw shows the
-	// display again, on the line below.
-	p.clear()
+	if p.bar != nil {
+		// The warning takes the display's line; the next draw shows
+		// the display again, on the line below.
+		_ = p.bar.Clear()
+	}

 	fmt.Fprintln(os.Stderr, msg)
 }
@@ -485,7 +392,9 @@ func (w *progressWriter) Flush() error {
 		w.p.mu.Lock()
 		defer w.p.mu.Unlock()

-		w.p.clear()
+		if w.p.bar != nil {
+			_ = w.p.bar.Clear()
+		}
 	}

 	_, err := w.out.Write(w.buf)
@@ -505,13 +414,6 @@ func (p *progress) finish() {
 	close(p.stop)
 	<-p.done

-	// The walk's path is only for someone watching the walk. Its line is
-	// erased, and the next phase is drawn on it.
-	p.mu.Lock()
-	p.clear()
-	p.path = ""
-	p.mu.Unlock()
-
 	p.draw()

 	if p.width != nil {
@@ -6,7 +6,6 @@ import (
 	"math"
 	"os"
 	"path/filepath"
-	"regexp"
 	"slices"
 	"strings"
 	"sync"
@@ -1139,164 +1138,3 @@ func TestWarningAfterLastItemKeepsBar(t *testing.T) {
 		t.Errorf("terminal shows %q, want a count of 2 of 2", shown)
 	}
 }
-
-func TestCutToColumns(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		s       string
-		columns int
-		want    string
-	}{
-		{"/srv/a", 10, "/srv/a"},
-		{"/srv/photos", 8, "/srv/pho"},
-		// Each of these two fullwidth letters takes two columns.
-		{"/ＡＢ/a", 4, "/Ａ"},
-		{"/ＡＢ/a", 5, "/ＡＢ"},
-		// An accent that combines with the letter before stays with it.
-		{"/café/a", 5, "/café"},
-		{"/srv", 0, ""},
-	}
-
-	for _, tc := range cases {
-		if got := cutToColumns(tc.s, tc.columns); got != tc.want {
-			t.Errorf("cutToColumns(%q, %d) = %q, want %q",
-				tc.s, tc.columns, got, tc.want)
-		}
-	}
-}
-
-func TestEscapeControlChars(t *testing.T) {
-	t.Parallel()
-
-	cases := map[string]string{
-		"/srv/music":    "/srv/music",
-		"/a\x1b[2Jb":    `/a\x1b[2Jb`,
-		"/a\x00\a\x7fb": `/a\x00\x07\x7fb`,
-		// U+009B takes two bytes in UTF-8.
-		"/a\u009b2Jb": `/a\x9b2Jb`,
-		// Byte 0x9b alone is not valid UTF-8. A terminal not in UTF-8
-		// mode acts on it, as on every byte from 0x80 to 0x9f.
-		"/a\x9b2Jb":       `/a\x9b2Jb`,
-		"/a\x80\x9f\xa0b": `/a\x80\x9f` + "\xa0b",
-		// In ě, which is c4 9b in UTF-8, byte 0x9b is part of a valid
-		// character.
-		"/aě2Jb":          "/aě2Jb",
-		"/café/ＡＢ":        "/café/ＡＢ",
-		"/latin1-caf\xe9": "/latin1-caf\xe9",
-	}
-	for in, want := range cases {
-		if got := escapeControlChars(in); got != want {
-			t.Errorf("escapeControlChars(%q) = %q, want %q", in, got, want)
-		}
-	}
-}
-
-// pathLines returns the text of each line the library wrote below a
-// display's line. It writes one as an erase to the end of the line, a
-// carriage return, the text and a newline.
-func pathLines(out string) []string {
-	matches := regexp.MustCompile("\x1b\\[K\r([^\n]*)\n").
-		FindAllStringSubmatch(out, -1)
-	lines := make([]string, 0, len(matches))
-
-	for _, m := range matches {
-		lines = append(lines, m[1])
-	}
-
-	return lines
-}
-
-// TestTerminalWalkShowsPathBelow checks that the walk's display on a
-// terminal 30 columns wide shows the path it reached last on the line
-// below, cut to 29 columns. That line is erased before a warning is
-// printed, and again when the walk ends, so the next phase is drawn on
-// an empty line.
-//
-//nolint:paralleltest // captureStderr replaces the process-wide os.Stderr
-func TestTerminalWalkShowsPathBelow(t *testing.T) {
-	stderr := captureStderr(t)
-	p := startProgress(progressParams{
-		label: scanPhase("walk"), unit: scanUnit, total: -1,
-	}, func() int { return 30 }, testRedraw, time.Now)
-
-	const shown = "/srv/photos/2026/holiday/beac"
-
-	p.setPath("/srv/photos/2026/holiday/beach.jpg")
-	p.increment()
-	awaitOutput(t, stderr, shown, 1)
-
-	p.warnf("warning")
-
-	before, _, _ := strings.Cut(stderr(), "warning")
-	if lines := pathLines(before); lines[len(lines)-1] != "" {
-		t.Errorf("line below shows %q as the warning is printed, want it "+
-			"empty", lines[len(lines)-1])
-	}
-
-	// Drawn again below the warning.
-	awaitOutput(t, stderr, shown, strings.Count(before, shown)+1)
-	p.finish()
-
-	lines := pathLines(stderr())
-	if !slices.Contains(lines, shown) {
-		t.Errorf("lines below the display = %q, want %q among them",
-			lines, shown)
-	}
-
-	if last := lines[len(lines)-1]; last != "" {
-		t.Errorf("line below the display shows %q after the walk, want it "+
-			"empty", last)
-	}
-}
-
-// TestTerminalWalkEscapesControlChars checks that a walked path holding
-// escape characters, which would clear the screen and set the window
-// title, puts none on the line below the walk's display. The line shows
-// each control character written out, as \x1b.
-//
-//nolint:paralleltest // captureStderr replaces the process-wide os.Stderr
-func TestTerminalWalkEscapesControlChars(t *testing.T) {
-	stderr := captureStderr(t)
-	p := startProgress(progressParams{
-		label: scanPhase("walk"), unit: scanUnit, total: -1,
-	}, func() int { return 80 }, testRedraw, time.Now)
-
-	p.setPath("/srv/\x1b[2J\x1b]0;title\a/beach.jpg")
-	p.increment()
-	awaitOutput(t, stderr, "beach.jpg", 1)
-	p.finish()
-
-	lines := pathLines(stderr())
-	for _, line := range lines {
-		if strings.Contains(line, "\x1b") {
-			t.Errorf("line below the display = %q, want no escape "+
-				"character", line)
-		}
-	}
-
-	const shown = `/srv/\x1b[2J\x1b]0;title\x07/beach.jpg`
-	if !slices.Contains(lines, shown) {
-		t.Errorf("lines below the display = %q, want %q among them",
-			lines, shown)
-	}
-}
-
-// TestPlainWalkShowsNoPath checks that the walk's display prints no path
-// when stderr is not a terminal.
-//
-//nolint:paralleltest // captureStderr replaces the process-wide os.Stderr
-func TestPlainWalkShowsNoPath(t *testing.T) {
-	stderr := captureStderr(t)
-	p := startProgress(progressParams{
-		label: scanPhase("walk"), unit: scanUnit, total: -1,
-	}, nil, testRedraw, time.Now)
-
-	p.setPath("/srv/a")
-	p.increment()
-	p.finish()
-
-	if strings.Contains(stderr(), "/srv/a") {
-		t.Errorf("stderr = %q, want no path", stderr())
-	}
-}
@@ -98,16 +98,17 @@ func scanPhase(name string) string {
 // runs, and the lock is released after it. When ctx is cancelled, as by
 // the SIGINT or SIGTERM that interruptContext catches, the scan keeps
 // what it has hashed (see syncScan), prints how many files its walk
-// reached, and returns errInterrupted. opts.workers must be at least 1;
-// the scan and dwim commands reject anything less. Before the lock is
-// taken, the scan lists the filesystems that are not persistent, on
-// which the walk records nothing; unless opts.noDefaultExcludes is set,
-// the walk does not enter the default excludes either. The walk neither
-// enters nor records the paths in opts.excludePaths, the --exclude
-// values; an operand at or below one is a fatal error. Once the
-// database is open, the scan notes its files, which the walk passes
-// over.
-func runScan(ctx context.Context, roots []string, opts scanOptions) error {
+// reached, and returns errInterrupted. workers must be at least 1; the
+// scan command rejects anything less. Before the lock is taken, the
+// 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
+// at or below one is a fatal error. Once the database is open, the scan
+// notes its files, which the walk passes over.
+func runScan(ctx context.Context, roots []string, workers int,
+	oneFS, noDefaultExcludes bool, excludePaths []string,
+) error {
 	dbPath, source, err := databasePath()
 	if err != nil {
 		return err
@@ -122,7 +123,7 @@ func runScan(ctx context.Context, roots []string, opts scanOptions) error {

 	var rules walkRules

-	rules.excludePaths, err = excludePathInodes(opts.excludePaths)
+	rules.excludePaths, err = excludePathInodes(excludePaths)
 	if err != nil {
 		return fmt.Errorf("--exclude: %w", err)
 	}
@@ -137,7 +138,7 @@ func runScan(ctx context.Context, roots []string, opts scanOptions) error {
 		return fmt.Errorf("list the mounted filesystems: %w", err)
 	}

-	if !opts.noDefaultExcludes {
+	if !noDefaultExcludes {
 		rules.defaultExcludes = defaultExcludes(runtime.GOOS)
 	}

@@ -166,7 +167,7 @@ func runScan(ctx context.Context, roots []string, opts scanOptions) error {
 		return err
 	}

-	st, err := syncScan(ctx, db, roots, opts.workers, opts.oneFS, rules)
+	st, err := syncScan(ctx, db, roots, workers, oneFS, rules)
 	if errors.Is(err, context.Canceled) {
 		return interrupted(st.walked)
 	}
@@ -562,7 +563,6 @@ func (s *scanState) walkPhase(events <-chan walkEvent, roots []string) {

 		s.st.walked++

-		prog.setPath(ev.rec.path)
 		prog.increment()

 		old, ok := s.existing[ev.rec.path]
@@ -2196,7 +2196,7 @@ func TestScanHashWriteFailureUnwindsPool(t *testing.T) {
 	var stderr bytes.Buffer

 	code := run([]string{
-		cmdScan, workersFlag, strconv.Itoa(hashLeakWorkers), dir,
+		cmdScan, "--workers", strconv.Itoa(hashLeakWorkers), dir,
 	}, io.Discard, &stderr)
 	if code != exitFatal {
 		t.Fatalf("run(scan) = %d, want %d; stderr: %s",