Re-vendor the canonical files from sneak/prompts at c55a0cb (closes #95)

Every vendored file, REPO_POLICIES.md and every model script is the
copy at sneak/prompts c55a0cb, with this repository's own entries kept
after the canonical content. Lint and test are phases of the Dockerfile
that write no image, built uncached. make test runs the suite under the
race detector as nobody, because root reads the files the tests make
unreadable. Dockerfile.lint, script/verify-lint-image-pin and
make test-race are gone. Prettier runs on the host, from the node and
yarn that script/bootstrap installs. golangci-lint v2.14.0 raises no
findings. .claude/settings.json is deleted.

Deviation: the set comes from c55a0cb on next rather than dd4027b, as
the instructions on sneak/prompts#78 allow.

Model: opus-5-5

.claude/settings.json

@@ -1,5 +0,0 @@
-{
-    "worktree": {
-        "bgIsolation": "none"
-    }
-}

.dockerignore

@@ -1,12 +1,79 @@
+# .dockerignore does NOT use .gitignore semantics. Docker matches with
+# moby/patternmatcher: filepath.Match plus `**`, so `*` does not cross
+# `/` and an unprefixed pattern is anchored at the context root. Every
+# depth-independent pattern therefore needs `**/`, or `config/.env` and
+# `certs/server.key` still ship while this file reads as solved. Only
+# genuinely root-anchored entries go unprefixed. Never transplant these
+# into .gitignore, where `**/` is wrong.
+#
+# Matching is case-sensitive, so secrets use character ranges rather
+# than an ALL-CAPS twin, which would still miss `Server.Key`.
+#
+# Extend with this repo's own host-built artifacts, written anchored:
+# `/myapp`, never `**/myapp`, which also matches `cmd/myapp/` and
+# deletes the package directory from the context.
+
 # .git is sent without its config. Without a VERSION build argument the
 # stage that compiles runs `git describe --tags --always` on .git, which
 # does not need .git/config; that file can hold a credential, such as a
 # password in a remote URL or the token the CI checkout step stores there.
-.git/config
+# Each submodule keeps a config with the same exposure in its git directory
+# under .git/modules/, nested again for a submodule's own submodules, or in
+# its own .git directory when it keeps one.
+# KNOWN GAP: a submodule whose name has a `config` segment (`config`,
+# `deploy/config`, `config/lib`) loses its whole git directory, because
+# `**/.git/modules/**/config` also matches that segment's directory
+# under .git/modules/. Go's version stamping then fails the build;
+# nothing leaks. Name such a submodule without that segment:
+# `git submodule add --name`.
+**/.git/config
+**/.git/modules/**/config
 
+# Agent scratch: one full checkout of the repo per in-flight agent.
+# Anchored because it occurs once where agents run at the repo root.
+# KNOWN GAP: a repo running agents in subdirectories still ships
+# `services/api/.claude/` and must add its own anchored entry.
 .claude
-.DS_Store
+
-sfdupes
+# Environment files. `*.env` covers bare `.env` and the `prod.env`
-*.log
+# convention. Re-include a committed template with a negation if the
-*.out
+# build needs one: `!docs/example.env`.
-*.test
+**/*.[eE][nN][vV]
+**/.[eE][nN][vV].*
+**/.[eE][nN][vV][rR][cC]
+
+# Private keys and the bundles carrying them. Public certificates
+# (*.crt, *.cer) are deliberately absent: they are legitimate inputs.
+**/*.[pP][eE][mM]
+**/*.[kK][eE][yY]
+**/*.[pP]12
+**/*.[pP][fF][xX]
+**/[iI][dD]_[rR][sS][aA]
+**/[iI][dD]_[dD][sS][aA]
+**/[iI][dD]_[eE][cC][dD][sS][aA]
+**/[iI][dD]_[eE][cC][dD][sS][aA]_[sS][kK]
+**/[iI][dD]_[eE][dD]25519
+**/[iI][dD]_[eE][dD]25519_[sS][kK]
+
+# Dependencies: restored inside the image, never copied in.
+**/node_modules
+
+# OS metadata.
+**/.DS_Store
+**/Thumbs.db
+
+# Editor state: never a build input, and it churns COPY.
+**/*.swp
+**/*.swo
+**/*~
+**/*.bak
+**/.idea
+**/.vscode
+**/*.sublime-*
+
+# This repository's host-built artifacts: the binary `make build` writes,
+# and test binaries, coverage output and logs.
+/sfdupes
+/*.test
+/*.out
+/*.log

.editorconfig

@@ -13,3 +13,6 @@ indent_style = tab
 
 [*.go]
 indent_style = tab
+
+# This repository's own sections, such as one for another language it
+# uses, go below this comment, and a re-vendor keeps them.

.gitea/workflows/check.yml

@@ -1,11 +1,20 @@
 name: check
 on: [push]
+# Free the shared runner: a new push cancels only the same branch's older run.
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
 jobs:
     check:
         runs-on: ubuntu-latest
+        # Free the shared runner from a hung build.
+        timeout-minutes: 20
         steps:
             # actions/checkout v4.2.2, 2026-02-22
             - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+              # script/cibuild needs no token, so none is left in .git/config.
               with:
+                  persist-credentials: false
+                  # All history and tags, so git describe finds the version tag.
                   fetch-depth: 0
             - run: script/cibuild

.gitignore

@@ -11,25 +11,50 @@ Thumbs.db
 .vscode/
 *.sublime-*
 
+# Agent scratch (worktrees of this repo, created and destroyed by
+# in-flight tooling). Unanchored: .gitignore patterns already match at
+# every depth, so no prefix is wanted here. This is not a .dockerignore
+# entry and must not be given a `**/` prefix on the way into one.
+.claude/
+
 # Node
 node_modules/
 
-# Environment / secrets
+# Secrets. Unanchored like every entry above, so each matches at every
-.env
+# depth. Matching is case-sensitive on Linux, so names use character
-.env.*
+# ranges rather than a lowercase form that misses `Server.Key`.
-*.pem
-*.key
 
-# Go build artifacts
+# Environment files. `*.env` covers bare `.env` and the `prod.env`
+# convention. Only the templates `example.env` and `sample.env` are
+# re-included below. A repository that commits any other template adds
+# its own negation at the end of this file, for example `!.env.example`.
+*.[eE][nN][vV]
+.[eE][nN][vV].*
+.[eE][nN][vV][rR][cC]
+!example.env
+!sample.env
+
+# Private keys and the bundles carrying them.
+*.[pP][eE][mM]
+*.[kK][eE][yY]
+*.[pP]12
+*.[pP][fF][xX]
+[iI][dD]_[rR][sS][aA]
+[iI][dD]_[dD][sS][aA]
+[iI][dD]_[eE][cC][dD][sS][aA]
+[iI][dD]_[eE][cC][dD][sS][aA]_[sS][kK]
+[iI][dD]_[eE][dD]25519
+[iI][dD]_[eE][dD]25519_[sS][kK]
+
+# This repository's own entries, such as its build outputs, go below
+# this comment, and a re-vendor keeps them. Anchor a binary built at the
+# root: `/myapp`, never `myapp`, which also ignores `cmd/myapp/`.
 /sfdupes
-*.test
-*.out
 *.log
+*.out
+*.test
 
-# Local scan data
+# A scan database lists every path it scanned.
 *.sqlite
 *.sqlite-shm
 *.sqlite-wal
-
-# Agent worktrees
-.claude/worktrees/

.golangci.yml

@@ -17,6 +17,7 @@ linters:
   disable:
     # Genuinely incompatible with project patterns
     - exhaustruct      # Requires all struct fields
+    - exhaustruct_v5   # Requires all struct fields (successor to exhaustruct)
     - godot            # Requires comments to end with periods
     - wrapcheck        # Too verbose for internal packages
     - varnamelen       # Short names like db, id are idiomatic Go
@@ -24,6 +25,8 @@ linters:
     # silenced by disabling that name, not by enabling the successor.
     - wsl              # Deprecated, replaced by wsl_v5
     - gomodguard       # Deprecated, replaced by gomodguard_v2
+    # Misses findings at random in v2.14.0; back once a pinned release fixes it
+    - canonicalheader
   settings:
     lll:
       line-length: 88

Dockerfile

@@ -1,184 +1,64 @@
-# Lint stage — fast feedback on formatting and lint issues
+# Lint phase, built alone by script/lint. The tools are invoked directly
-# golangci/golangci-lint:v2.12.2, 2026-08-07
+# rather than through `make lint`, which runs docker itself and so cannot
-FROM golangci/golangci-lint@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS lint
+# run inside a build step.
+# golangci/golangci-lint:v2.14.0, 2026-10-07
+FROM golangci/golangci-lint@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f AS lint
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download
 COPY . .
 
-# Cache-buster for the gate layers, and only for them. Docker
+# The gofmt half of `make fmt-check`. gofmt's output is assigned to a
-# invalidates COPY only when the copied content changes, so on an
+# variable first so that its own exit status, as when it cannot parse a
-# unchanged tree the gates below would be served from cache and the
+# file, still fails the step.
-# build would exit 0 having run nothing. script/cibuild and
+RUN files="$(gofmt -s -l .)" && \
-# script/docker pass a fresh CHECK_EPOCH on every invocation. A build
-# that passes none, such as a bare `docker build .`, fails at the check
-# right after the ARG instead of quietly serving the gates from cache.
-#
-# Two properties this depends on. ARG is per-stage, so the markdown and
-# build stages below declare it again; one declaration here would leave
-# their gates cacheable. And each gate RUN must reference the value,
-# because BuildKit hashes the expanded command: a declared but
-# unreferenced ARG invalidates nothing.
-#
-# It sits below the dependency layers deliberately. Everything above it
-# (the pinned base image, go mod download) keeps its cache; only the
-# gates go cold.
-ARG CHECK_EPOCH
-RUN if [ -z "${CHECK_EPOCH}" ]; then \
-        echo "CHECK_EPOCH is unset; build via script/cibuild or script/docker" >&2; \
-        exit 1; \
-    fi
-
-# The linter is invoked directly here, not through `make lint`. That
-# target now runs `docker build -f Dockerfile.lint`, and a docker build
-# cannot run a docker build: routing the gate through make would mean
-# nesting docker inside this image. Same reason `make check` is gone
-# from the build stage below, and `make fmt-check` from both stages: it
-# runs prettier through docker too. Its gofmt half is the step below,
-# its Markdown half the markdown stage further down. gofmt's output is
-# assigned to a variable first so that its own exit status, as when it
-# cannot parse a file, still fails the step.
-RUN echo "gate gofmt, epoch ${CHECK_EPOCH}" && \
-    files="$(gofmt -s -l .)" && \
     if [ -n "$files" ]; then \
         echo "gofmt: files not formatted:" >&2; echo "$files" >&2; exit 1; \
     fi
 
-# The FROM above and the one in Dockerfile.lint pin the same linter
+# Validates .golangci.yml against the schema the pinned binary embeds.
-# twice, and nothing else keeps them in sync; this fails the build when
+RUN golangci-lint config verify --config .golangci.yml
-# they disagree. See the script for why it restates neither pin.
+RUN golangci-lint run --config .golangci.yml ./...
-RUN echo "gate lint-image-pin, epoch ${CHECK_EPOCH}" && \
-    script/verify-lint-image-pin
 
-# Same config-schema check Dockerfile.lint runs, kept here so this build
+# Test phase, built alone by script/test. -race needs cgo and so a C
-# gates on exactly what script/lint gates on. It validates against a
+# compiler, which the Debian Go image ships and the alpine one does not.
-# schema the pinned binary embeds, so it needs no network.
+#
-RUN echo "gate config verify, epoch ${CHECK_EPOCH}" && \
+# The tests run as nobody: several of them make a file unreadable and
-    golangci-lint config verify --config .golangci.yml
+# expect reading it to fail, and root reads it anyway. nobody has no home
-
+# directory, so HOME is /tmp, where Go puts its build cache.
-RUN echo "gate lint, epoch ${CHECK_EPOCH}" && \
+# golang:1.25-trixie, 2026-10-04
-    golangci-lint run --config .golangci.yml ./...
+FROM golang@sha256:2c4c60ef415fbfa5e90300722293bef36c5e63fae17570ce18f580af933dbd73 AS test
-
+USER nobody
-# Prettier stage: the prettier that formats this repository's Markdown,
+ENV HOME=/tmp
-# never installed on a host. script/fmt and script/fmt-check build this
-# stage alone and run it with the repository mounted on /src. prettier
-# is installed in /tools so that the repository, mounted or copied onto
-# /src, cannot hide it.
-# node:22-alpine, 2026-02-22
-FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS prettier
-WORKDIR /tools
-# yarn.lock pins prettier by hash, and --frozen-lockfile fails rather
-# than install anything yarn.lock does not name.
-COPY package.json yarn.lock ./
-RUN yarn install --frozen-lockfile
-ENV PATH=/tools/node_modules/.bin:$PATH
 WORKDIR /src
-
+COPY go.mod go.sum ./
-# Markdown stage: the Markdown half of `make fmt-check`, as a gate.
+RUN go mod download
-FROM prettier AS markdown
 COPY . .
-# Second per-stage declaration of the gate cache-buster and its check;
+RUN go test -timeout 90s -race -cover ./... || \
-# see the lint stage above.
+    { echo "--- Rerunning with -v for details ---"; \
-ARG CHECK_EPOCH
+      go test -timeout 90s -race -v ./...; exit 1; }
-RUN if [ -z "${CHECK_EPOCH}" ]; then \
-        echo "CHECK_EPOCH is unset; build via script/cibuild or script/docker" >&2; \
-        exit 1; \
-    fi
-RUN echo "gate prettier, epoch ${CHECK_EPOCH}" && \
-    prettier --check '**/*.md' --tab-width 4 --prose-wrap always
 
-# Build stage
+# Build stage. Nothing is wanted from either phase above; the copies are
+# what make BuildKit build them first, so this stage cannot run unless
+# lint and test passed.
 # golang:1.25-alpine, 2026-07-23
 FROM golang@sha256:56961d79ea8129efddcc0b8643fd8a5416b4e6228cfd477e3fd61deb2672c587 AS builder
-
-# We never build or run as root. Create an unprivileged user and point
-# HOME and the build cache at its home so go build and go test can write
-# it when we drop to it below. $GOPATH/bin is deliberately not on PATH:
-# script/bootstrap no longer `go install`s anything (the linter runs
-# from a pinned image, never from a host install), so nothing lands
-# there and adding it would only widen what this image resolves.
-#
-# The module cache is kept outside that home, at the base image's
-# default /go/pkg/mod, and belongs to root: script/bootstrap fills it as
-# root. Do not move it into the home and hand it over with `chown -R`:
-# that walks every file in it, which took from about 80 s to over ten
-# minutes on a shared host, depending on load.
-RUN adduser -D -u 1000 builder
-ENV HOME=/home/builder
-ENV GOPATH=/home/builder/go
-ENV GOMODCACHE=/go/pkg/mod
-ENV GOCACHE=/home/builder/.cache/go-build
-
-WORKDIR /src
-
-# No-op file copies whose only purpose is the build-graph edge: they are
-# what make this stage depend on the lint and markdown stages, and so
-# what forces BuildKit to finish gofmt, the pin guard, lint and prettier
-# before compilation and tests start. Remove one and the fail-fast
-# design dies silently — the build stops gating on that stage and still
-# exits 0. The first replaces a copy of the linter binary itself, which
-# is no longer wanted here: nothing in this stage runs the linter,
-# because `make lint` is now a docker build and a docker build cannot
-# run inside one.
 COPY --from=lint /src/go.sum /dev/null
-COPY --from=markdown /src/go.sum /dev/null
+COPY --from=test /src/go.sum /dev/null
-
+RUN apk add --no-cache git make
-# Install development prerequisites the same way a developer does,
+# A tar-stream context keeps the sender's file owners, which git refuses.
-# rather than duplicating the installs inline. Only script/ and the
+RUN git config --system --add safe.directory /src
-# dependency manifests are copied first, nothing else, so this layer
+WORKDIR /src
-# stays cached until the scripts or the dependencies change — bootstrap
-# ends in `go mod download`, which is why there is no separate
-# invocation of it here.
-COPY script/ script/
 COPY go.mod go.sum ./
-RUN script/bootstrap
+RUN go mod download
-
+COPY . .
-# Hand builder only what it writes to, without walking the module cache.
-# This layer stays cached with bootstrap.
-# - /src itself: make build writes the binary into it, and git refuses
-#   a repository whose top directory belongs to another user.
-# - the module cache's cache/download directory itself, not what is in
-#   it: Go only reads the downloaded modules, but make build saves its
-#   lookup of this module's own version from git there, in a new
-#   directory named after the module path.
-# - builder's home: the go commands bootstrap ran as root left Go's
-#   telemetry files there, a few small files.
-RUN chown builder:builder /src /go/pkg/mod/cache/download && \
-    chown -R builder:builder /home/builder
-
-# The sources are handed to builder as they are copied, so no layer has
-# to walk them. Then drop root before running any checks or builds.
-COPY --chown=builder:builder . .
-USER builder
-
-# Fail the build unless the branch is green. Runs as non-root so the
-# permission-denied test paths are exercised legitimately (root would
-# bypass the chmod(0) the tests rely on).
-#
-# The gate is `make test`, not `make check`: that aggregate runs
-# `script/lint` and `script/fmt-check`, which both run docker, and
-# nothing inside an image build may shell out to docker. Lint and the
-# format checks are not skipped by this — they ran in the lint and
-# markdown stages above, which this stage's COPY --from lines make
-# prerequisites. `make`, not the script directly, because the Makefile's
-# `export CGO_ENABLED = 0` applies only to what it invokes.
-#
-# Third per-stage declaration of the gate cache-buster and its check;
-# see the lint stage above for why one is not enough. It is placed after
-# USER so the drop to the unprivileged user still happens before the
-# checks run.
-ARG CHECK_EPOCH
-RUN if [ -z "${CHECK_EPOCH}" ]; then \
-        echo "CHECK_EPOCH is unset; build via script/cibuild or script/docker" >&2; \
-        exit 1; \
-    fi
-RUN echo "gate test, epoch ${CHECK_EPOCH}" && make test
 
 # The version stamped into the binary: the VERSION build argument when
 # one is given, otherwise `git describe --tags --always` of the .git in
-# the build context (git is installed by script/bootstrap above). A
+# the build context. A context that carries .git and still yields no
-# context that carries .git and still yields no version fails the build;
+# version fails the build; with neither, as from a source tarball, it is
-# with neither, as from a source tarball, it is "dev".
+# "dev". `make build` rather than `go build`, so the image and a host
+# build share one compile recipe, cgo disabled included.
 ARG VERSION
 RUN version="${VERSION:-$(git describe --tags --always || echo dev)}"; \
     if [ -e .git ] && { [ -z "$version" ] || [ "$version" = dev ] || \
@@ -188,7 +68,8 @@ RUN version="${VERSION:-$(git describe --tags --always || echo dev)}"; \
     fi; \
     make build VERSION="$version"
 
-# Runtime stage
+# Runtime stage, and the last one: a plain `docker build .` builds this
+# stage's chain and nothing else.
 # alpine:3.22, 2026-07-23
 FROM alpine@sha256:14358309a308569c32bdc37e2e0e9694be33a9d99e68afb0f5ff33cc1f695dce
 

Dockerfile.lint

@@ -1,59 +0,0 @@
-# Lint-only image: this is how the linter runs, everywhere. The repo is
-# COPYed into the pinned golangci-lint image and the linter runs as a
-# build step, so a successful build IS a clean lint. golangci-lint is
-# never installed on a host — one toolchain, pinned by digest, identical
-# on a laptop and in CI — and this works even when the docker daemon is
-# remote and bind mounts are impossible.
-#
-# script/lint builds this file. It is a separate image from the lint
-# stage of the main Dockerfile because script/lint must not depend on
-# the rest of that build; the two FROM lines are kept identical by
-# script/verify-lint-image-pin, run as a gate below.
-# golangci/golangci-lint:v2.12.2, 2026-08-07
-FROM golangci/golangci-lint@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240
-
-WORKDIR /src
-
-# Dependency layers first, so they stay cached across lint runs.
-COPY go.mod go.sum ./
-RUN go mod download
-
-COPY . .
-
-# Cache-buster for the gate layers, and only for them. Caching of the
-# lint run is waived by ruling: COPY is invalidated only by changed
-# content, so on an unchanged tree the gates below would be served from
-# cache and this build would exit 0 in under a second having run no
-# linter at all. That exact false green has bitten this repo twice
-# already (#32, #39). script/lint passes a fresh value on every
-# invocation.
-#
-# Each gate RUN must reference the value, because BuildKit hashes the
-# expanded command and not the ARG declaration: a declared but
-# unreferenced ARG invalidates nothing. The ARG sits below the
-# dependency layers deliberately — everything above it keeps its cache,
-# only the gates go cold.
-ARG CHECK_EPOCH
-
-# The linter version is pinned in two places, here and in the main
-# Dockerfile's lint stage. Nothing else keeps them in sync, so a
-# half-applied bump is a build failure; see the script.
-RUN echo "gate lint-image-pin, epoch ${CHECK_EPOCH}" && \
-    script/verify-lint-image-pin
-
-# Validates .golangci.yml against golangci-lint's JSON schema. The
-# concern about this step was that it fetches that schema over a live,
-# unpinned HTTPS call; measured on the pinned image, it does not. The
-# binary carries the schema for its own version, so under
-# `--network none` this both passes on a valid config and still rejects
-# an invalid one with the jsonschema error. That holds for the gate
-# steps generally — none of them makes a network call — but not for
-# this build as a whole: `go mod download` above needs the network on a
-# cold cache, and under `--network none` a first build fails there
-# before reaching any gate. That layer stays cached, so only a warm
-# cache lints offline, until go.mod or go.sum changes.
-RUN echo "gate config verify, epoch ${CHECK_EPOCH}" && \
-    golangci-lint config verify --config .golangci.yml
-
-RUN echo "gate lint, epoch ${CHECK_EPOCH}" && \
-    golangci-lint run --config .golangci.yml ./...

Makefile

@@ -6,7 +6,7 @@ BINARY := sfdupes
 VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo dev)
 LDFLAGS := -X main.Version=$(VERSION)
 
-.PHONY: sfdupes build bootstrap setup test test-race lint fmt fmt-check check docker hooks clean
+.PHONY: sfdupes build bootstrap setup test lint fmt fmt-check check docker hooks clean
 
 # Standard targets are thin shims; the implementations live in script/
 # per the scripts-to-rule-them-all pattern.
@@ -27,9 +27,6 @@ setup:
 test:
 	@script/test
 
-test-race:
-	@script/test-race
-
 lint:
 	@script/lint
 

README.md

@@ -312,29 +312,34 @@ All three subcommands operate on a single SQLite database file:
 
     ```sql
     CREATE TABLE files (
-        path    BLOB PRIMARY KEY,  -- absolute path, raw bytes
+        path       BLOB PRIMARY KEY,  -- absolute path, raw bytes
-        size    INTEGER NOT NULL,  -- bytes, from lstat
+        size       INTEGER NOT NULL,  -- bytes, from lstat
-        mtime   INTEGER NOT NULL,  -- Unix seconds, from lstat
+        mtime      INTEGER NOT NULL,  -- whole Unix seconds of the mtime, from lstat
-        head    TEXT NOT NULL,     -- lowercase-hex SHA-256; first 64 KiB, or whole file under 10 MiB
+        mtime_nsec INTEGER NOT NULL,  -- nanoseconds within that second, 0 to 999999999
-        tail    TEXT NOT NULL,     -- lowercase-hex SHA-256; last 64 KiB, or whole file under 10 MiB
+        head       TEXT NOT NULL,     -- lowercase-hex SHA-256; first 64 KiB, or whole file under 10 MiB
-        content TEXT NOT NULL      -- lowercase-hex SHA-256, whole file or samples
+        tail       TEXT NOT NULL,     -- lowercase-hex SHA-256; last 64 KiB, or whole file under 10 MiB
+        content    TEXT NOT NULL      -- lowercase-hex SHA-256, whole file or samples
     ) WITHOUT ROWID;
     CREATE INDEX files_signature ON files (size, head, tail, content);
     ```
 
     Paths are stored as BLOBs because Unix paths are raw bytes, not guaranteed
-    UTF-8. `mtime` is used only for change detection; it is not part of the
+    UTF-8. `mtime` and `mtime_nsec` hold the file's mtime to the nanosecond:
-    duplicate key. For a file under 10 MiB `head`, `tail`, and `content` all
+    `mtime` the whole Unix seconds, rounded down, and `mtime_nsec` the
-    hold the whole-file hash (that range is hashed in full, with no end
+    nanoseconds past that second. Split this way they hold any mtime a
-    windows); for a larger file `head` and `tail` hold the first- and last-64
+    filesystem can record, one before 1678 or after 2262 included, which a
-    KiB hashes and `content` the whole-file or sampled hash. All three are empty
+    single 64-bit count of nanoseconds cannot. They are used only for change
-    strings when the file has never been hashed because its size was unique as
+    detection and are not part of the duplicate key. For a file under 10 MiB
-    of the last scan that covered it. For a file of 10 MiB or more, `content`
+    `head`, `tail`, and `content` all hold the whole-file hash (that range is
-    stays empty until the content phase of a scan (see "`scan` mode" below) has
+    hashed in full, with no end windows); for a larger file `head` and `tail`
-    read the file. A record with an empty `content` is never part of a duplicate
+    hold the first- and last-64 KiB hashes and `content` the whole-file or
-    group, though it still defines the file for tree reconstruction. The
+    sampled hash. All three are empty strings when the file has never been
-    `files_signature` index lets SQLite group the records by signature for
+    hashed because its size was unique as of the last scan that covered it. For
-    `report` without sorting the whole table.
+    a file of 10 MiB or more, `content` stays empty until the content phase of a
+    scan (see "`scan` mode" below) has read the file. A record with an empty
+    `content` is never part of a duplicate group, though it still defines the
+    file for tree reconstruction. The `files_signature` index lets SQLite group
+    the records by signature for `report` without sorting the whole table.
 
 ### Duplicate detection
 
@@ -421,6 +426,9 @@ operands:
   once its size, `head`, and `tail` match another record's.
 - A file whose mtime is newer than recorded, or whose size differs, is processed
   as if new: re-hashed, or recorded without hashes, per the shared-size rule.
+  Change detection compares the mtime to the nanosecond, as finely as the
+  filesystem records it, so a same-size rewrite counts as a change whenever the
+  filesystem gives it a later mtime than recorded, even within the same second.
 - A database record whose path lies under one of the scanned operands but was
   not successfully processed this run is deleted. This removes records for
   deleted files. It also removes records for paths that failed to stat or hash
@@ -738,104 +746,62 @@ entrypoints are:
 - `script/bootstrap` — install everything needed to build and develop this
   repository, idempotently, assuming nothing is present. `git`, `make`, and `go`
   come from the first of nix, apt, brew, or apk found on the host, and are
-  presence-checked only. `golangci-lint` and prettier are deliberately **not**
+  presence-checked only. An installed node is used as it is; otherwise node
-  installed: they run in Docker (see `script/lint` and `script/fmt`) and never
+  22.17.0 is installed through nvm, which comes from a release archive whose
-  from a host install, so there is no host copy to drift from the pin. A missing
+  sha256 the script checks. A yarn already on `PATH` is used as it is; otherwise
-  `docker` is warned about rather than installed or treated as fatal —
+  yarn 1.22.22 is activated through corepack, or installed with `npm` when there
-  everything except linting, formatting and `make test-race` works without it.
+  is no corepack. `yarn install --frozen-lockfile` then installs the prettier
-  Ends with `go mod download`.
+  that `package.json` and `yarn.lock` pin. `golangci-lint` is never installed:
+  it runs in Docker (see `script/lint`). `docker` is not installed either;
+  testing, linting and the image build need it. Ends with `go mod download`.
 - `script/setup` — make a fresh clone ready for development: runs
   `script/bootstrap`, then `script/install-precommit`.
 - `script/projectname` — print this project's name (`sfdupes`). Scripts that
   need the name call it, so they stay identical across repositories.
-- `script/test` — run the test suite with a 30-second timeout and coverage
+- `script/test` — run the test suite under the race detector, with a 90-second
-  enabled, rerunning verbosely on failure so the logs show which test failed.
+  timeout and coverage enabled, rerunning verbosely on failure so the logs show
-- `script/test-race` — run the test suite under the race detector with a
+  which test failed. It builds the `Dockerfile`'s `test` phase alone and writes
-  60-second timeout. The detector needs cgo and a C compiler, which the build
+  no image. The race detector needs cgo and a C compiler, which the build never
-  never uses, so the tests run in a digest-pinned Debian `golang` image that has
+  uses, so the phase starts from a digest-pinned Debian `golang` image, which
-  `gcc`, with the checkout mounted read-only; the container is removed when it
+  has `gcc`. The tests run as `nobody`, because several of them make a file
-  exits. They run as the calling user, or as `nobody` when that is root, because
+  unreadable and root reads it anyway.
-  several tests make a file unreadable and root reads it anyway; only then must
+- `script/lint` — run the linter. It builds the `Dockerfile`'s `lint` phase
-  the checkout be readable by other users. Not part of `script/check`. Every run
+  alone and writes no image: in the digest-pinned `golangci/golangci-lint`
-  starts with empty caches, so it needs the network and takes minutes, and the
+  image, the gofmt check, `golangci-lint config verify` and `golangci-lint run`
-  mount needs a local docker daemon.
+  run as build steps, so a successful build is a clean lint. The linter is never
-- `script/lint` — run the linter. It builds `Dockerfile.lint`, which copies the
+  run on the host, which makes a working `docker` the one prerequisite for
-  repository into the digest-pinned `golangci/golangci-lint` image and runs
+  linting.
-  `golangci-lint config verify` and `golangci-lint run` as build steps, so a
-  successful build is a clean lint. That exit status is all it produces, so it
-  runs with `--output=type=cacheonly` and writes no image; a run leaves only
-  build cache. The linter is never run on the host, which makes a working
-  `docker` the one prerequisite for linting — and therefore for `make check` and
-  the pre-commit hook. Offline machines: the gate steps themselves make no
-  network calls. `golangci-lint run` does not, and neither does
-  `golangci-lint config verify` — it validates against a schema the pinned
-  binary embeds, measured under `--network none` to both pass a valid config and
-  reject an invalid one. The build around them does. `Dockerfile.lint` runs
-  `go mod download` before the gates and this module has external dependencies,
-  so a first lint on a machine with a cold BuildKit cache reaches the network
-  there (as well as pulling the pinned image); under `--network none` it fails
-  at that step, before any gate. That layer sits above the gates and stays
-  cached, so once it is warm `script/lint` — and with it `make check` — runs
-  entirely offline, until `go.mod` or `go.sum` changes and the download layer
-  goes cold again. Because the daemon only ever sees a build context, this works
-  when the docker daemon is remote and bind mounts are impossible.
 - `script/fmt` — format in place: the Go sources with `gofmt -s -w`, and every
   Markdown file with prettier, at the settings in `.prettierrc` (4-space
-  indents, prose wrapped at 80 columns). prettier is pinned by hash through
+  indents, prose wrapped at 80 columns). Both run on the host, prettier through
-  `package.json` and `yarn.lock` and never installed on the host: this builds
+  yarn at the version `yarn.lock` pins. When yarn is not on `PATH`, this loads
-  the `Dockerfile`'s `prettier` stage, a digest-pinned node image into which
+  the node 22.17.0 that `script/bootstrap` installed through nvm.
-  `yarn install --frozen-lockfile` installs it, tagged `sfdupes-prettier`, and
+- `script/fmt-check` — the read-only counterpart of `script/fmt`: prints any
-  runs that with the repository mounted, as the calling user. Needs `docker`,
+  unformatted file and exits non-zero instead of writing. gofmt and prettier
-  and because of the mount, unlike `script/lint`, a local docker daemon.
+  both run every time, and each names itself when it fails. The `Dockerfile`'s
-- `script/fmt-check` — the read-only counterpart of `script/fmt`, with the
+  `lint` phase runs the same gofmt check.
-  repository mounted read-only: prints any unformatted file and exits non-zero
-  instead of writing. gofmt and prettier both run every time, and each names
-  itself when it fails. The `Dockerfile` runs the same two checks as gates: the
-  gofmt check in its lint stage, prettier in its `markdown` stage.
 - `script/check` — run `script/test`, `script/lint`, and `script/fmt-check`, in
-  that order. Modifies nothing. Needs `docker`, because `script/lint` and
+  that order. Modifies nothing. The first two need `docker`, the third what
-  `script/fmt-check` do.
+  `script/bootstrap` installs.
 - `script/docker` — build the Docker image, tagged with the name from
-  `script/projectname`. The `Dockerfile` runs the gates as build steps, so this
+  `script/projectname`, passing the output of
-  is also the check a developer or reviewer runs by hand.
+  `git describe --tags --always --dirty` (or `unknown` when that is empty) as
-- `script/cibuild` — build the Docker image untagged. This is what the Gitea
+  the `VERSION` build argument. The `Dockerfile`'s build stage depends on its
-  workflow runs on push; because the gates run as build steps, a successful
+  `lint` and `test` phases, so this also runs the tests and the linter.
-  build implies the repository is green.
+- `script/cibuild` — run `script/bootstrap`, then `script/check`, then build the
+  image as `script/docker` does. This is what the Gitea workflow runs on push; a
+  successful run means every check passed. The tests and the linter run twice:
+  once in `script/check`, and again as stages of the image build.
 - `script/precommit` — run by the git pre-commit hook: `go mod tidy` must be a
   no-op (a resulting change to `go.mod` or `go.sum` fails the commit), then
   `script/check`.
-- `script/install-precommit` — install the git pre-commit hook that runs
+- `script/install-precommit` — install the git pre-commit hook, as
-  `script/precommit`. The hook is written to the common git directory, so the
+  `.git/hooks/pre-commit`, that runs `script/precommit`.
-  main checkout and every worktree share it.
-- `script/verify-lint-image-pin` — fail unless the `golangci/golangci-lint`
-  reference in `Dockerfile.lint` and the one in the `Dockerfile` lint stage are
-  the same image at the same digest, naming both if not. The linter is pinned in
-  those two files and nothing else keeps them in sync, so a bump applied to one
-  alone would leave `make lint` and the `Dockerfile`'s fail-fast lint stage
-  checking the same tree against different rulesets, both green. The guard
-  restates neither pin — a third copy would be the same drift one file further
-  out — and runs as a gate in both files, so `make lint`, `make check` and
-  `make docker` all catch it.
 
-`script/verify-linter-pin` used to live here. It compared a linter binary
+Every `docker build` in `script/` passes `--no-cache`. On an unchanged tree
-against a version pin in `script/bootstrap`, and both of its subjects are gone:
+Docker would serve the gate steps from its cache, and the build would pass
-no linter binary is copied between build stages any more, and bootstrap pins no
+having run no test and no linter. Every run therefore downloads the Go modules
-version because it installs no linter. The drift it existed to catch has moved
+again and needs the network.
-from binary-versus-pin to pin-versus-pin, which is what
-`script/verify-lint-image-pin` above checks.
-
-`script/lint`, `script/docker` and `script/cibuild` all pass a freshly computed
-`CHECK_EPOCH` build argument, and the gate steps in `Dockerfile.lint` and
-`Dockerfile` reference it. Without that, an unchanged tree lets Docker serve the
-gate layers from cache and the build exits 0 having executed no tests and no
-lint — a green it never earned, and one this repository has produced twice.
-`CHECK_EPOCH` invalidates the gate layers on every run while leaving the pinned
-base images and the dependency layers cached. Each script's value carries the
-process id as well as the epoch, because two runs land inside the same second
-easily and a bare epoch would cache the second one. Each `Dockerfile` stage with
-gates fails when the value is empty, so a bare `docker build .` stops with
-`CHECK_EPOCH is unset; build via script/cibuild or script/docker` instead of
-serving the gates from cache.
 
 ## Build
 
@@ -847,17 +813,15 @@ compile recipe:
   the default target.
 - `make bootstrap` — install the build and development dependencies.
 - `make setup` — prepare a fresh clone: `bootstrap` plus the pre-commit hook.
-- `make test` — run the test suite (30-second timeout; reruns with `-v` on
+- `make test` — run the test suite under the race detector, in Docker (90-second
-  failure).
+  timeout; reruns with `-v` on failure; see `script/test`); requires `docker`.
-- `make test-race` — run the test suite under the race detector, in Docker (see
+- `make lint` — run `golangci-lint` with the repo config and the gofmt check, in
-  `script/test-race`); requires `docker`. Not part of `make check`.
+  Docker (see `script/lint`); requires `docker`.
-- `make lint` — run `golangci-lint` with the repo config, in Docker (see
-  `script/lint`); requires `docker`.
 - `make fmt` / `make fmt-check` — format the Go sources and the Markdown /
-  verify formatting without writing; requires `docker`, for prettier (see
+  verify formatting without writing, on the host; requires `go` and what
-  `script/fmt`).
+  `make bootstrap` installs (see `script/fmt`).
 - `make check` — `test`, `lint`, and `fmt-check`; modifies nothing. Requires
-  `docker`, via `lint` and `fmt-check`.
+  `docker` and what `make bootstrap` installs.
 - `make docker` — build the Docker image, which runs the gates as build stages.
 - `make hooks` — install the pre-commit hook.
 - `make clean` — remove the binary.

REPO_POLICIES.md

@@ -1,6 +1,6 @@
 ---
 title: Repository Policies
-last_modified: 2026-07-06
+last_modified: 2026-10-07
 ---
 
 This document covers repository structure, tooling, and workflow standards. Code
@@ -60,17 +60,28 @@ style conventions are in separate documents:
   prerequisite since nvm requires bash. yarn is then pinned via
   `corepack prepare yarn@<version> --activate`. Never install "latest" or "lts";
   always exact versions. `script/cibuild` runs the CI build: it changes to the
-  repo root and runs `docker build .`; the Gitea workflow calls it. Four further
+  repo root, runs `script/bootstrap`, runs `script/check`, and builds the image
-  scripts are our own extensions to the standard: `script/check` runs
+  with the version; the Gitea workflow calls it. **`script/cibuild` runs
-  `script/test`, `script/lint`, and `script/fmt-check`; `script/precommit` is
+  `script/bootstrap` first**, because the workflow checks out the repo and runs
-  what the git pre-commit hook runs, and it calls `script/check`;
+  nothing else, while `script/fmt-check` runs the formatter on the host: on a
-  `script/install-precommit` installs the git pre-commit hook (the `make hooks`
+  pristine checkout with nothing installed the run dies there, after the
-  target shims to it); and `script/projectname` (literally that filename) simply
+  containerised gates have passed. **The bootstrap alone is not enough**:
-  outputs the project's name. Scripts that need the name call
+  `script/bootstrap` installs node and yarn under nvm and leaves neither on the
-  `script/projectname` — e.g. `script/docker` assembles its image tag from it —
+  `PATH` of the shell that called it, so a bare `yarn` still exits 127. The host
-  so those scripts stay byte-identical across all repos. Repo-type-specific
+  entrypoints that need yarn — `script/fmt` and `script/fmt-check` — therefore
-  pre-commit extras (e.g. `go mod tidy` verification in Go repos) belong in
+  source nvm for the pinned node version before invoking it, exactly as
-  `script/precommit`, not in the hook itself. Model scripts are at
+  `script/bootstrap`'s own install step does. A runner carrying nothing but
+  docker and git then gets through `script/check`. Four further scripts are our
+  own extensions to the standard: `script/check` runs `script/test`,
+  `script/lint` and `script/fmt-check`; `script/precommit` is what the git
+  pre-commit hook runs, and it calls `script/check`; `script/install-precommit`
+  installs the git pre-commit hook (the `make hooks` target shims to it); and
+  `script/projectname` (literally that filename) simply outputs the project's
+  name. Scripts that need the name call `script/projectname` — e.g.
+  `script/docker` assembles its image tag from it — so those scripts stay
+  byte-identical across all repos. Repo-type-specific pre-commit extras (e.g.
+  `go mod tidy` verification in Go repos) belong in `script/precommit`, not in
+  the hook itself. Model scripts are at
   `https://git.eeqj.de/sneak/prompts/raw/branch/main/script/<name>`. The README
   must document the provided scripts in an **Entrypoints** section (see the
   README requirements below).
@@ -89,87 +100,222 @@ style conventions are in separate documents:
   contributor should be able to understand the entire development workflow by
   reading the Makefile.
 
-- Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
+- Every repo should have a `Dockerfile`, and it carries the repo's gates: a
-  as a build step so the build fails if the branch is not green. For non-server
+  `lint` phase and a `test` phase, with the final stage depending on both so the
-  repos, the Dockerfile should bring up a development environment and run
+  image cannot be built unless they pass. For non-server repos the final stage
-  `make check`. For server repos, `make check` should run as an early build
+  brings up a development environment; for server repos it is the runtime image.
-  stage before the final image is assembled. Dockerfiles install development
+  The gate phases and the build stage start from their pinned base images and
-  prerequisites by running `script/bootstrap` rather than duplicating installs
+  install what those images lack either inline, as the canonical Go `Dockerfile`
-  inline; COPY `script/` and the dependency manifests (`package.json` +
+  below does for `git`, or by running `script/bootstrap`, as the `prompts`
-  `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it so the bootstrap
+  repo's own `Dockerfile` does for its yarn packages. The development
-  layer stays cached until dependencies change.
+  environment stage installs development prerequisites by running
+  `script/bootstrap` rather than duplicating its installs inline. A stage that
+  runs `script/bootstrap` COPYs `script/` and the dependency manifests
+  (`package.json` + `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it.
 
-- **Dockerfiles must use a separate lint stage for fail-fast feedback.** Go
+- **Linting and testing run in Docker, as phases of the `Dockerfile`.** There is
-  repos use a multistage build where linting runs in an independent stage based
+  no separate lint file. `script/lint` and `script/test` each build one phase
-  on the `golangci/golangci-lint` image (pinned by hash). This stage runs
+  and nothing else:
-  `make fmt-check` and `make lint` before the full build begins. The build stage
-  then declares an explicit dependency on the lint stage via
-  `COPY --from=lint /src/go.sum /dev/null`, which forces BuildKit to complete
-  linting before proceeding to compilation and tests. This ensures lint failures
-  surface in seconds rather than minutes, without blocking on dependency
-  download or compilation in the build stage.
 
-    The standard pattern for a Go repo Dockerfile is:
+    ```sh
+    docker build --no-cache --target lint --output type=cacheonly .
+    docker build --no-cache --target test --output type=cacheonly .
+    ```
+
+    **A stage that is not the last one in the file is built only when the final
+    stage's chain depends on it, or when `--target` names it.** That is why the
+    two gates are always invoked by name here, and why the final stage carries a
+    `COPY --from=` of a harmless file from each of them: without that edge a
+    plain `docker build .` builds the last stage alone and exits 0 having linted
+    and tested nothing.
+
+    **The gate builds write no image.** With `--output type=cacheonly` the phase
+    runs and a failing step fails the build, but the result is not exported.
+    Nothing uses those images, and writing one out is slow: a Go test phase's
+    image holds the toolchain and every compiled package. A build given neither
+    `--output` nor `-t` writes an untagged image and leaves it dangling, on
+    every developer host and every CI runner. `script/cibuild` and
+    `script/docker` build the image that ships and tag it, so each build
+    replaces the previous image; each assigns the tag on its own line before the
+    build, so `set -e` stops it where `script/projectname` fails.
+
+    Inside a phase the tool is invoked directly — `golangci-lint`, `go test`,
+    `eslint`, `prettier` — never through `make lint` or `script/test`, which are
+    themselves a `docker build` and would recurse into a daemon that does not
+    exist in a build step. Formatting is the exception and stays on the host:
+    `script/fmt` writes the working tree, and `script/fmt-check` is its
+    read-only twin.
+
+    **No lint verdict may come from a host invocation of the linter.** On a
+    shared host golangci-lint reads a result cache keyed on file content rather
+    than location, so a second checkout of the same content is served the first
+    one's findings, and a host-global lock in `$TMPDIR` makes concurrent runs
+    exit non-zero with `parallel golangci-lint is running` — a status a caller
+    cannot tell from real findings. Both have produced wrong verdicts in this
+    org, in both directions. A container has its own cache, its own `TMPDIR` and
+    a digest-pinned binary, so neither is reachable.
+
+- **Any build that runs checks is built with `--no-cache`.** Docker invalidates
+  a `COPY` layer only when the copied content changes, so on an unchanged tree
+  the check `RUN` is served from cache, nothing executes, and the build still
+  exits 0. Every `docker build` in `script/` therefore passes `--no-cache`:
+  `script/lint`, `script/test`, `script/cibuild` and `script/docker` are the
+  four, and there is no fifth — `script/check` runs the two gate phases and
+  `script/fmt-check`, and builds no image of its own. A bare `docker build .` is
+  not evidence that anything ran: a sub-second build reporting success is a
+  cache hit, not a result. Never invalidate by pruning — `docker builder prune`
+  and friends destroy a build cache shared with every other build on the host.
+  When a check is added or changed, prove it works by planting a defect it must
+  catch and watching the run fail on it, then revert the defect. A green run
+  alone shows neither that the check ran nor that it covers what it should.
+
+- **The gate phases are separate stages, and the build stage depends on both.**
+  The lint phase is based on the `golangci/golangci-lint` image (pinned by
+  hash), so lint failures surface in seconds rather than after a full compile,
+  and the test phase is based on the Debian Go image. The canonical Go repo
+  `Dockerfile`:
 
     ```dockerfile
-    # Lint stage — fast feedback on formatting and lint issues
+    # Lint phase
     # golangci/golangci-lint:v2.x.x, YYYY-MM-DD
     FROM golangci/golangci-lint@sha256:... AS lint
     WORKDIR /src
     COPY go.mod go.sum ./
     RUN go mod download
     COPY . .
-    RUN make fmt-check
+    RUN golangci-lint run --config .golangci.yml ./...
-    RUN make lint
 
-    # Build stage
+    # Test phase. -race needs cgo and so a C compiler, which the Debian Go
-    # golang:1.x-alpine, YYYY-MM-DD
+    # image ships and the alpine one does not.
-    FROM golang@sha256:... AS builder
+    # golang:1.x, YYYY-MM-DD
+    FROM golang@sha256:... AS test
     WORKDIR /src
-
-    # Force BuildKit to run the lint stage before proceeding
-    COPY --from=lint /src/go.sum /dev/null
-
     COPY go.mod go.sum ./
     RUN go mod download
     COPY . .
-    RUN make test
+    RUN go test -timeout 90s -race -cover ./... || \
+        { echo "--- Rerunning with -v for details ---"; \
+          go test -timeout 90s -race -v ./...; exit 1; }
 
-    ARG VERSION=dev
+    # Build stage. Nothing is wanted from either phase above; the copies
-    RUN CGO_ENABLED=0 go build -trimpath \
+    # are what make BuildKit build them first, so this stage cannot run
-        -ldflags="-s -w -X main.Version=${VERSION}" \
+    # unless lint and test passed.
-        -o /app ./cmd/app/
+    # golang:1.x-alpine, YYYY-MM-DD
+    FROM golang@sha256:... AS builder
+    COPY --from=lint /src/go.sum /dev/null
+    COPY --from=test /src/go.sum /dev/null
+    RUN apk add --no-cache git
+    # A tar-stream context keeps the sender's file owners, which git refuses.
+    RUN git config --system --add safe.directory /src
+    WORKDIR /src
+    COPY go.mod go.sum ./
+    RUN go mod download
+    COPY . .
 
-    # Runtime stage
+    # The VERSION build arg when one is given, otherwise
+    # `git describe --tags --always` on the .git in the build context. With
+    # .git present, a version that is still empty, dev or unknown fails the
+    # build: git is missing or could not read the checkout.
+    ARG VERSION
+    RUN VERSION="${VERSION:-$(git describe --tags --always)}"; \
+        if [ -e .git ]; then \
+            case "$VERSION" in ""|dev|unknown) \
+                echo "version is '$VERSION' although .git is present" >&2; \
+                exit 1 ;; \
+            esac; \
+        fi; \
+        CGO_ENABLED=0 go build -trimpath \
+            -ldflags="-s -w -X main.Version=${VERSION}" \
+            -o /app ./cmd/app/
+
+    # Runtime stage, and the last one
     FROM alpine@sha256:...
     COPY --from=builder /app /usr/local/bin/app
     ENTRYPOINT ["app"]
     ```
 
     Key points:
-    - The lint stage uses the `golangci/golangci-lint` image directly (it
+    - The lint phase uses the `golangci/golangci-lint` image directly (it has
-      includes both Go and the linter), so there is no need to install the
+      both Go and the linter), so nothing needs installing.
-      linter separately.
+    - `COPY --from=<phase> /src/go.sum /dev/null` is a no-op copy whose only
-    - `COPY --from=lint /src/go.sum /dev/null` is a no-op file copy that creates
+      purpose is the ordering edge. BuildKit runs stages in parallel by default,
-      a stage dependency. BuildKit runs stages in parallel by default; without
+      and a stage nothing depends on is not built at all, so without these two
-      this line, the build stage would not wait for lint to finish and a lint
+      lines a red gate would not fail the build.
-      failure might not fail the overall build.
+    - Keep the runtime stage last, and if you add a stage after it, give it the
+      same two copies. A plain `docker build .` builds the last stage's chain
+      and nothing else.
     - If the project uses `//go:embed` directives that reference build artifacts
-      (e.g. a web frontend compiled in a separate stage), the lint stage must
+      (e.g. a web frontend compiled in a separate stage), the lint phase must
       create placeholder files so the embed directives resolve. Example:
       `RUN mkdir -p web/dist && touch web/dist/index.html web/dist/style.css`.
-      The lint stage should not depend on the actual build output — it exists to
+    - If the project requires CGO or system libraries for linting, install them
-      fail fast.
+      in the lint phase. The `golangci/golangci-lint` image is Debian-based and
-    - If the project requires CGO or system libraries for linting (e.g.
+      has no `apk`, so install with `apt-get` under the Debian package name
-      `vips-dev`), install them in the lint stage with `apk add`.
+      (`libvips-dev`, where alpine says `vips-dev`), and delete the package
-    - The build stage runs `make test` after compilation setup. Tests run in the
+      lists in the same `RUN`, so the layer does not keep them:
-      build stage, not the lint stage, because they may require compiled
+
-      artifacts or heavier dependencies.
+        ```dockerfile
+        RUN apt-get update \
+            && apt-get install -y --no-install-recommends libvips-dev \
+            && rm -rf /var/lib/apt/lists/*
+        ```
+
+    - `.dockerignore` lets `.git` into the build context. It keeps out every git
+      `config` at any depth (`**/.git/config`, `**/.git/modules/**/config`): the
+      repository's own, each submodule's under `.git/modules/`, and that of a
+      submodule keeping its own `.git` directory. `git describe` does not need
+      them, and each can hold a credential: a password in a remote URL, or the
+      token the CI checkout step stores there. A submodule whose name has a
+      `config` segment (`config`, `deploy/config`, `config/lib`) loses its whole
+      git directory to `**/.git/modules/**/config`, and Go's version stamping
+      then fails the build: give it a name without that segment
+      (`git submodule add --name`). The stage that compiles has `git` (the
+      Debian Go image has it; an alpine one needs `apk add --no-cache git`) and
+      takes the version from the `VERSION` build argument when one is given,
+      otherwise from `git describe --tags --always`. That gives the tag on a
+      tagged commit; on a later commit, the tag, the number of commits since it
+      and the short commit (`v1.2.3-4-gabc1234`); and the short commit when no
+      tag is reachable. The stage that compiles also marks its working directory
+      safe for git (`git config --system --add safe.directory /src`): a context
+      sent as a tar stream keeps the sender's file owners, and git refuses a
+      checkout owned by another user, so the version would come out empty.
+      `ARG VERSION` has no default, and the build fails if the context carries
+      `.git` and the version still comes out empty, `dev` or `unknown`. A plain
+      `docker build .` with no build arguments must succeed; a Dockerfile that
+      refuses an empty build argument drops that refusal and keeps the argument.
+      A checkout whose `.git` is a file (a linked worktree, or a repository
+      checked out as a submodule) is the exception: that file points to a git
+      directory outside the build context, so the build cannot read the version
+      and a plain `docker build .` fails; pass the version with
+      `--build-arg VERSION=...`, as `script/docker` and `script/cibuild` already
+      do.
 
 - Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
-  runs `script/cibuild` (which runs `docker build .`) on push. Since the
+  runs `script/cibuild` on push, and checks out the repo as its only other step,
-  Dockerfile already runs `make check`, a successful build implies all checks
+  with `persist-credentials: false`: `script/cibuild` needs no token, and
-  pass.
+  without it the checkout leaves the job's token in `.git/config` for every
+  later step. The checkout step also sets `fetch-depth: 0`, which fetches the
+  tags `git describe` needs: by default it clones shallow with no tags, and a
+  tagged repository's CI build would stamp a bare short commit id. The
+  workflow's `concurrency` block groups runs by workflow and branch
+  (`${{ github.workflow }}-${{ github.ref }}`) with `cancel-in-progress: true`,
+  so a new push cancels the older run on the same branch, queued or running, and
+  no other: runs for replaced commits do not hold up the shared runner.
+  `script/cibuild` bootstraps, runs the gate phases, and then builds the image,
+  so a successful run means every check passed; a bare `docker build .` does not
+  carry the same guarantee, because its gate phases may come from the cache. The
+  image build is uncached and so runs the gate phases a second time. That is the
+  price of the rule above, and it is worth paying: the image that ships is built
+  from a run of its own gates rather than from a cache entry. The `check` job
+  sets `timeout-minutes: 20`, so a hung build frees the shared runner after 20
+  minutes. That allows for the three Docker builds described above (the test
+  phase, the lint phase, then the image), each held to the 5-minute Docker build
+  limit below, plus the bootstrap. A separate workflow limited to `main` by a
+  `branches` list under `on: push` cannot be checked by review: to try a change
+  to it, add the feature branch to that list and push, then remove the branch
+  from the list again before merging. Keep any job in it that publishes behind
+  `if: github.ref_name == 'main'`, so the run from the feature branch publishes
+  nothing.
 
 - Use platform-standard formatters: `black` for Python, `prettier` for
   JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
@@ -189,14 +335,21 @@ style conventions are in separate documents:
   module under test to verify it compiles/parses. There is no excuse for
   `make test` to be a no-op.
 
-- `make test` must complete in under 20 seconds. Add a 30-second timeout in the
+- `make test` must complete in under 60 seconds. That is the hard cap, and a
-  Makefile.
+  suite that exceeds it fails. Under 20 seconds is the target. A suite between
+  20 and 60 seconds is still green, but the overage must be filed as an
+  improvement bug against that repo. Add a 90-second timeout to the test
+  invocation (`go test -timeout 90s`). The backstop deliberately sits above the
+  hard cap so that it catches a genuinely hung test rather than a merely slow
+  one.
 
-- **`make test` should use the conditional verbose rerun pattern.** Run tests
+- **The test command should use the conditional verbose rerun pattern.** Run
-  without `-v` (verbose) first. If tests fail, automatically rerun with `-v` to
+  tests without `-v` (verbose) first. If tests fail, automatically rerun with
-  show full output. This keeps CI logs and `docker build` output clean on
+  `-v` to show full output. This keeps CI logs and `docker build` output clean
-  success (just package/suite summaries) while providing full diagnostic detail
+  on success (just package/suite summaries) while providing full diagnostic
-  on failure (every test case, every assertion). The general shell pattern:
+  detail on failure (every test case, every assertion). The command lives in the
+  `test` phase of the `Dockerfile`, since `script/test` builds that phase; the
+  Makefile form below is the same pattern for any repo-local invocation:
 
     ```makefile
     test:
@@ -209,11 +362,26 @@ style conventions are in separate documents:
 
     ```makefile
     test:
-    	@go test -timeout 30s -race -cover ./... || \
+    	@go test -count=1 -timeout 90s -race -cover ./... || \
     		{ echo "--- Rerunning with -v for details ---"; \
-    		  go test -timeout 30s -race -v ./...; exit 1; }
+    		  go test -count=1 -timeout 90s -race -v ./...; exit 1; }
     ```
 
+    `-count=1` is required on both invocations: it defeats Go's test _result_
+    cache, so neither run can report a stored pass in place of running the
+    tests. It leaves the build cache alone, so it costs the runtime of the suite
+    and no recompilation.
+
+    That cache is Go's own, separate from Docker's layer cache. Go stores a
+    passing result in its cache directory (`GOCACHE`), and when the same tests
+    run again on unchanged code it prints that result, marked `(cached)`,
+    without running them. That matters on a developer's machine, where this
+    target runs and the directory lasts from one run to the next. The `test`
+    phase of the `Dockerfile` needs no `-count=1`: its base image holds no
+    result for this repo's tests and nothing before its `go test` step runs a
+    test, so there is nothing to replay. `--no-cache` (above) is what makes that
+    step run on an unchanged tree.
+
     Python example:
 
     ```makefile
@@ -239,10 +407,89 @@ style conventions are in separate documents:
   must be in `.gitignore`. No exceptions.
 
 - `.gitignore` should be comprehensive from the start: OS files (`.DS_Store`),
-  editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`.
+  editor files (`.swp`, `*~`), in-repo agent scratch directories (`.claude/`),
-  Fetch the standard `.gitignore` from
+  `node_modules/`, and the repo's own build outputs. Fetch the standard
+  `.gitignore` from
   `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up
-  a new repo.
+  a new repo. A repo's `.gitignore` is the standard file followed by the repo's
+  own entries, such as its binaries; a re-vendor replaces the standard part and
+  keeps those entries. These patterns are written to `.gitignore`'s own
+  semantics, in which an unanchored pattern already matches at every depth; they
+  are not a `.dockerignore` and must not be transplanted into one unmodified.
+
+- **`.dockerignore` does not use `.gitignore` semantics, and copying patterns
+  across unmodified leaves secrets in the build context.** Docker matches with
+  `moby/patternmatcher`: `filepath.Match` semantics plus a `**` extension, so
+  `*` does not cross `/` and a pattern without a leading `**/` is anchored at
+  the build-context root. A `.dockerignore` listing `.env`, `*.pem` and `*.key`
+  therefore excludes only the copies at the repository root, while `config/.env`
+  and `certs/server.key` still reach the context and can land in an image layer
+  — which is more dangerous than a short file with no secret patterns at all,
+  because it reads as solved and stops anyone looking. Give every
+  depth-independent pattern the `**/` prefix and leave only genuinely
+  root-anchored entries unprefixed: `.claude`, and the repo's own host-built
+  binary, written `/myapp` and never `**/myapp`, which would also match
+  `cmd/myapp/` and delete the package directory from the context. Matching is
+  case-sensitive, and an ALL-CAPS twin per pattern still misses `Server.Key`, so
+  secret names use character ranges — `**/*.[kK][eE][yY]`, `**/*.[pP][eE][mM]`,
+  and likewise for `.envrc` and the extensionless SSH keys. Where such a pattern
+  also catches something the build needs, re-include it with a negation
+  (`!docs/example.env`); deleting the pattern reopens the exposure for every
+  other file it covers. Fetch the standard `.dockerignore` from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` and extend
+  it with the repo's own artifacts.
+
+- **In-repo agent scratch belongs in both files, written to each file's own
+  semantics.** `.claude/` holds one worktree per in-flight agent — an entire
+  additional checkout of the repo — so under `COPY . .` the build context
+  inflates by a multiple of the repo and another session's unreviewed work can
+  be copied into an image layer. In `.gitignore` the entry is `.claude/`,
+  unanchored. In `.dockerignore` it is `.claude`, anchored and with **no** `**/`
+  prefix, because the prefixed form would also delete any nested directory of
+  that name from the build. Anchoring carries a known gap that the canonical
+  `.dockerignore` states in its own comment, since consuming repos receive the
+  file and not the tracker: the directory is created in the agent's working
+  directory, so a repo running agents in subdirectories still ships
+  `services/api/.claude/` and must add its own anchored entry there.
+
+- **A plain `docker build .` of a clone stamps the version that
+  `git describe --tags --always` gives**, derived from the `.git` in the build
+  context as the canonical `Dockerfile` above shows. Without its failure check,
+  a missing `git` or an unreadable checkout would leave `-X main.Version=` empty
+  and the build would still exit 0. `script/docker` and `script/cibuild` pass
+  the version they compute on the host; it takes precedence. They do this
+  byte-identically across repos:
+
+    ```sh
+    # The version and the tag each get their own line: a failing command
+    # substitution inside an argument does not trip `set -e`, so the inline
+    # form degrades to an empty constant.
+    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
+    [ -n "$version" ] || version="unknown"
+    tag="$(script/projectname)"
+    docker build --no-cache \
+        --build-arg VERSION="$version" \
+        -t "$tag" .
+    ```
+
+    `--always` makes an untagged repo yield an abbreviated commit hash rather
+    than failing, and the `[ -n "$version" ]` line is the single place the
+    fallback is applied — a live check that fires on a build from an export with
+    no `.git` and on a repository with no commits yet. Do not fold it into the
+    substitution as `|| echo unknown`, which makes the guard unreachable. The
+    Dockerfile's side is `ARG VERSION` in the stage that compiles, declared
+    there because `ARG` is stage-scoped; passing `VERSION` to a repo whose
+    Dockerfile declares no such `ARG` is ignored and costs nothing, which is why
+    the scripts stay byte-identical. One consequence for CI: the standard
+    checkout action clones shallow and fetches no tags, so the canonical
+    `.gitea/workflows/check.yml` sets `fetch-depth: 0` on its checkout step.
+
+- **Verify `.dockerignore` by enumerating the image, not by reading the
+  patterns.** Plant files at the root _and_ at least two directories deep, build
+  a probe image that does `COPY . .`, and list what actually landed
+  (`docker run --rm --entrypoint find IMAGE /app`). The `transferring context`
+  size is not a substitute: a nested secret is a few bytes, and BuildKit
+  transfers only the delta from the previous build.
 
 - **No build artifacts in version control.** Code-derived data (compiled
   bundles, minified output, generated assets) must never be committed to the
@@ -258,9 +505,56 @@ style conventions are in separate documents:
 - Make all changes on a feature branch. You can do whatever you want on a
   feature branch.
 
-- `.golangci.yml` is standardized and must _NEVER_ be modified by an agent, only
+- `.golangci.yml` is standardized. The vendored copy in a consuming repo must
-  manually by the user. Fetch from
+  _NEVER_ be modified by an agent: fetch it from
-  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`.
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml` and keep it
+  byte-identical, so that no repo can quietly loosen its own linting. Linter
+  configuration changes are made to the canonical copy in the `prompts` repo and
+  reach consuming repos by re-vendoring; an agent may open a PR against
+  canonical, which only the user merges. One list is exempt from byte-identity,
+  because it cannot be written once for every repo: the `deny` list of the
+  `test-support` depguard rule, where a repo names its own test-support packages
+  by full import path. A repo adds entries there and changes nothing else, and a
+  re-vendor carries its entries forward. The canonical golangci-lint version is
+  v2.14.0 (released 2026-09-24), pinned as the digest of the lint phase's base
+  image
+  (`golangci/golangci-lint@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f`,
+  which reports `2.14.0 built with go1.27.0 from 114493f9`). A module's `go`
+  directive must not name a newer Go minor version than the one golangci-lint
+  was built with, or golangci-lint refuses to lint it: this release lints
+  `go 1.27.1` but not `go 1.28`. That digest is the only pin, since no repo
+  installs golangci-lint on the host. A repo sets the lint phase digest to the
+  one named here and re-vendors `.golangci.yml` in the same commit, whichever of
+  the two prompted the change: the canonical copy can name linters that an older
+  golangci-lint rejects, and a newer golangci-lint can add linters that
+  `default: all` switches on until the canonical copy disables them.
+
+- **`script/bootstrap` installs a pinned tool by comparing versions, never by
+  testing presence.** An `if ! command -v <tool>; then install; fi` guard tests
+  `PATH` only, so on an already-provisioned machine the pin is inert and a
+  version bump is a silent no-op — while the Dockerfile, installing into a clean
+  image, gets the pinned version, so a local `make check` and `make docker` can
+  disagree about what the tool even is. The canonical form:
+    - compares the installed version against the pin over the **whole** version
+      token; a parser that stops at the first `-` reports `2.12.2` for a host
+      running `2.12.2-rc1` and skips the install;
+    - treats absent, non-zero, empty or unrecognised `--version` output as a
+      mismatch, so the failure direction is a redundant install and never a
+      skipped one;
+    - after installing, re-resolves the binary the way callers do — `hash -r`,
+      then through `PATH`, not through the directory the installer wrote to —
+      and fails naming the resolved path, since an install that a shadowing
+      binary hides succeeds while changing nothing any caller sees;
+    - is actually called, and prints the version on both success paths: a
+      function defined and never invoked has the same exit status and the same
+      empty output as one that worked.
+
+    Keep it POSIX sh: no arrays, no `[[`, no `grep -P`.
+
+    A Go tool a repo needs on the host is installed with `go install` pinned to
+    a commit hash (`go install <package>@<commit hash>`). It is never tracked as
+    a `go.mod` tool dependency or through a `tools.go` file, either of which
+    pulls the tool's own dependencies into the repo's `go.mod` and `go.sum`.
 
 - When pinning images or packages by hash, add a comment above the reference
   with the version and date (YYYY-MM-DD).
@@ -371,15 +665,21 @@ style conventions are in separate documents:
       Never edit existing migrations after release.
 
 - All repos should have an `.editorconfig` enforcing the project's indentation
-  settings.
+  settings: the standard file from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.editorconfig`, which sets
+  tabs for `Makefile` and Go files, followed by the repo's own sections, such as
+  one for another language it uses. A re-vendor replaces the standard part and
+  keeps those sections.
 
 - Avoid putting files in the repo root unless necessary. Root should contain
-  only project-level config files (`README.md`, `Makefile`, `Dockerfile`,
+  only project-level config files (`README.md`, `AGENTS.md`, `Makefile`,
-  `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`, and
+  `Dockerfile`, `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`,
-  language-specific config). Everything else goes in a subdirectory. Canonical
+  and language-specific config). Everything else goes in a subdirectory.
-  subdirectory names:
+  Canonical subdirectory names:
     - `bin/` — executable scripts and tools
-    - `cmd/` — Go command entrypoints
+    - `cmd/` — Go command entrypoints; thin only: one `main.go` per binary whose
+      body is a single call into `internal/` or `pkg/`, no project logic in
+      `cmd/`
     - `configs/` — configuration templates and examples
     - `deploy/` — deployment manifests (k8s, compose, terraform)
     - `docs/` — documentation and markdown (README.md stays in root)
@@ -406,3 +706,7 @@ style conventions are in separate documents:
     - Go: `go.mod`, `go.sum`, `.golangci.yml`
     - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
     - Python: `pyproject.toml`
+
+- Guidance for coding agents lives in one `AGENTS.md` at the repository root. It
+  is never committed under a file or directory named after one agent tool, such
+  as `CLAUDE.md` or `.claude/`, and never split into separate memory files.

TODO.md

@@ -2,14 +2,15 @@
 
 - take an issue from the `1.0.0` milestone on the tracker; work not yet on the
   tracker gets filed as an issue first
-- branch (from `main`)
+- branch from `next`
 - do the work, with tests, in small focused commits
 - record it at the top of Completed Steps (`TODO.md` changes in the same commit
   as the work)
-- push the branch and open a PR whose title ends with ` (closes #N)`
+- push the branch and open a PR against `next` whose title ends with
-- an independent review gates the merge; every finding is addressed or
+  ` (closes #N)`
-  explicitly rebutted on the PR
+- an independent review gates each merge to `next`; every finding is addressed
-- merge to `main` once the review passes
+  or explicitly rebutted on the PR
+- only the owner merges `next` to `main`
 
 # Status
 
@@ -28,16 +29,43 @@
 
 # Completed Steps
 
-- `make test-race` runs the test suite under the race detector in a cgo-enabled
+- re-vendor the canonical files and model scripts from `sneak/prompts` `next` at
+  `c55a0cb`: golangci-lint v2.14.0; lint and test are phases of the `Dockerfile`
+  that write no image, and `make test` runs the suite under the race detector,
+  so `Dockerfile.lint`, `script/verify-lint-image-pin` and `make test-race` are
+  gone; every `docker build` in `script/` passes `--no-cache`; prettier runs on
+  the host, from the node and yarn `script/bootstrap` installs, so the
+  `prettier` and `markdown` stages are gone and the build stage installs `git`
+  and `make` itself; a new push cancels the workflow's older run on the same
+  branch, and a run stops after 20 minutes; `.claude/settings.json` is deleted
+  (2026-10-08, https://git.eeqj.de/sneak/sfdupes/issues/95)
+
+- `scan` records mtime to the nanosecond, as whole seconds in `mtime` plus
+  `mtime_nsec`, and compares it at that resolution, so a same-size rewrite
+  within the same second is re-hashed (2026-10-07,
+  https://git.eeqj.de/sneak/sfdupes/issues/12)
+
+- cut the narration from `TODO.md` Completed Steps and from the comments in
+  `script/`, `Dockerfile` and `Dockerfile.lint` (gone since
+  https://git.eeqj.de/sneak/sfdupes/issues/95); §Workflow now branches from and
+  merges to `next` (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/49)
+
+- `make test-race` ran the test suite under the race detector in a cgo-enabled
   container, outside `make check` (2026-10-04,
-  https://git.eeqj.de/sneak/sfdupes/issues/18)
+  https://git.eeqj.de/sneak/sfdupes/issues/18). Since
+  https://git.eeqj.de/sneak/sfdupes/issues/95 `make test` itself runs the suite
+  under the race detector, in the `Dockerfile`'s Debian-based `test` phase, and
+  `make test-race` is gone
 
-- a bare `docker build .` fails with a message naming `script/cibuild` and
+- a bare `docker build .` failed, naming `script/cibuild` and `script/docker`,
-  `script/docker` instead of serving the gates from cache (2026-10-04,
+  rather than serve the gates from cache (2026-10-04,
-  https://git.eeqj.de/sneak/sfdupes/issues/39)
+  https://git.eeqj.de/sneak/sfdupes/issues/39). Since
+  https://git.eeqj.de/sneak/sfdupes/issues/95 a bare build succeeds, as
+  `REPO_POLICIES.md` requires, and may serve the gates from cache; the builds in
+  `script/` pass `--no-cache`, so theirs always run
 
-- `make fmt` and `make fmt-check` run prettier over all Markdown, in Docker, and
+- `make fmt` and `make fmt-check` run prettier over all Markdown, and CI checks
-  CI checks it; all Markdown reformatted (2026-10-04,
+  it; all Markdown reformatted (2026-10-04,
   https://git.eeqj.de/sneak/sfdupes/issues/19)
 
 - `script/lint` writes no image, so a run no longer leaves an untagged one
@@ -80,9 +108,12 @@
 - README documents install, Docker, a daily cron scan and how to read and check
   the reports (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/54)
 
-- the `Dockerfile` build stage keeps the Go module cache out of `builder`'s home
+- the `Dockerfile` build stage kept the Go module cache out of `builder`'s home
-  and copies the sources with `--chown`, so no `chown -R` walks them
+  and copied the sources with `--chown`, so no `chown -R` walked them
-  (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/43)
+  (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/43). Since
+  https://git.eeqj.de/sneak/sfdupes/issues/95 there is no `builder` user and
+  nothing changes owner: the build stage only compiles, as root, and the tests
+  run as `nobody` in the `test` phase
 
 - `--version` prints `sfdupes VERSION` to stdout; README documents it and
   `--help` (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/15)
@@ -121,29 +152,24 @@
 
 - stamp the git tag or short commit in a plain `docker build .` instead of `dev`
   (2026-10-02, branch `next`, closes
-  https://git.eeqj.de/sneak/sfdupes/issues/67): `.dockerignore` now sends
+  https://git.eeqj.de/sneak/sfdupes/issues/67): `.dockerignore` sends `.git`
-  `.git`, without `.git/config`, and the `Dockerfile` build stage takes the
+  without `.git/config`; the build stage stamps the `VERSION` build argument,
-  `VERSION` build argument when one is given, otherwise
+  else `git describe --tags --always`, and fails if the context carries `.git`
-  `git describe --tags --always` of that `.git`. The build fails if the context
+  and the version is still empty, `dev` or `unknown`. CI checks out the full
-  carries `.git` and the version still comes out empty, `dev` or `unknown`. The
+  history (`fetch-depth: 0`) so it stamps the same value as `make build`.
-  CI checkout step fetches the full history (`fetch-depth: 0`) so CI sees the
-  tag and stamps the same value as `make build`.
 
 - replace the 1 KiB end-window sampling with the head/tail plus content-hash
   ladder (2026-09-22, branch `next`, closes
-  https://git.eeqj.de/sneak/sfdupes/issues/61): a file under 10 MiB is hashed in
+  https://git.eeqj.de/sneak/sfdupes/issues/61); README "Duplicate detection"
-  full and compared directly, with no end-window step — its `head`, `tail`, and
+  documents every rung. A file under 10 MiB is hashed in full, and its `head`,
-  `content` all hold the whole-file hash. A file at 10 MiB or above gets only
+  `tail` and `content` all hold that hash. A larger file gets only its 64 KiB
-  the 64 KiB `head` and `tail` in the hash phase; a new content phase, after the
+  `head` and `tail` in the hash phase; the content phase, after the update
-  update phase, reads it for its `content` hash — the whole file below 50 MiB,
+  phase, reads it for `content` (the whole file below 50 MiB, gigabyte-spaced 1
-  gigabyte-spaced 1 MiB samples at or above — only when its size, `head`, and
+  MiB samples at or above) only when its size, `head` and `tail` match another
-  `tail` match another record's, from the same scan or stored by an earlier one,
+  record's from this scan or an earlier one, and never reads a file gone or
-  so a stored file gains its content hash when it gains a match. A file that is
+  changed since its record was written. `report` and `trees` leave out any
-  gone or has changed since its record was written is not read. The `content`
+  record without a `content` hash. The `content` column is part of the version 1
-  column is part of the version 1 schema. `report` and `trees` group by the
+  schema.
-  extended signature and leave out any record without a `content` hash, so the
-  ladder is applied across the whole database. README "Duplicate detection"
-  documents every rung including the probabilistic large-file path.
 
 - remove the dead `files.dat` references from `Makefile`, `.gitignore` and
   `.dockerignore` (2026-09-21, branch `next`, closes
@@ -151,265 +177,110 @@
 
 - fix the lint-image pin comments and `FROM` form in `Dockerfile` and
   `Dockerfile.lint` (2026-08-10, branch `next`, closes
-  https://git.eeqj.de/sneak/sfdupes/issues/25): dropped the false
+  https://git.eeqj.de/sneak/sfdupes/issues/25): both pins became the policy
-  `(Debian-based)` parenthetical (v2.12.1 was Debian too) and the redundant tag,
+  `# image:vX.Y.Z, YYYY-MM-DD` comment over a bare `FROM image@sha256:...`,
-  so both pins are the policy `# image:vX.Y.Z, YYYY-MM-DD` comment over a bare
+  without the false `(Debian-based)` note or the tag. Since
-  `FROM image@sha256:...`. Digest unchanged. `script/verify-lint-image-pin`
+  https://git.eeqj.de/sneak/sfdupes/issues/95 the `Dockerfile`'s `lint` phase
-  parses those `FROM` lines and still matches the tagless form; its advice line
+  holds the only golangci-lint pin, in that form, so `Dockerfile.lint` and
-  lost the now meaningless "tag and digest". With no tag in either reference, a
+  `script/verify-lint-image-pin`, which compared the two pins, are gone.
-  tag-only disagreement no longer exists — a one-sided tag is caught as a plain
-  mismatch.
 
 - run all linting in Docker via `Dockerfile.lint` and `script/lint` (2026-08-10,
   branch `next`, closes https://git.eeqj.de/sneak/sfdupes/issues/46): per the
-  owner ruling, the linter runs inside a container invoked through the `script/`
+  owner ruling the linter is never installed on a host, and
-  entrypoint and is never installed on a host. New root `Dockerfile.lint` COPYs
+  `golangci-lint config verify` runs before `golangci-lint run`.
-  the repo into the digest-pinned `golangci/golangci-lint:v2.12.2` image and
+  `script/bootstrap` stopped installing or pinning the linter, and
-  runs `golangci-lint config verify` and `golangci-lint run` as build steps, so
+  `script/verify-linter-pin` was retired. Since
-  a successful build IS a clean lint; `script/lint` is reduced to building it.
+  https://git.eeqj.de/sneak/sfdupes/issues/95 both commands run in the
-  `script/bootstrap` loses the `go install`, the pin constants, the version
+  `Dockerfile`'s `lint` phase, which `script/lint` builds alone and the build
-  parser and `verify_golangci_lint` outright rather than hardening them — with
+  stage depends on through `COPY --from=lint /src/go.sum /dev/null`;
-  nothing linting on the host, the `$GOPATH/bin` versus `PATH` problem that
+  `Dockerfile.lint` and `script/verify-lint-image-pin` are gone. Nothing inside
-  motivated them has no subject — and now warns rather than fails when `docker`
+  an image build may run docker, so the phase calls `golangci-lint` directly.
-  is absent. Two traps handled. A lint build on an unchanged tree returns
-  success in well under a second having run no linter, which is
-  https://git.eeqj.de/sneak/sfdupes/issues/32 and
-  https://git.eeqj.de/sneak/sfdupes/issues/39 again, so `Dockerfile.lint`
-  carries `ARG CHECK_EPOCH` referenced inside every gate `RUN` (BuildKit hashes
-  the expanded command, not the declaration) and `script/lint` passes
-  `"$(date +%s)-$$"` — the PID matters because two lint runs land inside the
-  same second easily. And nothing inside an image build may shell out to docker,
-  so the main `Dockerfile`'s lint stage now invokes `golangci-lint` directly
-  instead of `make lint`, and its build stage runs `make test` and
-  `make fmt-check` instead of the `make check` aggregate (`make`, not the
-  scripts bare, because the Makefile's `export CGO_ENABLED = 0` only reaches
-  what it invokes). `COPY --from=lint` `/usr/bin/golangci-lint` is replaced by
-  `COPY --from=lint /src/go.sum /dev/null`: the copied binary was the only edge
-  forcing BuildKit to finish linting before the build stage starts, and dropping
-  it without replacing the edge would have ended fail-fast linting silently
-  under a still-green build. That is canonical `REPO_POLICIES.md:107`'s ordering
-  edge, restored. `ENV PATH=/home/builder/go/bin:$PATH` is gone with the
-  `go install` that justified it. `script/verify-linter-pin` is retired, deleted
-  along with its README entry, because both of its subjects ceased to exist in
-  the same change: it compared a linter binary against `GOLANGCI_LINT_VERSION`
-  in `script/bootstrap`, and there is now neither a binary crossing between
-  stages nor a version pin in bootstrap. The drift it guarded has not gone away,
-  it has moved — the linter is still pinned twice, now as the `FROM` line of
-  `Dockerfile.lint` and the `FROM` line of the `Dockerfile` lint stage, with
-  nothing syncing them, which is exactly what
-  https://git.eeqj.de/sneak/sfdupes/issues/42 made a build failure. Its
-  replacement is one new `script/verify-lint-image-pin`, run as a gate in both
-  files, which compares the two references to each other and deliberately
-  restates neither: a hardcoded expected digest would be a third copy and the
-  same drift one file further out. `golangci-lint config verify` is included per
-  the ruling, and the concern about its unpinned live HTTPS schema fetch was
-  measured rather than assumed — under `--network none` the pinned binary both
-  passes a valid config and rejects an invalid one with the jsonschema error, so
-  it validates from an embedded schema and makes no network call of its own. The
-  README scopes that to the gate steps rather than to linting as a whole:
-  `Dockerfile.lint` runs `go mod download` above them, so a cold cache still
-  needs the network and only a warm one lints offline. Verified: `make lint`
-  green with every `PATH` directory containing a `golangci-lint` removed
-  (`/home/user/go/bin`, `/home/user/.local/bin`, `/usr/local/bin`;
-  `command -v golangci-lint` empty); two consecutive `script/lint` runs on an
-  untouched tree both executed the linter, 27.7s and 28.7s in the lint step
-  under distinct epochs with the `COPY . .` layer `CACHED` above them, at 42.2s
-  and 41.8s wall clock — the no-cache rule was not weakened to shorten that.
-  Negative control: a planted `var unusedIssue46Sentinel = 1` failed
-  `script/lint` with
-  `report.go:173:5: var unusedIssue46Sentinel is unused (unused)`, and failed
-  `make docker` at `[lint 9/9]` with the build stage stopped at `[builder 3/12]`
-  — `COPY --from=lint`, `script/bootstrap`, the test gate and `make build` all
-  zero occurrences — then reverted clean. The drift guard fails on a tag-only
-  disagreement, on a digest-only disagreement, and on an unreadable reference,
-  naming both sides. `make docker` green in 5m35s with all six gates executing
-  under one epoch (lint 37.6s, test 25.2s reporting
-  `ok sneak.berlin/go/sfdupes 1.938s coverage: 88.5%`, not `(cached)`). The
-  non-root quirk still holds: in the builder image with the Go test cache off,
-  `--user 0:0` fails `TestScanHardlinkRunFailsTogether` (exit 1) where the
-  unprivileged user passes (exit 0). Noted for follow-up, not fixed here:
-  `golangci-lint` warns that the `gomodguard` linter is deprecated since v2.12.0
-  in favour of `gomodguard_v2`.
 
 - install the Docker build stage's prerequisites by running `script/bootstrap`
   instead of `apk add --no-cache make` inline (2026-08-09, branch
-  `dockerfile-bootstrap`, closes #42): canonical `REPO_POLICIES.md:97` requires
+  `dockerfile-bootstrap`, closes https://git.eeqj.de/sneak/sfdupes/issues/42),
-  it, and the inline install left the build stage maintaining its own notion of
+  with `script/verify-linter-pin` failing the build unless the linter copied
-  the toolchain — exactly the divergence #24 exists to close, one layer down.
+  from the lint stage was the version `script/bootstrap` pinned. Builds then
-  The stage now copies `script/` plus `go.mod`/`go.sum` and runs
+  took up to 5m14s cold, mostly in a `chown -R` of the module cache, filed as
-  `script/bootstrap`, which ends in `go mod download`, so the separate
+  https://git.eeqj.de/sneak/sfdupes/issues/43. Since
-  invocation of that is gone. `COPY --from=lint /usr/bin/golangci-lint` stays,
+  https://git.eeqj.de/sneak/sfdupes/issues/95 the build stage installs `git` and
-  and moves above the bootstrap layer. It is the only edge making this stage
+  `make` with `apk add --no-cache` and only compiles; the `lint` and `test`
-  depend on the lint stage, so deleting it as redundant would end fail-fast
+  phases are the gates
-  linting silently. Letting bootstrap install its own linter here would have
-  reintroduced the second toolchain and paid for a from-source build of it. What
-  makes the two stages provably one toolchain rather than two that happen to
-  agree is a new `script/verify-linter-pin`, run in the build stage on the
-  binary that arrives from the lint stage, before bootstrap: it fails the build
-  naming both versions unless that binary is the version `script/bootstrap`
-  pins. Bootstrap's own check could not serve that purpose — it reinstalls its
-  pin from source and then verifies whatever `PATH` resolves, so drift
-  self-heals silently and a lint stage image bumped on its own would lint at the
-  new version while `make check` ran at the old one, green. The linter version
-  is pinned in two independent places (the lint stage image digest and
-  `GOLANGCI_LINT_VERSION`) and nothing else keeps them in sync, so a
-  half-applied bump is now a build failure. The pin is read out of
-  `script/bootstrap`, which stays the single source of truth; a pin that cannot
-  be read is a hard failure, not a skip. The check needs no `CHECK_EPOCH`: its
-  only inputs are the copied binary and `script/`, so Docker invalidates the
-  layer exactly when a cached result would stop being true, and it is documented
-  with the other entrypoints in the README. `$GOPATH/bin` joins `PATH` because
-  that is where bootstrap's `go install` lands and bootstrap verifies its
-  installs against what `PATH` resolves — nothing in the image is shadowed by
-  it, the directory does not exist until bootstrap runs. Everything added sits
-  above `ARG CHECK_EPOCH`, and the `chown` and `USER builder` still precede
-  `make check`. Verified: the guard fails the build with both versions named
-  when the lint stage's linter is faked to a different version, and an
-  unmodified build still passes it; bootstrap runs clean under Alpine's `sh` and
-  its `apk` branch, installing `git` and `make` and finding the copied linter
-  already at the pin; a second build served the bootstrap and dependency layers
-  `CACHED` while both gates ran with a fresh epoch; a planted `unused` finding
-  failed the build at the lint gate in 48.9s with the build stage's `make check`
-  never starting; and the suite run in the image as `--user 0:0` fails
-  `TestScanHardlinkRunFailsTogether`, so the drop to the unprivileged user is
-  still load-bearing. That last check needs the Go test cache disabled — the
-  first attempt reported `ok ... (cached)` as root, reusing the result the
-  build-time run had left in the shared cache, which would have read as a pass.
-  Build wall time, on a shared host running many concurrent builds and so noisy:
-  2m13s on an unchanged tree, 2m17s and 4m29s for two builds after a source
-  change, 5m14s cold. Only the cold one breaches the policy ceiling, and not
-  because of this change — `chown -R builder:builder /src /home/builder` walks
-  the module cache and re-runs on every source change, and it alone varied
-  between 77s and 210s across those four builds, which is also the whole spread
-  in the totals. The same cold measurement against `main` is 5m03s with a 209s
-  `chown`. Filed as #43
 - bust the Docker layer cache for the gate steps, so `script/cibuild` and
   `script/docker` cannot report a green they did not earn (2026-08-09, branch
-  `cibuild-cache-bust`, closes #32): both scripts were bare `docker build`
+  `cibuild-cache-bust`, closes https://git.eeqj.de/sneak/sfdupes/issues/32): the
-  invocations with no cache control, and the `Dockerfile` copies the tree before
+  `Dockerfile` copies the tree before its gates, so on an unchanged tree Docker
-  running its gates, so on an unchanged tree Docker served those layers from
+  served them from cache and the build exited 0 having run nothing. The fix was
-  cache and the build exited 0 having executed nothing. That is not hypothetical
+  a `CHECK_EPOCH` build argument; since
-  here — every merge this repo has done is a non-fast-forward merge of an
+  https://git.eeqj.de/sneak/sfdupes/issues/95 every `docker build` in `script/`
-  undiverged branch, so each merge commit's tree is byte-identical to the branch
+  passes `--no-cache` instead. Run as root, the tests fail
-  head's and each merge CI run was almost certainly a full cache hit; and PR
+  `TestScanHardlinkRunFailsTogether`, because root reads through the `chmod(0)`
-  #31's reviewer found `make docker` returning success as a 17-layer cache hit,
+  the test relies on, so the `test` phase runs them as `nobody`
-  catching it only by being suspicious. The fix is `ARG CHECK_EPOCH` with the
-  scripts passing `--build-arg CHECK_EPOCH="$(date +%s)"`. Two details make or
-  break it. `ARG` is scoped per stage and this `Dockerfile` has three gates
-  across two — `make fmt-check` and `make lint` in the lint stage, `make check`
-  in the build stage — so a single declaration would have left one stage
-  silently cacheable; it is declared in both. And BuildKit hashes the expanded
-  command, not the declaration, so a declared-but-unreferenced `ARG` invalidates
-  nothing: each gate `RUN` echoes the epoch, which also puts the value in the
-  build log as evidence the layer really ran. Placement is below the dependency
-  layers on purpose — a build that goes cold every time would be a different
-  bug, not a fix. Verified by running each script twice back to back on an
-  unchanged tree under `BUILDKIT_PROGRESS=plain`: all three gates executed on
-  all four runs, each with a fresh epoch in the log (`script/cibuild` 78.8s then
-  61.1s; `script/docker` 61.1s then 53.4s), and thirteen steps were still served
-  `CACHED` in the steady state — the lint stage's `WORKDIR /src`, both
-  `go mod download`s, `apk add`, `adduser`, the `chown`, every `go.mod`/`go.sum`
-  and source copy, the linter copy out of the lint stage, and the binary copy
-  into the runtime stage. The lint stage still gates the build stage: with a
-  deliberate `unused` finding planted in the tree, the build failed at
-  `make lint` in 36.1s and the build-stage `make check` never started. The build
-  stage also still drops to the unprivileged `builder` user before `make check`,
-  which the suite depends on rather than merely prefers: forcing the same image
-  to run the tests as root fails `TestScanHardlinkRunFailsTogether`, because
-  root reads straight through the `chmod(0)` the test uses to prove hard links
-  are read once. This is the local fix only; propagating it to the canonical
-  templates is `prompts` #26
 - check the installed golangci-lint version in `script/bootstrap` instead of
-  only its presence (2026-08-09, branch `bootstrap-version-check`, closes #24):
+  only its presence (2026-08-09, branch `bootstrap-version-check`, closes
-  `missing golangci-lint` meant any linter already on `PATH` satisfied the
+  https://git.eeqj.de/sneak/sfdupes/issues/24): the version lives only in
-  check, so the pin was never consulted and the v2.12.2 bump from #3 was inert
+  `GOLANGCI_LINT_VERSION`, with the `go install` module ref derived from it, and
-  on every host that already had one — this host ran v2.10.1 against a v2.12.2
+  any installed version that is not the pin — older, newer, absent or
-  pin, `make check` went green, and `make docker` then rejected the same commit
+  unparseable — is reinstalled. `go install` writes into `GOBIN` (or
-  with findings the local gate never saw. The version now lives in one place,
+  `GOPATH/bin`) while `make lint` runs the first `golangci-lint` on `PATH`, so
-  `GOLANGCI_LINT_VERSION`, with the `go install` module ref derived from it so a
+  bootstrap re-reads the effective version after installing and, on a mismatch,
-  bump cannot half-apply; a `golangci_lint_version` helper parses
+  prints both paths and both versions and exits non-zero; it does not reorder
-  `golangci-lint --version` (taking the field after the word `version` and
+  `PATH` or delete anyone's binary. The `--version` call keeps its stderr and is
-  tolerating an optional leading `v`, which the module ref carries and the
+  bounded by `timeout(1)` where that exists. `git`, `make` and `go` keep
-  binary's output does not), and any version that is not the pin — older, newer,
+  presence-only checks. Verified by bootstrapping this host from v2.10.1 to
-  absent or unparseable — is reinstalled. The install is then verified against
+  v2.12.2 and again to a no-op, and by stub runs of the script under `dash`
-  the binary `PATH` actually resolves: `go install` writes into `GOBIN` (or
+  covering a thirteen-input version-parse matrix, a shadowed install that must
-  `GOPATH/bin`) while `make lint` runs whichever `golangci-lint` comes first on
+  exit non-zero, an install destination not on `PATH`, `GOBIN` set, and a wedged
-  `PATH`, so a wrong-version one sitting ahead of it — nix, apt, brew, apk, or
+  binary that must hit the timeout; `make check` and `make lint` are clean at
-  the `/usr/local/bin` copy the `Dockerfile` builder stage makes — would swallow
+  v2.12.2, so v2.10.1 was not hiding any findings on `main`
-  the install and leave the local gate disagreeing with CI under an affirmative
-  `bootstrap complete`. Bootstrap now re-reads the effective version after
-  installing and, on a mismatch, prints both paths and both versions to stderr
-  and exits non-zero instead of claiming success; it does not reorder anyone's
-  `PATH` or delete their binary. The `--version` call keeps its stderr
-  connected, so a present-but-broken binary says why rather than reinstalling
-  forever in silence, and is bounded by `timeout(1)` where that exists, so a
-  wedged binary cannot hang bootstrap. `git`, `make` and `go` keep their
-  presence-only checks and now say why in a comment: they are host
-  package-manager tools the repo deliberately does not pin, with `go.mod`
-  governing the language version and the digest-pinned images covering
-  reproducible builds. Verified on this host by bootstrapping from v2.10.1 to
-  v2.12.2 and running it again to a no-op, plus stub runs of the real script
-  under `dash` covering a thirteen-input parse matrix (absent, older, newer,
-  host-style, image-style, leading-`v`, stderr-only, empty, non-zero exit,
-  impostor binary, `(devel)`, trailing `version`), a shadowed install that must
-  exit non-zero, an install destination not on `PATH` at all, `GOBIN` set, and a
-  wedged binary that must hit the timeout; `make check` and `make lint` are
-  clean at v2.12.2, so v2.10.1 was not hiding any findings on `main`
 - unwind the hash worker pool on the error path (2026-08-09, branch
-  `hash-pool-cleanup`, closes #6): `hashPhase` used to return the moment
+  `hash-pool-cleanup`, closes https://git.eeqj.de/sneak/sfdupes/issues/6): the
-  `recordRun` failed and abandon the pool — the feeder parked forever on a full
+  pool is now an owned, context-aware `hashPool`: every blocking send in the
-  `jobs` channel and every worker on a full `results` channel. That only stopped
+  feeder and the workers selects on `ctx.Done()`, `jobs` is closed on every path
-  being invisible when #4 landed and `runScan` began unwinding instead of
+  out, and `hashPhase` defers `pool.stop()`, which cancels and then drains
-  calling `os.Exit`. The pool is now an owned, context-aware `hashPool`: every
+  `results` until the last goroutine has exited — draining is what frees a
-  blocking send in the feeder and the workers selects on `ctx.Done()`, `jobs` is
+  worker already parked on a send. `ctx` is threaded from `cmd.Context()`
-  closed on every path out, and `hashPhase` defers `pool.stop()`, which cancels
+  through `runScan`, `syncScan`, both worker pools and the whole database layer,
-  and then drains `results` until the last goroutine has exited — draining is
+  as the first parameter everywhere. The walk pool gets the same treatment plus
-  what frees a worker already parked on a send. `ctx` is threaded from
+  a `ctx.Err()` guard after the walk: a cancelled walk yields a partial size
-  `cmd.Context()` through `runScan`, `syncScan`, both worker pools and the whole
+  census, and every file it never reached looks vanished to the update phase.
-  database layer (it is the first parameter everywhere), so #5 can hand this
+  That phase's own `BeginTx` also fails on the cancelled context before deleting
-  path a signal and needs to add nothing else. The walk pool never leaked,
+  anything, but the guard is the barrier that still holds once an interrupted
-  because `walkPhase` always drains its events to close, but it has the same
+  scan may commit what it has. Tests drive `run(scan)` against a database whose
-  unbounded-send shape and #5 will give it an early return, so it gets the same
+  insert trigger aborts and assert that the scan fails instead of hanging and
-  treatment plus a `ctx.Err()` guard after the walk: a cancelled walk yields a
+  that `runtime.NumGoroutine()` polls back to its pre-scan baseline; others
-  partial size census, and every file it never reached looks vanished to the
+  cancel a scan part-way through the walk, deterministically, by counting its
-  update phase. That phase's own `BeginTx` fails on the same cancelled context
+  own consultations of `ctx.Done()`, and assert that it stops at the guard
-  before deleting anything, so the guard is defence in depth rather than the
+  holding a partial census and a still-populated record index, with every record
-  only barrier — but it is the one that survives #5 deciding an interrupted scan
+  intact. Direct tests of `sendEvent`, the walk workers, `dispatchDirs`,
-  may commit what it has. Tests drive `run(scan)` against a database whose
+  `feedHashJobs`, `hashWorker` and `hashPhase` cover the remaining cancellation
-  insert trigger aborts, and assert both that the scan fails instead of hanging
+  branches of both pools
-  and that `runtime.NumGoroutine()` polls back to its pre-scan baseline; a
-  second set cancels a scan part-way through the walk — deterministically, by
-  counting the scan's own consultations of `ctx.Done()` rather than racing a
-  timer — and asserts that it stops at the guard holding a partial census and a
-  still-populated record index, with every record intact. The remaining
-  cancellation branches of both pools are covered by direct tests of
-  `sendEvent`, the walk workers, `dispatchDirs`, `feedHashJobs`, `hashWorker`
-  and `hashPhase`
 - guarantee the database is closed on every fatal exit path (2026-08-09, branch
-  `db-close-on-fatal`, closes #4): `fatalf` and its `os.Exit(1)` are gone, so
+  `db-close-on-fatal`, closes https://git.eeqj.de/sneak/sfdupes/issues/4):
-  the deferred `db.Close()` — and with it the SQLite WAL checkpoint — now
+  `fatalf` and its `os.Exit(1)` are gone, so the deferred `db.Close()` — and
-  actually runs when a subcommand fails; `runScan`, `runReport`, `runTrees`,
+  with it the SQLite WAL checkpoint — now actually runs when a subcommand fails;
-  `loadRecords` and `resolveRoots` return errors instead. The single exit point
+  `runScan`, `runReport`, `runTrees`, `loadRecords` and `resolveRoots` return
-  is `run` in `main.go`: it maps a `fatalError` (anything a subcommand returned)
+  errors instead. The single exit point is `run` in `main.go`: it maps a
-  to exit 1 and cobra's own argument and flag errors to exit 2, which keeps a
+  `fatalError` (anything a subcommand returned) to exit 1 and cobra's own
-  runtime failure from being reported as a usage error or printing the usage
+  argument and flag errors to exit 2, which keeps a runtime failure from being
-  text. New `main_test.go` drives the CLI in-process and asserts the exit codes
+  reported as a usage error or printing the usage text. New `main_test.go`
-  from README §Error handling plus the stdout/stderr split, including that a
+  drives the CLI in-process and asserts the exit codes from README §Error
-  fatal error raised after the database is open leaves no `-wal`/`-shm` sidecar
+  handling plus the stdout/stderr split, including that a fatal error raised
-  behind for `scan`, `report` or `trees`
+  after the database is open leaves no `-wal`/`-shm` sidecar behind for `scan`,
+  `report` or `trees`
 - update golangci-lint to v2.12.2 with the canonical config (2026-08-09, branch
-  `golangci-v2.12.2`, merged as `38a01bd`, closes #3): bumped the pinned linter
+  `golangci-v2.12.2`, merged as `38a01bd`, closes
-  in the `Dockerfile` lint stage and `script/bootstrap` from v2.12.1 to v2.12.2,
+  https://git.eeqj.de/sneak/sfdupes/issues/3): bumped the pinned linter in the
-  and replaced `.golangci.yml` with the canonical file — the linter settings
+  `Dockerfile` lint stage and `script/bootstrap` from v2.12.1 to v2.12.2, and
-  (`lll`, `funlen`, `cyclop`, `dupl` thresholds) now live under
+  replaced `.golangci.yml` with the canonical file — the linter settings (`lll`,
-  `linters.settings` per the v2 schema, so they are actually applied; no new
+  `funlen`, `cyclop`, `dupl` thresholds) now live under `linters.settings` per
-  lint findings surfaced
+  the v2 schema, so they are actually applied; no new lint findings surfaced
 - convert Makefile targets to scripts-to-rule-them-all `script/` entrypoints
-  like the other managed repos (2026-07-26, commit `3abeacf`, closes #1): all 12
+  like the other managed repos (2026-07-26, commit `3abeacf`, closes
-  `script/` entrypoints exist (`bootstrap`, `setup`, `projectname`, `test`,
+  https://git.eeqj.de/sneak/sfdupes/issues/1): all 12 `script/` entrypoints
-  `lint`, `fmt`, `fmt-check`, `check`, `docker`, `cibuild`, `precommit`,
+  exist (`bootstrap`, `setup`, `projectname`, `test`, `lint`, `fmt`,
-  `install-precommit`) and every Makefile target is now a thin shim over them,
+  `fmt-check`, `check`, `docker`, `cibuild`, `precommit`, `install-precommit`)
-  matching the other managed repos
+  and every Makefile target is now a thin shim over them
 - make the binary the default Make target (2026-07-24, branch
   `make-default-target`): plain `make` now builds `sfdupes` (previously it ran
   `check` plus `build`); `make build` remains as an alias
@@ -428,8 +299,7 @@
 - announce each operand on stderr before its passes (2026-07-24, branch
   `scan-operand-progress`): with per-operand walk/hash/update cycles, a
   multi-operand run (e.g. `scan /srv/*`) showed pass totals that looked like the
-  whole run's — an operator watching operand 3 of 14 hash 300k files concluded
+  whole run's
-  20M files were being skipped
 - parallel walk (2026-07-24, branch `parallel-walk`): the walk pass was a single
   goroutine and took hours at ~20M files on a busy pool (observed: 22M files in
   4h on a ZFS server); it is now a per-directory worker-pool traversal that
@@ -501,6 +371,3 @@ Accepted divergences (no action):
 
 - flat single-package layout with `.go` files in the repo root — fine for a
   small single-binary tool per the Go styleguide; the tracker audit agrees
-- `make test` runs without `-race` — the repo mandates `CGO_ENABLED=0` (pure-Go
-  builds) and the race detector requires cgo, so the detector runs in a separate
-  cgo-enabled container, `make test-race`, which is not part of `make check`

db.go

@@ -11,6 +11,7 @@ import (
 	"path/filepath"
 	"slices"
 	"strconv"
+	"time"
 
 	"golang.org/x/sys/unix"
 	// The pure-Go SQLite driver, registered as "sqlite"; keeps cgo
@@ -40,15 +41,18 @@ const dbDirPerm = 0o755
 const lockFilePerm = 0o600
 
 // createTableSQL is the schema applied to a fresh database. Paths are
-// BLOBs because Unix paths are raw bytes, not guaranteed UTF-8.
+// BLOBs because Unix paths are raw bytes, not guaranteed UTF-8. mtime
+// holds whole Unix seconds and mtime_nsec the nanoseconds within that
+// second.
 const createTableSQL = `
 CREATE TABLE files (
-    path    BLOB PRIMARY KEY,
+    path       BLOB PRIMARY KEY,
-    size    INTEGER NOT NULL,
+    size       INTEGER NOT NULL,
-    mtime   INTEGER NOT NULL,
+    mtime      INTEGER NOT NULL,
-    head    TEXT NOT NULL,
+    mtime_nsec INTEGER NOT NULL,
-    tail    TEXT NOT NULL,
+    head       TEXT NOT NULL,
-    content TEXT NOT NULL
+    tail       TEXT NOT NULL,
+    content    TEXT NOT NULL
 ) WITHOUT ROWID
 `
 
@@ -61,10 +65,11 @@ CREATE INDEX files_signature ON files (size, head, tail, content)
 // upsertSQL inserts one file record, replacing any existing record for
 // the same path.
 const upsertSQL = `
-INSERT INTO files (path, size, mtime, head, tail, content)
+INSERT INTO files (path, size, mtime, mtime_nsec, head, tail, content)
-VALUES (?, ?, ?, ?, ?, ?)
+VALUES (?, ?, ?, ?, ?, ?, ?)
 ON CONFLICT (path) DO UPDATE SET
     size = excluded.size, mtime = excluded.mtime,
+    mtime_nsec = excluded.mtime_nsec,
     head = excluded.head, tail = excluded.tail,
     content = excluded.content
 `
@@ -356,8 +361,8 @@ func userVersion(ctx context.Context, db *sql.DB) (int, error) {
 // which is the order of the primary key, so SQLite does not sort.
 func loadFileRows(ctx context.Context, db *sql.DB, fn func(r scanRec)) error {
 	rows, err := db.QueryContext(ctx,
-		"SELECT path, size, mtime, head, tail, content FROM files "+
+		"SELECT path, size, mtime, mtime_nsec, head, tail, content "+
-			"ORDER BY path")
+			"FROM files ORDER BY path")
 	if err != nil {
 		return fmt.Errorf("read records: %w", err)
 	}
@@ -366,17 +371,19 @@ func loadFileRows(ctx context.Context, db *sql.DB, fn func(r scanRec)) error {
 
 	for rows.Next() {
 		var (
-			path []byte
+			path      []byte
-			r    scanRec
+			sec, nsec int64
+			r         scanRec
 		)
 
-		err = rows.Scan(&path, &r.size, &r.mtime, &r.head, &r.tail,
+		err = rows.Scan(&path, &r.size, &sec, &nsec, &r.head, &r.tail,
 			&r.content)
 		if err != nil {
 			return fmt.Errorf("read record: %w", err)
 		}
 
 		r.path = string(path)
+		r.mtime = time.Unix(sec, nsec)
 		fn(r)
 	}
 
@@ -466,10 +473,10 @@ func loadDupeRows(ctx context.Context, db *sql.DB,
 // values, and skipping the hash columns keeps the scan's in-memory
 // index small on multi-million-file databases.
 func loadFileMeta(ctx context.Context, db *sql.DB,
-	fn func(path string, size, mtime int64, hashed bool),
+	fn func(path string, size int64, mtime time.Time, hashed bool),
 ) error {
 	rows, err := db.QueryContext(ctx,
-		"SELECT path, size, mtime, head <> '' FROM files")
+		"SELECT path, size, mtime, mtime_nsec, head <> '' FROM files")
 	if err != nil {
 		return fmt.Errorf("read records: %w", err)
 	}
@@ -478,17 +485,17 @@ func loadFileMeta(ctx context.Context, db *sql.DB,
 
 	for rows.Next() {
 		var (
-			path        []byte
+			path            []byte
-			size, mtime int64
+			size, sec, nsec int64
-			hashed      int64
+			hashed          int64
 		)
 
-		err = rows.Scan(&path, &size, &mtime, &hashed)
+		err = rows.Scan(&path, &size, &sec, &nsec, &hashed)
 		if err != nil {
 			return fmt.Errorf("read record: %w", err)
 		}
 
-		fn(string(path), size, mtime, hashed != 0)
+		fn(string(path), size, time.Unix(sec, nsec), hashed != 0)
 	}
 
 	err = rows.Err()
@@ -507,7 +514,7 @@ func loadFileMeta(ctx context.Context, db *sql.DB,
 // memory; the rows come ordered by size, head, and tail, so each
 // group's rows arrive together.
 const contentCandidatesSQL = `
-SELECT f.path, f.size, f.mtime, f.head, f.tail, f.content <> ''
+SELECT f.path, f.size, f.mtime, f.mtime_nsec, f.head, f.tail, f.content <> ''
 FROM files AS f
 JOIN (
     SELECT size, head, tail
@@ -533,17 +540,20 @@ func loadContentCandidates(ctx context.Context, db *sql.DB,
 
 	for rows.Next() {
 		var (
-			path   []byte
+			path      []byte
-			r      scanRec
+			sec, nsec int64
-			hashed int64
+			r         scanRec
+			hashed    int64
 		)
 
-		err = rows.Scan(&path, &r.size, &r.mtime, &r.head, &r.tail, &hashed)
+		err = rows.Scan(&path, &r.size, &sec, &nsec, &r.head, &r.tail,
+			&hashed)
 		if err != nil {
 			return fmt.Errorf("read record: %w", err)
 		}
 
 		r.path = string(path)
+		r.mtime = time.Unix(sec, nsec)
 		fn(r, hashed != 0)
 	}
 
@@ -627,8 +637,8 @@ func execUpserts(ctx context.Context, tx *sql.Tx, upserts []scanRec,
 	defer func() { _ = st.Close() }()
 
 	for _, r := range upserts {
-		_, err = st.ExecContext(ctx,
+		_, err = st.ExecContext(ctx, []byte(r.path), r.size,
-			[]byte(r.path), r.size, r.mtime, r.head, r.tail, r.content)
+			r.mtime.Unix(), r.mtime.Nanosecond(), r.head, r.tail, r.content)
 		if err != nil {
 			return fmt.Errorf("upsert %s: %w", r.path, err)
 		}

db_test.go

@@ -10,6 +10,7 @@ import (
 	"slices"
 	"strings"
 	"testing"
+	"time"
 )
 
 // testDBPath returns a database path inside a fresh temp dir.
@@ -260,10 +261,13 @@ func TestApplyChangesRoundTrip(t *testing.T) {
 	// written.
 	recs := []scanRec{
 		{
-			size: 2, mtime: 20, head: "h2", tail: "t2", content: "c2",
+			size: 2, mtime: time.Unix(20, 999_999_999), head: "h2", tail: "t2",
-			path: "/a/tab\tnew\nline",
+			content: "c2", path: "/a/tab\tnew\nline",
+		},
+		{
+			size: 1, mtime: time.Unix(10, 0), head: "h1", tail: "t1",
+			content: "c1", path: "/a/x",
 		},
-		{size: 1, mtime: 10, head: "h1", tail: "t1", content: "c1", path: "/a/x"},
 	}
 
 	err := applyChanges(t.Context(), db, recs, nil,
@@ -281,7 +285,8 @@ func TestApplyChangesRoundTrip(t *testing.T) {
 	// An upsert for an existing path updates in place; a delete
 	// removes exactly its path.
 	upd := scanRec{
-		size: 3, mtime: 30, head: "h3", tail: "t3", content: "c3", path: "/a/x",
+		size: 3, mtime: time.Unix(30, 0), head: "h3", tail: "t3", content: "c3",
+		path: "/a/x",
 	}
 
 	err = applyChanges(t.Context(), db, []scanRec{upd},
@@ -308,7 +313,7 @@ func TestApplyChangesBatching(t *testing.T) {
 	recs := make([]scanRec, 0, n)
 	for i := range n {
 		recs = append(recs, scanRec{
-			size: int64(i), mtime: 1, head: "h", tail: "t",
+			size: int64(i), mtime: time.Unix(1, 0), head: "h", tail: "t",
 			path: fmt.Sprintf("/batch/%07d", i),
 		})
 	}

report.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"strings"
+	"time"
 )
 
 // ioBufSize is the buffer size for the buffered stdout writers.
@@ -21,7 +22,7 @@ const minGroupSize = 2
 // only and used by scan for change detection.
 type scanRec struct {
 	size    int64
-	mtime   int64
+	mtime   time.Time
 	head    string
 	tail    string
 	content string

report_test.go

@@ -11,6 +11,7 @@ import (
 	"slices"
 	"strings"
 	"testing"
+	"time"
 )
 
 // awkwardDir is a directory name holding every byte the reports escape.
@@ -313,8 +314,14 @@ func TestDupeGroupsMtimeExcluded(t *testing.T) {
 	// mtime is informational only; records differing only in mtime
 	// still group together.
 	recs := []scanRec{
-		{size: 9, mtime: 100, head: "h", tail: "t", content: "c", path: "/m/1"},
+		{
-		{size: 9, mtime: 200, head: "h", tail: "t", content: "c", path: "/m/2"},
+			size: 9, mtime: time.Unix(100, 0), head: "h", tail: "t",
+			content: "c", path: "/m/1",
+		},
+		{
+			size: 9, mtime: time.Unix(200, 0), head: "h", tail: "t",
+			content: "c", path: "/m/2",
+		},
 	}
 
 	groups := dupeGroupsOf(t, recs)

scan.go

@@ -17,6 +17,7 @@ import (
 	"strings"
 	"sync"
 	"syscall"
+	"time"
 )
 
 // The duplicate ladder (see hashSignature and README "Duplicate
@@ -68,7 +69,7 @@ var errInterrupted = errors.New("scan interrupted")
 type fileRec struct {
 	path  string
 	size  int64
-	mtime int64
+	mtime time.Time
 	dev   uint64
 	ino   uint64
 }
@@ -79,7 +80,7 @@ type fileRec struct {
 // they would dominate the scan's memory.
 type fileMeta struct {
 	size   int64
-	mtime  int64
+	mtime  time.Time
 	hashed bool
 }
 
@@ -369,7 +370,7 @@ func (s *scanState) loadIndex(ctx context.Context, roots []string) error {
 	s.existing = make(map[string]fileMeta)
 
 	return loadFileMeta(ctx, s.db,
-		func(path string, size, mtime int64, hashed bool) {
+		func(path string, size int64, mtime time.Time, hashed bool) {
 			prog.increment()
 
 			if underAnyRoot(path, roots) {
@@ -415,7 +416,7 @@ func (s *scanState) walkPhase(
 		old, ok := s.existing[ev.rec.path]
 
 		switch {
-		case !ok || old.size != ev.rec.size || old.mtime < ev.rec.mtime:
+		case !ok || old.size != ev.rec.size || mtimeAfter(ev.rec.mtime, old.mtime):
 			changed = append(changed, ev.rec)
 		case old.hashed:
 			delete(s.existing, ev.rec.path)
@@ -807,7 +808,7 @@ func unchangedFile(r scanRec) (fileRec, bool, error) {
 	}
 
 	if !fi.Mode().IsRegular() || fi.Size() != r.size ||
-		fi.ModTime().Unix() > r.mtime {
+		mtimeAfter(fi.ModTime(), r.mtime) {
 		return fileRec{}, false, nil
 	}
 
@@ -818,6 +819,16 @@ func unchangedFile(r scanRec) (fileRec, bool, error) {
 	}, true, nil
 }
 
+// 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 {
@@ -966,7 +977,7 @@ func seedRoot(ctx context.Context, root string,
 	sendEvent(ctx, events, walkEvent{rec: fileRec{
 		path:  root,
 		size:  fi.Size(),
-		mtime: fi.ModTime().Unix(),
+		mtime: fi.ModTime(),
 		dev:   dev,
 		ino:   ino,
 	}})
@@ -1124,7 +1135,7 @@ func emitFile(ctx context.Context, p string, e fs.DirEntry,
 	sendEvent(ctx, events, walkEvent{rec: fileRec{
 		path:  p,
 		size:  info.Size(),
-		mtime: info.ModTime().Unix(),
+		mtime: info.ModTime(),
 		dev:   dev,
 		ino:   ino,
 	}})

scan_test.go

@@ -20,6 +20,8 @@ import (
 	"syscall"
 	"testing"
 	"time"
+
+	"golang.org/x/sys/unix"
 )
 
 // writeFile creates a file with the given content and returns its path.
@@ -581,6 +583,65 @@ func TestScanContentHashedStalePartners(t *testing.T) {
 	}
 }
 
+// TestScanContentSameSecondRewrite is TestScanContentStalePartners for
+// a stored file rewritten in place at the same size with an mtime later
+// in the same second than recorded: the file counts as changed, so
+// neither it nor its match inside the operand is read.
+func TestScanContentSameSecondRewrite(t *testing.T) {
+	t.Parallel()
+
+	db := openTestDB(t)
+	dirA := t.TempDir()
+	changed := sparseFileWithoutMatch(t, dirA, "changed", headTailMin)
+
+	first := time.Date(2026, 1, 2, 3, 4, 5, 100_000_000, time.UTC)
+
+	err := os.Chtimes(changed, first, first)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	syncTree(t, db, dirA)
+
+	before := dbRecords(t, db)
+
+	// Rewrite one byte in place, keeping the size.
+	pokeAt(t, changed, headTailMin/2, []byte{1})
+
+	later := first.Add(500 * time.Millisecond)
+
+	err = os.Chtimes(changed, later, later)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dirB := t.TempDir()
+	sparseFile(t, dirB, "changed-copy", headTailMin)
+
+	st := syncTree(t, db, dirB)
+	if st != (scanStats{walked: 1, added: 1}) {
+		t.Errorf("stats = %+v, want 1 added and nothing skipped", st)
+	}
+
+	recs := dbRecords(t, db)
+	for _, r := range recs {
+		if r.content != "" {
+			t.Errorf("%s: content = %q, want none: its only match is stale",
+				r.path, r.content)
+		}
+	}
+
+	for _, old := range before {
+		if r := recordByPath(t, recs, old.path); r != old {
+			t.Errorf("record = %+v, want it left as %+v", r, old)
+		}
+	}
+
+	if groups := dupeGroups(t, db); len(groups) != 0 {
+		t.Errorf("groups = %+v, want none", groups)
+	}
+}
+
 // TestScanContentReadFailure checks that a failed content read is
 // counted as skipped and leaves the record without a content hash, and
 // that a later scan tries the read again.
@@ -783,8 +844,8 @@ func TestWalk(t *testing.T) {
 			t.Errorf("%s: size = %d, want 1..3", r.path, r.size)
 		}
 
-		if r.mtime <= 0 {
+		if r.mtime.Unix() <= 0 {
-			t.Errorf("%s: mtime = %d, want positive", r.path, r.mtime)
+			t.Errorf("%s: mtime = %v, want after 1970", r.path, r.mtime)
 		}
 	}
 }
@@ -1285,11 +1346,172 @@ func TestSyncScanMtimeBump(t *testing.T) {
 		t.Fatalf("mtime-bump stats = %+v, want 1 updated", st)
 	}
 
-	if r := recordByPath(t, dbRecords(t, db), a); r.mtime != future.Unix() {
+	if r := recordByPath(t, dbRecords(t, db), a); !r.mtime.Equal(future) {
-		t.Fatalf("mtime = %d, want %d", r.mtime, future.Unix())
+		t.Fatalf("mtime = %v, want %v", r.mtime, future)
 	}
 }
 
+// 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,
+	data []byte,
+) {
+	t.Helper()
+
+	r := recordByPath(t, dbRecords(t, db), path)
+	if want := hexSum(data); r.head != want || r.tail != want ||
+		r.content != want {
+		t.Fatalf("head, tail, content = %q, %q, %q, want %q for each",
+			r.head, r.tail, r.content, want)
+	}
+}
+
+// TestSyncScanSameSecondRewrite rewrites a file in place at the same
+// size with an mtime later in the same second as the recorded one: the
+// next scan must notice the change and re-hash the file.
+func TestSyncScanSameSecondRewrite(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	a := writeFile(t, dir, "a.bin", pattern(1, 500))
+
+	// b.bin shares the size of a.bin, so a.bin is hashed.
+	writeFile(t, dir, "b.bin", pattern(2, 500))
+
+	first := time.Date(2026, 1, 2, 3, 4, 5, 100_000_000, time.UTC)
+
+	err := os.Chtimes(a, first, first)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	syncTree(t, db, dir)
+
+	rewritten := pattern(3, 500)
+	writeFile(t, dir, "a.bin", rewritten)
+
+	later := first.Add(500 * time.Millisecond)
+
+	err = os.Chtimes(a, later, later)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	st := syncTree(t, db, dir)
+	if st != (scanStats{walked: 2, updated: 1, unchanged: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 updated 1 unchanged", st)
+	}
+
+	assertWholeFileHashed(t, db, a, rewritten)
+}
+
+// TestSyncScanOperandSameSecondRewrite is TestSyncScanSameSecondRewrite
+// for files given to scan as operands, which scan stats without reading
+// their directory.
+func TestSyncScanOperandSameSecondRewrite(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	a := writeFile(t, dir, "a.bin", pattern(1, 500))
+
+	// b.bin shares the size of a.bin, so a.bin is hashed.
+	b := writeFile(t, dir, "b.bin", pattern(2, 500))
+
+	first := time.Date(2026, 1, 2, 3, 4, 5, 100_000_000, time.UTC)
+
+	err := os.Chtimes(a, first, first)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	syncTree(t, db, a, b)
+
+	rewritten := pattern(3, 500)
+	writeFile(t, dir, "a.bin", rewritten)
+
+	later := first.Add(500 * time.Millisecond)
+
+	err = os.Chtimes(a, later, later)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	st := syncTree(t, db, a, b)
+	if st != (scanStats{walked: 2, updated: 1, unchanged: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 updated 1 unchanged", st)
+	}
+
+	assertWholeFileHashed(t, db, a, rewritten)
+}
+
+// TestSyncScanRewriteAfter2262 runs assertLateRewriteRehashed with an
+// mtime after 2262, a time too late to count in nanoseconds in an int64.
+func TestSyncScanRewriteAfter2262(t *testing.T) {
+	t.Parallel()
+
+	assertLateRewriteRehashed(t, time.Date(2300, 1, 2, 3, 4, 5, 0, time.UTC))
+}
+
+// TestSyncScanRewritePastTimeLimit runs assertLateRewriteRehashed with an
+// mtime one second past the latest a time.Time holds without wrapping it
+// to a time far in the past.
+func TestSyncScanRewritePastTimeLimit(t *testing.T) {
+	t.Parallel()
+
+	assertLateRewriteRehashed(t, time.Unix(9223371974719179008, 0))
+}
+
+// assertLateRewriteRehashed scans a directory, rewrites a file in it in
+// place at the same size, sets its mtime to late, and fails unless the
+// next scan re-hashes the file. It skips where late does not fit the
+// platform's timespec or the filesystem does not store it.
+func assertLateRewriteRehashed(t *testing.T, late time.Time) {
+	t.Helper()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	a := writeFile(t, dir, "a.bin", pattern(1, 500))
+
+	// b.bin shares the size of a.bin, so a.bin is hashed.
+	writeFile(t, dir, "b.bin", pattern(2, 500))
+
+	syncTree(t, db, dir)
+
+	rewritten := pattern(3, 500)
+	writeFile(t, dir, "a.bin", rewritten)
+
+	// os.Chtimes cannot set such a time: it converts through UnixNano.
+	ts, err := unix.TimeToTimespec(late)
+	if err != nil {
+		t.Skipf("an mtime %d seconds after 1970 does not fit this platform's "+
+			"timespec: %v", late.Unix(), err)
+	}
+
+	err = unix.UtimesNano(a, []unix.Timespec{ts, ts})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fi, err := os.Lstat(a)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if fi.ModTime().Unix() != late.Unix() {
+		t.Skipf("the filesystem stored the mtime as %d seconds after 1970, "+
+			"not %d", fi.ModTime().Unix(), late.Unix())
+	}
+
+	st := syncTree(t, db, dir)
+	if st != (scanStats{walked: 2, updated: 1, unchanged: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 updated 1 unchanged", st)
+	}
+
+	assertWholeFileHashed(t, db, a, rewritten)
+}
+
 func TestSyncScanAddRemove(t *testing.T) {
 	t.Parallel()
 
@@ -1335,9 +1557,7 @@ func TestSyncScanSizeChange(t *testing.T) {
 
 	writeFile(t, dir, "f", pattern(1, 200))
 
-	mt := time.Unix(old.mtime, 0)
+	err := os.Chtimes(p, old.mtime, old.mtime)
-
-	err := os.Chtimes(p, mt, mt)
 	if err != nil {
 		t.Fatal(err)
 	}

script/bootstrap

@@ -2,17 +2,21 @@
 # script/bootstrap: install all dependencies needed to build and develop
 # this repo. Idempotent: every install is guarded by a check so already
 # installed tools are skipped. Base tooling comes from nix, apt, brew,
-# or apk (detected in that order); assumes nothing is present (not git,
+# or apk (detected in that order); assumes nothing is present. Node is
-# make, or go). Neither the linter nor the Markdown formatter is
+# used directly if installed; otherwise it is installed at a pinned
-# installed: golangci-lint (script/lint) and prettier (script/fmt,
+# version via nvm (installing nvm itself first, from a hash-verified
-# script/fmt-check) run via docker only, pinned by hash, so their only
+# release archive, never curl | sh).
-# prerequisite is a working docker — which is warned about, not
-# installed, because everything except linting, formatting and
-# make test-race works without it.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
+# Pinned versions, 2026-07-06
+NODE_VERSION="22.17.0"
+NVM_VERSION="0.40.3"
+# sha256 of https://github.com/nvm-sh/nvm/archive/refs/tags/v0.40.3.tar.gz
+NVM_SHA256="5f4d6aaa04a177dc93c985e31dbc411ab6b8c6e1e21d8015dbc1372625fcd1d0"
+YARN_VERSION="1.22.22"
+
 PKGMGR=""
 SUDO=""
 APT_UPDATED=""
@@ -45,6 +49,7 @@ pkg_install() {
     case "$PKGMGR" in
         nix) nix-env -iA "nixpkgs.$1" ;;
         apt)
+            # Package lists may be empty (fresh images); refresh once per run.
             if [ -z "$APT_UPDATED" ]; then
                 $SUDO env DEBIAN_FRONTEND=noninteractive apt-get update
                 APT_UPDATED=1
@@ -60,31 +65,82 @@ missing() {
     ! command -v "$1" >/dev/null 2>&1
 }
 
+# verify_sha256 <file> <expected-hash>
+verify_sha256() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        actual="$(sha256sum "$1" | cut -d' ' -f1)"
+    else
+        actual="$(shasum -a 256 "$1" | cut -d' ' -f1)"
+    fi
+    if [ "$actual" != "$2" ]; then
+        echo "bootstrap: sha256 mismatch for $1" >&2
+        echo "  expected: $2" >&2
+        echo "  actual:   $actual" >&2
+        exit 1
+    fi
+}
+
+# nvm is a bash script; run a command in a bash with nvm loaded
+nvm_sh() {
+    bash -c ". \"\$HOME/.nvm/nvm.sh\" && $*"
+}
+
+ensure_nvm() {
+    [ -s "$HOME/.nvm/nvm.sh" ] && return 0
+    # nvm prerequisites; nvm itself requires bash
+    if missing bash; then pkg_install bash bash bash bash; fi
+    if missing curl; then pkg_install curl curl curl curl; fi
+    if missing git; then pkg_install git git git git; fi
+    tmp="$(mktemp -d)"
+    curl -fsSL -o "$tmp/nvm.tar.gz" \
+        "https://github.com/nvm-sh/nvm/archive/refs/tags/v${NVM_VERSION}.tar.gz"
+    verify_sha256 "$tmp/nvm.tar.gz" "$NVM_SHA256"
+    mkdir -p "$HOME/.nvm"
+    tar -xzf "$tmp/nvm.tar.gz" -C "$HOME/.nvm" --strip-components=1
+    rm -rf "$tmp"
+}
+
+ensure_node() {
+    if ! missing node; then return 0; fi
+    ensure_nvm
+    nvm_sh "nvm install $NODE_VERSION"
+}
+
+ensure_yarn() {
+    if ! missing yarn; then return 0; fi
+    if ! missing corepack; then
+        corepack enable
+        corepack prepare "yarn@$YARN_VERSION" --activate
+    elif [ -s "$HOME/.nvm/nvm.sh" ]; then
+        nvm_sh "nvm use $NODE_VERSION >/dev/null && corepack enable && \
+            corepack prepare yarn@$YARN_VERSION --activate"
+    else
+        npm install -g "yarn@$YARN_VERSION"
+    fi
+}
+
+install_js_deps() {
+    if missing yarn && [ -s "$HOME/.nvm/nvm.sh" ]; then
+        nvm_sh "nvm use $NODE_VERSION >/dev/null && cd \"$ROOT\" && \
+            yarn install --frozen-lockfile"
+    else
+        yarn install --frozen-lockfile
+    fi
+}
+
 main() {
     cd "$ROOT"
 
-    # System tooling, deliberately unpinned: these come from the host
-    # package manager and whatever version it ships is what the host
-    # gets, so a presence check is the right check. The repo pins no
-    # system toolchain versions — the Go language version is governed by
-    # go.mod, and builds that must be reproducible run in the Docker
-    # image, whose base images are pinned by digest.
-    if missing git; then pkg_install git git git git; fi
     if missing make; then pkg_install gnumake make make make; fi
+    if missing git; then pkg_install git git git git; fi
+    # Go builds the binary and runs gofmt. Presence is the whole check:
+    # go.mod names the Go version, and the tests and the linter run in
+    # digest-pinned images.
     if missing go; then pkg_install go golang go go; fi
 
-    # Linting and Markdown formatting run via docker only, so docker is
+    ensure_node
-    # their prerequisite rather than something bootstrap installs. Warn,
+    ensure_yarn
-    # do not fail: everything except `make lint`, `make fmt`,
+    install_js_deps
-    # `make fmt-check` and `make test-race` — and, through them,
-    # `make check`, `make docker` and the pre-commit hook — works
-    # without it.
-    if missing docker; then
-        echo "bootstrap: WARNING: docker not found; make lint, make fmt," >&2
-        echo "bootstrap: make fmt-check, make check, make docker and" >&2
-        echo "bootstrap: make test-race require it." >&2
-    fi
-
     go mod download
 
     echo "bootstrap complete"

script/check

@@ -1,6 +1,8 @@
 #!/bin/sh
 # script/check: run all checks (test, lint, fmt-check). Our own
-# extension to scripts-to-rule-them-all. Must not modify any files.
+# extension to scripts-to-rule-them-all. test and lint are Docker
+# phases; fmt-check is native, because a formatter writes the working
+# tree. Must not modify any files.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/cibuild

@@ -1,37 +1,30 @@
 #!/bin/sh
-# script/cibuild: run the CI build. The Gitea workflow runs this on
+# script/cibuild: run the CI build. It bootstraps first: a CI runner
-# push.
+# checks out and runs this and nothing else, and script/fmt-check runs
-#
+# the formatter on the host, which a pristine checkout cannot do.
-# The Dockerfile runs the gates individually as build steps, not the
+# --no-cache for the same reason as script/docker: the gate phases the
-# make check aggregate: the lint stage runs the gofmt check,
+# final stage depends on are RUN steps, and a cached one is a check that
-# script/verify-lint-image-pin, golangci-lint config verify and
+# did not run.
-# golangci-lint run; the markdown stage runs the prettier check; the
-# build stage, dropped to an unprivileged user, runs make test. None of
-# make lint, make fmt-check or make check appears, because each runs
-# docker, and docker cannot run inside a docker build. Nothing is
-# skipped by that — the linter, gofmt and prettier are invoked directly
-# in their stages, and the build stage's COPY --from lines make those
-# stages prerequisites, so BuildKit must finish them first. Between the
-# three stages everything make check would run has run, which is why a
-# successful build here implies the repo is green.
-#
-# That implication holds only because of CHECK_EPOCH. A COPY layer is
-# invalidated only by changed content, and a rebuild of an unchanged
-# checkout sends the same content, so without a fresh value here Docker
-# serves the gate layers from cache and the build reports a green it
-# never earned. Passing the current epoch invalidates the gate
-# layers on every run while leaving the pinned base images and
-# go mod download cached; see the Dockerfile for the placement. The
-# process id goes in with the epoch so that two runs started in the
-# same second still get different values, the same form script/lint
-# uses.
 set -eu
 
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    docker build --build-arg CHECK_EPOCH="$(date +%s)-$$" .
+    "$SCRIPT_DIR/bootstrap"
+    "$SCRIPT_DIR/check"
+    # The version and the tag each get their own line: a failing
+    # command substitution inside an argument does not trip `set -e`,
+    # so the inline form degrades silently to an empty constant. The
+    # VERSION build argument takes precedence over the version a build
+    # stage derives from the .git in the context.
+    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
+    [ -n "$version" ] || version="unknown"
+    tag="$("$SCRIPT_DIR/projectname")"
+    docker build --no-cache \
+        --build-arg VERSION="$version" \
+        -t "$tag" .
 }
 
 main "$@"

script/docker

@@ -1,14 +1,8 @@
 #!/bin/sh
 # script/docker: build the Docker image tagged with the project name.
-# The tag comes from script/projectname.
+# Identical in all repos; the tag comes from script/projectname.
-#
+# --no-cache because the gate phases the final stage depends on are RUN
-# CHECK_EPOCH is passed for the same reason script/cibuild passes it:
+# steps, and a cached one is a check that did not run.
-# without a fresh value Docker serves the gate layers from cache on an
-# unchanged tree and this exits 0 having run none of the lint stage's
-# gates, the markdown stage's prettier gate or the builder stage's test
-# gate. This is the set of gates a developer or reviewer runs by hand,
-# so a cached pass here is the most misleading result the repo can
-# produce. Dependency layers sit above the ARG and stay cached.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -16,10 +10,17 @@ ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    docker build \
+    # The version and the tag each get their own line: a failing
-        --build-arg CHECK_EPOCH="$(date +%s)-$$" \
+    # command substitution inside an argument does not trip `set -e`,
-        -t "$("$SCRIPT_DIR/projectname")" \
+    # so the inline form degrades silently to an empty constant. The
-        .
+    # VERSION build argument takes precedence over the version a build
+    # stage derives from the .git in the context.
+    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
+    [ -n "$version" ] || version="unknown"
+    tag="$("$SCRIPT_DIR/projectname")"
+    docker build --no-cache \
+        --build-arg VERSION="$version" \
+        -t "$tag" .
 }
 
 main "$@"

script/fmt

@@ -1,22 +1,32 @@
 #!/bin/sh
-# script/fmt: format all files (writes): the Go sources with gofmt, the
+# script/fmt: format all files (writes).
-# Markdown with prettier. prettier is never installed on the host: it
-# runs from the Dockerfile's prettier stage with the repository mounted,
-# as the calling user so the files it rewrites keep their owner. The tag
-# makes each build replace the previous image instead of leaving another
-# one behind.
 set -eu
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+
+# Must match the pin in script/bootstrap.
+NODE_VERSION="22.17.0"
+
+# script/bootstrap installs node and yarn under nvm and leaves neither
+# on the PATH of the shell that called it, so resolve the pinned
+# toolchain here the way bootstrap's own install step does. nvm is a
+# bash script, hence the subshell.
+run_yarn() {
+    if command -v yarn >/dev/null 2>&1; then
+        exec yarn "$@"
+    fi
+    if [ ! -s "$HOME/.nvm/nvm.sh" ]; then
+        echo "fmt: no yarn; run script/bootstrap first" >&2
+        exit 1
+    fi
+    exec bash -c '. "$HOME/.nvm/nvm.sh" && nvm use "$1" >/dev/null &&
+        shift && exec yarn "$@"' bash "$NODE_VERSION" "$@"
+}
 
 main() {
     cd "$ROOT"
     gofmt -s -w .
-    image="$("$SCRIPT_DIR/projectname")-prettier"
+    run_yarn run prettier --write '**/*.md' --tab-width 4 --prose-wrap always
-    docker build -q --target prettier -t "$image" . >/dev/null
-    docker run --rm --user "$(id -u):$(id -g)" -v "$ROOT:/src" "$image" \
-        prettier --write '**/*.md' --tab-width 4 --prose-wrap always
 }
 
 main "$@"

script/fmt-check

@@ -1,19 +1,35 @@
 #!/bin/sh
-# script/fmt-check: check formatting (read-only). Same scope as
+# script/fmt-check: check formatting (read-only).
-# script/fmt, but fails instead of writing. gofmt and prettier both run
-# every time and each reports its own failure, so the output says which
-# one failed.
 set -eu
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+
+# Must match the pin in script/bootstrap.
+NODE_VERSION="22.17.0"
+
+# script/bootstrap installs node and yarn under nvm and leaves neither
+# on the PATH of the shell that called it, so resolve the pinned
+# toolchain here the way bootstrap's own install step does. nvm is a
+# bash script, hence the subshell.
+run_yarn() {
+    if command -v yarn >/dev/null 2>&1; then
+        exec yarn "$@"
+    fi
+    if [ ! -s "$HOME/.nvm/nvm.sh" ]; then
+        echo "fmt-check: no yarn; run script/bootstrap first" >&2
+        exit 1
+    fi
+    exec bash -c '. "$HOME/.nvm/nvm.sh" && nvm use "$1" >/dev/null &&
+        shift && exec yarn "$@"' bash "$NODE_VERSION" "$@"
+}
 
 main() {
     cd "$ROOT"
     status=0
 
-    # Under set -e a bare assignment would end the script when gofmt
+    # gofmt and prettier both run every time, so the output names each
-    # fails (a Go file it cannot parse), and prettier would never run.
+    # one that fails. Under set -e a bare assignment would end the
+    # script when gofmt fails (a Go file it cannot parse).
     if ! files="$(gofmt -s -l .)"; then
         echo "gofmt: failed; see its errors above" >&2
         status=1
@@ -24,14 +40,9 @@ main() {
         status=1
     fi
 
-    # Same image as script/fmt; see there.
+    # run_yarn ends in exec; the subshell returns here afterwards.
-    image="$("$SCRIPT_DIR/projectname")-prettier"
+    (run_yarn run prettier --check '**/*.md' --tab-width 4 --prose-wrap always) ||
-    docker build -q --target prettier -t "$image" . >/dev/null
-    if ! docker run --rm -v "$ROOT:/src:ro" "$image" \
-        prettier --check '**/*.md' --tab-width 4 --prose-wrap always; then
-        echo "prettier: Markdown not formatted; run make fmt" >&2
         status=1
-    fi
 
     exit "$status"
 }

script/install-precommit

@@ -1,19 +1,15 @@
 #!/bin/sh
 # script/install-precommit: install the git pre-commit hook that runs
 # script/precommit. Our own extension to scripts-to-rule-them-all.
-# Hooks are shared between the main checkout and all worktrees, so
-# resolve the common git dir instead of assuming .git is a directory.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    hooks_dir="$(git rev-parse --git-common-dir)/hooks"
+    hook=".git/hooks/pre-commit"
-    mkdir -p "$hooks_dir"
+    printf '#!/bin/sh\nset -e\nscript/precommit\n' > .git/hooks/pre-commit
-    hook="$hooks_dir/pre-commit"
+    chmod +x .git/hooks/pre-commit
-    printf '#!/bin/sh\nset -e\nscript/precommit\n' > "$hook"
-    chmod +x "$hook"
     echo "pre-commit hook installed: runs script/precommit"
 }
 

script/lint

@@ -1,34 +1,23 @@
 #!/bin/sh
-# script/lint: run the linter. golangci-lint is never installed on a
+# script/lint: run the linter. Linting is a phase of the Dockerfile and
-# host: it runs via docker only, one way, everywhere — this builds
+# this builds that phase alone; the linter is never installed or run on
-# Dockerfile.lint, which COPYs the repo into the digest-pinned
+# a developer host, where a shared result cache and a host-global lock
-# golangci-lint image and lints as a build step, so a successful build
+# make its answer untrustworthy.
-# is a clean lint. The only prerequisite is a working docker. The gate
-# steps make no network calls of their own, but Dockerfile.lint runs
-# `go mod download` above them, so a cold cache does reach the network
-# (as does pulling the pinned image); that layer stays cached, and once
-# it is warm this runs offline until go.mod or go.sum changes.
 #
-# CHECK_EPOCH is what makes the result mean anything. Without it docker
+# The phase is not the last stage in the file, so it is built only when
-# serves the gate layers from cache on an unchanged tree and this exits
+# --target names it. --no-cache because a cached lint layer is a lint
-# 0 in well under a second having run no linter. The PID is in the value
+# that did not run. --output type=cacheonly writes no image, since
-# as well as the epoch because two lint runs land inside the same second
+# nothing uses one.
-# easily, and `date +%s` alone would cache the second one.
-#
-# The result is the build's exit status and the image is never used, so
-# --output=type=cacheonly writes none. Without it every run spends
-# seconds exporting an image and leaves it behind untagged.
 set -eu
 
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    docker build \
+    docker build --no-cache \
-        --build-arg CHECK_EPOCH="$(date +%s)-$$" \
+        --target lint \
-        --output=type=cacheonly \
+        --output type=cacheonly .
-        -f Dockerfile.lint \
-        .
 }
 
 main "$@"

script/precommit

@@ -1,13 +1,13 @@
 #!/bin/sh
 # script/precommit: run by the git pre-commit hook; fails the commit if
-# checks fail. Our own extension to scripts-to-rule-them-all. Go extra:
+# checks fail. Our own extension to scripts-to-rule-them-all.
-# go mod tidy must be a no-op before the checks run.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
+    # Go extra: go mod tidy must be a no-op before the checks run.
     cd "$ROOT"
     go mod tidy
     if ! git diff --exit-code -- go.mod go.sum; then

script/setup

@@ -1,6 +1,6 @@
 #!/bin/sh
 # script/setup: set up the repo for development after a fresh clone:
-# installs dependencies (script/bootstrap) and the git pre-commit hook.
+# installs dependencies and the git pre-commit hook.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/test

@@ -1,17 +1,19 @@
 #!/bin/sh
-# script/test: run the test suite. Reruns verbosely on failure so CI
+# script/test: run the test suite. Testing is a phase of the Dockerfile
-# logs show which test failed.
+# and this builds that phase alone, on the same terms as script/lint:
+# --target because a phase that is not the last stage is built only when
+# named, and --no-cache because a cached test layer is a test that did
+# not run. --output type=cacheonly writes no image, since nothing uses one.
 set -eu
 
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    go test -timeout 30s -cover ./... || {
+    docker build --no-cache \
-        echo "--- Rerunning with -v for details ---"
+        --target test \
-        go test -timeout 30s -v ./...
+        --output type=cacheonly .
-        exit 1
-    }
 }
 
 main "$@"

script/test-race

@@ -1,40 +0,0 @@
-#!/bin/sh
-# script/test-race: run the test suite under the race detector. Not part
-# of script/check.
-#
-# The race detector needs cgo and a C compiler, which the host build
-# never uses, so the tests run in a golang image that has gcc. The
-# checkout is mounted read-only, so the docker daemon must be local. The
-# container starts with empty caches every time: each run downloads the
-# dependencies and compiles them with the detector, which needs the
-# network and takes minutes.
-#
-# The tests run as the calling user, never as root: several of them make
-# a file unreadable and expect reading it to fail, and root reads it
-# anyway. When the caller is root they run as nobody, and then the
-# checkout must be readable by other users. Neither user has a home
-# directory in the image, so HOME is /tmp, where Go puts its build cache.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-# golang:1.25-trixie, 2026-10-04. Debian rather than the Alpine image the
-# Dockerfile builds with, because this one includes gcc.
-IMAGE="golang@sha256:2c4c60ef415fbfa5e90300722293bef36c5e63fae17570ce18f580af933dbd73"
-
-main() {
-    user="$(id -u):$(id -g)"
-    if [ "$(id -u)" -eq 0 ]; then
-        user=65534:65534
-    fi
-    docker run --rm \
-        --user "$user" \
-        --env HOME=/tmp \
-        --env CGO_ENABLED=1 \
-        --volume "$ROOT:/src:ro" \
-        --workdir /src \
-        "$IMAGE" \
-        go test -race -timeout 60s ./...
-}
-
-main "$@"

script/verify-lint-image-pin

@@ -1,84 +0,0 @@
-#!/bin/sh
-# script/verify-lint-image-pin: fail unless the golangci-lint image
-# referenced by Dockerfile.lint and the one referenced by the main
-# Dockerfile's lint stage are the same image at the same digest. Our own
-# extension to scripts-to-rule-them-all, not one of its entrypoints.
-#
-# The linter version is pinned in two independent files. That is the
-# shape #42 turned into a build failure rather than tolerate: nothing
-# else keeps the two in sync, and a bump applied to one file alone would
-# leave `make lint` and the fail-fast lint stage of `make docker`
-# linting the same tree against different rulesets, both green. This is
-# the single guard that stops it, run as a gate in both files.
-#
-# It deliberately restates neither pin. A hardcoded expected digest here
-# would be a third copy — one more thing to bump, and the same drift one
-# file further out. It compares the two files to each other and knows
-# nothing about which version is correct.
-#
-# A reference that cannot be read is a hard failure, not a skip: a
-# comparison of two empty strings succeeds, which would turn this guard
-# into exactly the unearned green it exists to prevent.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-LINT_DOCKERFILE="Dockerfile.lint"
-MAIN_DOCKERFILE="Dockerfile"
-
-# Echo the single golangci-lint image reference in the named Dockerfile.
-# Scans every argument of every FROM instruction rather than assuming a
-# field position, so `FROM --platform=... img AS stage` reads correctly.
-# Exits non-zero, with a diagnosis, unless there is exactly one.
-lint_image_ref() {
-    file="$1"
-
-    if [ ! -f "$file" ]; then
-        echo "verify-lint-image-pin: $file: not found" >&2
-        return 1
-    fi
-
-    refs="$(
-        awk '
-            toupper($1) == "FROM" {
-                for (i = 2; i <= NF; i++) {
-                    if ($i ~ /^golangci\/golangci-lint[:@]/) {
-                        print $i
-                    }
-                }
-            }
-        ' "$file"
-    )"
-
-    count="$(printf '%s' "$refs" | grep -c . || true)"
-    if [ "$count" -ne 1 ]; then
-        echo "verify-lint-image-pin: $file: expected exactly one" \
-            "golangci/golangci-lint FROM reference, found $count" >&2
-        return 1
-    fi
-
-    printf '%s\n' "$refs"
-}
-
-main() {
-    cd "$ROOT"
-
-    lint_ref="$(lint_image_ref "$LINT_DOCKERFILE")"
-    main_ref="$(lint_image_ref "$MAIN_DOCKERFILE")"
-
-    if [ "$lint_ref" != "$main_ref" ]; then
-        echo "verify-lint-image-pin: the linter image is pinned twice and" \
-            "the two pins disagree:" >&2
-        echo "verify-lint-image-pin:   $LINT_DOCKERFILE: $lint_ref" >&2
-        echo "verify-lint-image-pin:   $MAIN_DOCKERFILE: $main_ref" >&2
-        echo "verify-lint-image-pin: bump both FROM lines together so" \
-            "script/lint and the Dockerfile lint stage keep running the" \
-            "same linter" >&2
-        exit 1
-    fi
-
-    echo "verify-lint-image-pin: $LINT_DOCKERFILE and $MAIN_DOCKERFILE" \
-        "agree on $lint_ref"
-}
-
-main "$@"