Run all linting in Docker via Dockerfile.lint (closes #46)

Per the owner ruling, the linter runs inside a container invoked
through the script/ entrypoint and is never installed on a host. A new
root Dockerfile.lint COPYs the repo into the digest-pinned
golangci/golangci-lint:v2.12.2 image and runs `golangci-lint config
verify` and `golangci-lint run` as build steps, so a successful build
IS a clean lint. script/lint is reduced to building it, which also
works when the docker daemon is remote and bind mounts are impossible.

script/bootstrap loses the `go install`, the pin constants, the
version parser and verify_golangci_lint outright rather than being
hardened: with nothing linting on the host, the $GOPATH/bin versus
PATH shadowing problem those existed to diagnose has no subject. It
keeps the git/make/go presence checks and `go mod download`, and warns
rather than fails when docker is absent.

Two traps.

A lint build on an unchanged tree returns success in well under a
second having run no linter, which is #32 and #39 over again. Caching
is waived by ruling, so Dockerfile.lint carries ARG CHECK_EPOCH
referenced inside every gate RUN -- BuildKit hashes the expanded
command, not the declaration, so a declared but unreferenced ARG
invalidates nothing -- and script/lint passes "$(date +%s)-$$". The
PID is in that value because two lint runs land inside the same second
easily and a bare epoch would cache the second one.

Nothing inside an image build may shell out to docker. The main
Dockerfile's lint stage therefore 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, which reaches
script/lint. Those two remain `make` invocations rather than the bare
scripts because the Makefile's `export CGO_ENABLED = 0` only applies
to what it invokes, and today's `make check` gets it.

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;
dropping it without replacing the edge would have ended fail-fast
linting silently under a still-green build. That no-op copy is the
ordering edge canonical REPO_POLICIES.md prescribes. Nothing in the
build stage runs the linter any more, so the binary itself is not
wanted there, and ENV PATH=/home/builder/go/bin:$PATH goes 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 this 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 #42 made a
build failure. Its replacement is one new script/verify-lint-image-pin
that compares those two references to each other and deliberately
restates neither pin: a hardcoded expected digest would be a third
copy and the same drift one file further out. It runs as a gate in
both files, so `make lint`, `make check` and `make docker` all catch
drift, and an unreadable reference is a hard failure rather than a
vacuous pass.

`golangci-lint config verify` is included per the ruling. 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 against a schema it embeds and linting needs no network
beyond pulling the image. The README states that rather than a
requirement that does not exist.

Verified. `make lint` green with every PATH directory containing a
golangci-lint removed and `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. A planted unused variable failed
script/lint with that exact finding and failed `make docker` at the
lint stage with the build stage stopped before its COPY --from=lint,
then reverted clean. The drift guard fails on tag-only, digest-only
and unreadable-reference cases, naming both sides. `make check` green;
`make docker` green in 5m35s with all six gates executing and the test
gate reporting real coverage rather than a cached ok. In the builder
image with the Go test cache off, --user 0:0 still fails
TestScanHardlinkRunFailsTogether where the unprivileged user passes,
so the non-root quirk is intact.

Dockerfile

@@ -1,6 +1,6 @@
 # Lint stage — fast feedback on formatting and lint issues
-# golangci/golangci-lint:v2.12.2, 2026-08-07
-FROM golangci/golangci-lint@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS lint
+# golangci/golangci-lint:v2.12.2 (Debian-based), 2026-08-07
+FROM golangci/golangci-lint:v2.12.2@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS lint
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download

Dockerfile.lint

@@ -9,8 +9,8 @@
 # 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
+# golangci/golangci-lint:v2.12.2 (Debian-based), 2026-08-07
+FROM golangci/golangci-lint:v2.12.2@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240
 
 WORKDIR /src
 
@@ -46,12 +46,8 @@ RUN echo "gate lint-image-pin, epoch ${CHECK_EPOCH}" && \
 # 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.
+# an invalid one with the jsonschema error. Linting therefore needs no
+# network beyond pulling the pinned image.
 RUN echo "gate config verify, epoch ${CHECK_EPOCH}" && \
     golangci-lint config verify --config .golangci.yml
 

README.md

@@ -475,21 +475,13 @@ and may be invoked directly. The provided entrypoints are:
     steps, so a successful build is a clean lint. 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.
+    pre-commit hook. Once the pinned image is local, nothing here
+    needs the network: the config-schema validation used by
+    `config verify` comes from a schema the pinned binary embeds, and
+    was measured under `--network none` to both pass a valid config
+    and reject an invalid one. 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 the Go sources in place (`gofmt -s -w`).
     Markdown is not formatted.
 -   `script/fmt-check` — the read-only counterpart of `script/fmt`:

TODO.md

@@ -29,18 +29,6 @@
 
 # Completed Steps
 
-- 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
-  `(Debian-based)` parenthetical (v2.12.1 was Debian too) and the
-  redundant tag, so both pins are the policy `# image:vX.Y.Z,
-  YYYY-MM-DD` comment over a bare `FROM image@sha256:...`. Digest
-  unchanged. `script/verify-lint-image-pin` parses those `FROM` lines
-  and still matches the tagless form; its advice line lost the now
-  meaningless "tag and digest". With no tag in either reference, a
-  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
@@ -94,11 +82,9 @@
   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`
+  error, so it validates from an embedded schema and linting needs no
+  network; the README says so instead of claiming a requirement that
+  does not exist. 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

script/cibuild

@@ -1,19 +1,8 @@
 #!/bin/sh
-# script/cibuild: run the CI build. The Gitea workflow runs this on
-# push.
-#
-# The Dockerfile runs the gates individually as build steps, not the
-# make check aggregate: the lint stage runs make fmt-check,
-# script/verify-lint-image-pin, golangci-lint config verify and
-# golangci-lint run; the build stage, dropped to an unprivileged user,
-# runs make test and make fmt-check. Neither make lint nor make check
-# appears, because both reach script/lint, which is itself a docker
-# build, and a docker build cannot run inside one. Lint is not skipped
-# by that — the linter is invoked directly in the lint stage, and the
-# build stage's COPY --from=lint makes that stage a prerequisite, so
-# BuildKit must finish it first. Between the two stages everything
-# make check would run has run, which is why a successful build here
-# implies the repo is green.
+# script/cibuild: run the CI build. The Dockerfile runs make fmt-check,
+# make lint and make check (via the script/ entrypoints) as build steps,
+# so a successful build implies all checks pass. The Gitea workflow runs
+# this on push.
 #
 # That implication holds only because of CHECK_EPOCH. A COPY layer is
 # invalidated by changed content, and a merge commit's tree is

script/docker

@@ -4,11 +4,11 @@
 #
 # CHECK_EPOCH is passed for the same reason script/cibuild passes it:
 # without it Docker serves the Dockerfile's gate layers from cache on an
-# unchanged tree and this exits 0 having run neither the lint stage's
-# gates nor the builder stage's test and fmt-check gates. 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.
+# unchanged tree and this exits 0 having run neither the lint stage nor
+# the builder stage's make check. This is the gate 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)"

script/lint

@@ -3,11 +3,8 @@
 # host: it runs via docker only, one way, everywhere — this builds
 # Dockerfile.lint, which COPYs the repo into the digest-pinned
 # golangci-lint image and lints as a build step, so a successful build
-# 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.
+# is a clean lint. The only prerequisite is a working docker; once the
+# pinned image is present nothing here reaches the network.
 #
 # CHECK_EPOCH is what makes the result mean anything. Without it docker
 # serves the gate layers from cache on an unchanged tree and this exits

script/verify-lint-image-pin

@@ -71,9 +71,9 @@ main() {
             "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
+        echo "verify-lint-image-pin: bump both FROM lines together, tag and" \
+            "digest, so script/lint and the Dockerfile lint stage keep" \
+            "running the same linter" >&2
         exit 1
     fi