Add -count=1 to the canonical Go make test example (closes #44 )

The canonical Go `test` target in `REPO_POLICIES.md` omitted `-count=1`, so Go replayed cached successful results and the target could exit 0 having executed no test. Every repo that copied it inherited the false green. Both invocations get the flag; the rerun needs it so a failure is reproduced rather than replayed.
2026-08-10 13:51:34 +00:00
12 changed files with 60 additions and 1170 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,97 +1,3 @@
 # Docker matches this file with moby/patternmatcher: Go filepath.Match
 # semantics plus a `**` extension, compiled to a regexp. Plain
 # filepath.Match has no `**` at all. What follows from that: `*` does not
 # cross `/`, and a pattern without a leading `**/` is anchored at the
 # build-context root. Every depth-independent pattern therefore needs the
 # `**/` prefix — without it `config/.env` and `certs/server.key` still
 # ship while the file reads as solved.
 #
 # Root-anchored entries are for paths that occur exactly once, at the
 # context root. A host-built binary is the usual case, and it must be
 # written anchored: `/myapp`, never `**/myapp`. The prefixed form also
 # matches `cmd/myapp/`, which deletes the package directory from the
 # context. In-repo agent scratch is the other case, for the same reason
 # — with the caveat recorded at that entry: anchoring is exact only
 # where agents run at the repo root, and a repo where they do not must
 # add its own entries.
 #
 # Matching is case-sensitive, so `**/*.key` does not match
 # `certs/SERVER.KEY`, which is reachable on the case-insensitive
 # filesystems most laptops use. Adding an ALL-CAPS twin per pattern is
 # not the fix: it still misses `Server.Key` while reading as though case
 # were handled. Character ranges cover every spelling in one line, so
 # every secret name below is written that way — including the
 # extensionless SSH keys and `.envrc`, because on those same
 # case-insensitive filesystems direnv reads `.ENVRC` and ssh reads
 # `ID_RSA`.
 #
 # `**/*.[eE][nN][vV]` also excludes a committed env template such as
 # `example.env`. If the build genuinely needs one, re-include it with a
 # negation after the pattern: `!docs/example.env`.
 #
 # Extend this file with the repo's own host-built artifacts (compiled
 # binaries, test binaries, coverage output); those are per-repo and
 # belong here because a host build otherwise drops them into the
 # context.
 # Repository metadata: exactly one, at the context root. Excluding it
 # means `git describe` cannot run in any build stage, and it fails
 # quietly there rather than erroring, so a version embedded that way
 # comes out empty. Compute the version on the host and pass it in with
 # `--build-arg VERSION=...`; see the version rule in REPO_POLICIES.md.
 .git
-
+node_modules
-# In-repo agent scratch: a directory holding a full additional checkout
+.DS_Store
 # of the repo for each in-flight agent. Anchored because it occurs
 # exactly once *where agents run at the repo root*, which is the
 # convention this file assumes; the `**/` form would also match any
 # nested directory of that name and delete it from the build.
 #
 # KNOWN GAP, and it is not hypothetical: the directory is created in the
 # agent's working directory. If agents in this repo run in
 # subdirectories — a monorepo with a per-service agent, say — then
 # `services/api/.claude/` is NOT excluded by the line below and still
 # reaches the build context and the image, which is the exposure this
 # entry exists to close. A repo in that shape adds its own anchored
 # entries (`/services/api/.claude`), or `**/.claude` after confirming no
 # legitimately named nested directory would be caught.
 #
 # Not case-folded, unlike the secret patterns below: tooling creates
 # this directory in exactly one spelling, so a folded pattern would add
 # no coverage.
 .claude
 # Environment files. `*.env` covers both the bare `.env` name (`*` matches
 # the empty string) and the `prod.env` convention.
 **/*.[eE][nN][vV]
 **/.[eE][nN][vV].*
 **/.[eE][nN][vV][rR][cC]
 # Private keys and the bundles that carry them. Public certificates
 # (*.crt, *.cer) are deliberately absent: they are not secrets and are
 # sometimes a legitimate build input.
 **/*.[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][dD]25519
 # 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 under a developer's
 # hands, so it invalidates COPY for reasons unrelated to the source.
 **/*.swp
 **/*.swo
 **/*~
 **/*.bak
 **/.idea
 **/.vscode
 **/*.sublime-*
--- a/.gitignore
+++ b/.gitignore
@@ -11,12 +11,6 @@ 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/
--- a/15
+++ b/15
@@ -12,17 +12,4 @@ COPY package.json yarn.lock ./
 RUN script/bootstrap
 COPY . .
-
+RUN make check
 # CHECK_EPOCH is a per-invocation nonce supplied by script/cibuild and
 # script/docker. Without it an unchanged tree serves this layer from
 # cache and the build reports a green it never ran. ARG is stage-scoped,
 # so it must be redeclared in every stage that runs checks. The guard
 # makes a bare `docker build .` fail loudly instead of silently reusing
 # the empty (and therefore stable) cache key. Expand the value into the
 # command so the cache miss does not depend on BuildKit's handling of an
 # unreferenced ARG. Both the guard and the check RUN reference the value,
 # so both are value-keyed: there are two independent invalidation points
 # here, not one. Keep both.
 ARG CHECK_EPOCH
 RUN [ -n "$CHECK_EPOCH" ] || exit 1
 RUN echo "check epoch: ${CHECK_EPOCH}" && make check
--- a/README.md
+++ b/README.md
@@ -123,13 +123,9 @@ alpine. We provide:
 - `script/check` — run all checks: `test`, `lint`, `fmt-check` (our own
  extension)
 - `script/docker` — build the Docker image, tagged via `script/projectname`
-  (byte-identical across repos); passes the same `CHECK_EPOCH` nonce as
+  (byte-identical across repos)
-  `script/cibuild`
+- `script/cibuild` — cd to the repo root and `docker build .` (what CI runs; the
- `script/cibuild` — cd to the repo root, assign `epoch="$(date +%s%N)$$"`, then
+  image build runs `script/check`)
  `docker build --build-arg CHECK_EPOCH="$epoch" .` (what CI runs; the image
  build runs `script/check`, and the per-invocation `CHECK_EPOCH` nonce is what
  stops Docker serving that check from cache on an unchanged tree — a bare
  `docker build .` fails closed on purpose)
 - `script/precommit` — run by the git pre-commit hook (our own extension); calls
  `script/check`
 - `script/install-precommit` — installs the git pre-commit hook (our own
--- a/TODO.md
+++ b/TODO.md
@@ -21,93 +21,9 @@ fmt-check, and commit.
 # Completed Steps
- 2026-08-09: Made a golangci-lint result belong to the tree that asked for it.
+- 2026-08-10: Added `-count=1` to both `go test` invocations in the canonical Go
-  REPO_POLICIES.md now carries the canonical Go `script/lint`, which gives the
+  `make test` example in `REPO_POLICIES.md`, so the target cannot report a
-  linter per-checkout `GOLANGCI_LINT_CACHE` and per-checkout `TMPDIR`. The two
+  cached pass it did not earn.
  are separate defects and the second is the one that gets dropped: the result
  cache is keyed on file content rather than location, so checkouts holding
  identical files serve each other's findings under the other's path, while the
  concurrency lock is `$TMPDIR/golangci-lint.lock` — host-global, independent of
  the cache, and unaffected by isolating it. Moving workers from worktrees to
  their own clones does not help either half; it only removes the foreign-path
  artefact that made the defect visible. The lock error is retried rather than
  surfaced, because it is not a result: it exits non-zero exactly as findings
  do, and reporting it as findings sends a correct branch back for rework.
  Detection is on the stderr stream and never on exit status, so a finding
  quoting the lock message in source cannot be retried away, and exhaustion
  exits 75 with a VOID message rather than passing or failing quietly.
  `--allow-serial-runners` (which keeps the guard and queues) covers the
  same-checkout overlap that `TMPDIR` scoping cannot; `--allow-parallel-runners`
  is rejected outright. The stdout and stderr capture files are per invocation
  rather than per checkout, because serialising the linter does not serialise
  the shell's redirections: two runs in one checkout — the overlap the flag
  exists to support — would otherwise truncate and read each other's output,
  which is the same defect one layer above where it was fixed. Both checklists
  gained the corresponding items, since a half-fix that sets only the cache
  reads as complete. `GOCACHE` was measured and does not need isolating.
  Verified with the snippet extracted from the committed document and executed
  as a consuming repo would adopt it, against paired controls: contamination
  reproduced on the pre-fix form and absent on the adopted one, retry engaged,
  exhaustion loud, a genuine finding still reported, and a held host lock
  failing the pre-fix script while leaving the adopted one untouched.
 - 2026-08-09: Kept in-repo agent scratch out of the Docker build context and out
  of version control. `.claude/` holds one worktree — an entire additional
  checkout of the repo — per in-flight agent, and under `COPY . .` all of it was
  reaching the image: another session's unreviewed, sometimes uncommitted work,
  inflating the context by a multiple of the repo and invalidating `COPY` for
  reasons unrelated to the repo's own content. The `.dockerignore` entry is
  root-anchored, because the directory occurs exactly once where agents run at
  the repo root and the `**/` form additionally deletes any nested directory of
  that name — with the residual gap that follows from anchoring (a monorepo
  running agents in subdirectories still ships `services/api/.claude/`) stated
  in the canonical `.dockerignore`, the policy and the existing-repo checklist,
  since consuming repos receive the files rather than the tracker; the
  `.gitignore` entry is unanchored, because `.gitignore` patterns already match
  at every depth, and each file is written to its own semantics rather than
  derived from the other. Also closed the consequence that ships broken
  silently: excluding `.git` means `git describe` cannot run in any build stage
  and yields an empty version without erroring, so `script/docker` and
  `script/cibuild` now compute the version on the host and pass
  `--build-arg VERSION`, and `REPO_POLICIES.md` states where `VERSION` comes
  from instead of leaving the reader to fill the gap with `git describe` inside
  the build. The two Go documents that carry the `GOLDFLAGS` pattern were
  corrected in the same pass, from `:=` to `?=`, since a `$(shell git describe)`
  evaluated inside a build stage is exactly the empty version this closes.
  Verified by enumerating a probe image before, after, and against the
  `**/`-prefixed form, with a positive control and the `CHECK_EPOCH` cache
  verification re-run under the changed build context.
 - 2026-08-09: Closed the secret exposure in the canonical `.dockerignore`: a
  developer's local `.env`, `*.pem` or `*.key` was reaching the Docker build
  context under `COPY . .`, invisible to every git-based check because
  `.gitignore` covers it. The patterns are written to `.dockerignore`'s own
  `moby/patternmatcher` semantics — `**/`-prefixed so they hold at every depth,
  which also fixes nested `node_modules` — rather than transplanted from
  `.gitignore`, whose unprefixed form protects only the repository root while
  reading as solved. Coverage extends past the `.env`/`.pem`/`.key` trio to the
  `prod.env` convention, `.envrc`, PKCS#12 bundles and extensionless SSH keys,
  every one of them case-folded with character ranges because matching is
  case-sensitive and an ALL-CAPS twin per pattern still misses `Server.Key`.
  `REPO_POLICIES.md` and both repo checklists now state that asymmetry and
  require verification by enumerating the image rather than by reading the
  patterns. Verified with a probe image before, against three naive forms
  (unprefixed, lowercase-only, ALL-CAPS-doubled), and after.
 - 2026-08-09: Made the pinned golangci-lint actually propagate: REPO_POLICIES.md
  now carries the canonical `script/bootstrap` snippet for Go repos, which
  installs when the installed version does not match the pin (the old
  `if missing` guard tested PATH presence only, so pins were inert on any
  provisioned machine and CI silently disagreed with local) and then re-resolves
  the binary through `PATH` and fails loudly, naming the shadowing path, when
  the install did not take effect — the failure mode the naive
  compare-then-install fix leaves behind while reporting success.
 - 2026-08-09: Fixed the false green in the canonical CI gate: `script/cibuild`
  and `script/docker` now pass a per-invocation `CHECK_EPOCH` nonce, and the
  `Dockerfile` (plus the Go multistage template in REPO_POLICIES.md, in both its
  lint and builder stages) declares `ARG CHECK_EPOCH` with a guard that makes a
  bare `docker build .` fail closed. Corrected the org-canonical text that
  asserted a successful build implies all checks pass, across every document
  carrying it: `REPO_POLICIES.md`, both repo checklists (which still told agents
  to write the pre-fix `script/cibuild` and ended on an acceptance item the
  guard makes unsatisfiable), and the Go styleguide.
 - 2026-08-07: Set the canonical `.golangci.yml` to the org-standard v2-schema
  config already deployed byte-identical across the org's Go repos (settings
  under `linters.settings` so thresholds like lll/funlen/cyclop/dupl actually
--- a/prompts/CODE_STYLEGUIDE_GO.md
+++ b/prompts/CODE_STYLEGUIDE_GO.md
@@ -1,6 +1,6 @@
 ---
 title: Code Styleguide — Go
-last_modified: 2026-08-09
+last_modified: 2026-03-18
 ---
 1.  Try to hard wrap long lines at 77 characters or less.
@@ -49,20 +49,7 @@ last_modified: 2026-08-09
    ```
    ```make
-    # ?= rather than := because this `$(shell git describe ...)` is only
+    VERSION := $(shell git describe --always --dirty)
    # correct on the host. `.dockerignore` excludes `.git`, so evaluated
    # inside a build stage it expands to the empty string without failing
    # and the binary reports no version at all. The version is computed on
    # the host by `script/docker` / `script/cibuild` and passed with
    # `--build-arg VERSION=...`. If this repo's Dockerfile compiles by
    # invoking make (`RUN make build`), `ARG VERSION` in that stage puts the
    # value in the environment and `?=` defers to it. The canonical Go
    # template in REPO_POLICIES.md instead runs `go build` directly with
    # `-ldflags "... -X main.Version=${VERSION}"`, so there this Makefile is
    # a host-only path — but it is still `?=`, because a repo that later
    # moves the build behind make must not silently start shipping an empty
    # version. See the git-describe rule in REPO_POLICIES.md.
    VERSION ?= $(shell git describe --always --dirty)
    BUILDARCH := $(shell uname -m)
    GOLDFLAGS += -X main.Version=$(VERSION)
@@ -114,16 +101,9 @@ last_modified: 2026-08-09
    `golangci-lint`.
 1.  Write a `Dockerfile` for every repo, even if it only runs the tests and
-    linting. `script/cibuild` and `script/docker` should always make sure that
+    linting. `docker build .` should always make sure that the code is in an
-    the code is in an able-to-be-compiled state, linted, and any tests run, and
+    able-to-be-compiled state, linted, and any tests run. The Docker build
-    the build should fail if linting doesn't pass. That guarantee holds only
+    should fail if linting doesn't pass.
    because those scripts pass a per-invocation `CHECK_EPOCH` build arg that
    busts the check layers out of the Docker cache; without it an unchanged tree
    serves those layers from cache and the build reports a green it never ran. A
    bare `docker build .` fails closed by design, on the `[ -n "$CHECK_EPOCH" ]`
    guard — always go through `script/cibuild` or `script/docker`. See
    [Repository Policies](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md)
    for the canonical form.
 1.  Every repo must have a `Makefile`. See
    [Repository Policies](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md)
--- a/prompts/EXISTING_REPO_CHECKLIST.md
+++ b/prompts/EXISTING_REPO_CHECKLIST.md
@@ -1,6 +1,6 @@
 ---
 title: Existing Repo Checklist
-last_modified: 2026-08-09
+last_modified: 2026-07-06
 ---
 Use this checklist when beginning work in a repo that may not yet conform to our
@@ -24,57 +24,15 @@ with your task.
 - [ ] `LICENSE` file exists and matches the README
 - [ ] `REPO_POLICIES.md` exists and version date is current — fetch from
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md`
- [ ] `.gitignore` is comprehensive (OS, editor, agent scratch, language
+- [ ] `.gitignore` is comprehensive (OS, editor, language artifacts, secrets) —
-      artifacts, secrets) — fetch from
+      fetch from `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore`
-      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` if missing.
+      if missing
      An existing repo usually has a hand-written one that is never re-fetched,
      so check the entries rather than the file's presence: `.claude/` in
      particular, unanchored, so agent worktrees cannot be committed by
      accident. Do not give it a `**/` prefix — that is a `.dockerignore` form
      and is wrong here.
 - [ ] `.editorconfig` exists — fetch from
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.editorconfig`
- [ ] `Dockerfile` and `.dockerignore` exist (fetch `.dockerignore` from
+- [ ] `Dockerfile` and `.dockerignore` exist; Dockerfile runs `make check` as a
-      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore`);
+      build step — fetch `.dockerignore` from
-      Dockerfile runs `make check` as a build step, and every stage containing a
+      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore`
-      check-running `RUN` declares `ARG CHECK_EPOCH` with the
+- [ ] Gitea Actions workflow in `.gitea/workflows/` runs `docker build .` on
      `RUN [ -n "$CHECK_EPOCH" ] || exit 1` guard immediately below it — see the
      `CHECK_EPOCH` rule in `REPO_POLICIES.md`. Without them the check layer is
      served from cache on an unchanged tree and the build reports a green it
      never ran.
 - [ ] `.dockerignore` excludes the repo's own host-built artifacts (compiled
      binaries, test binaries, coverage output), written root-anchored —
      `/myapp`, never `**/myapp`, which would also match `cmd/myapp/`. An
      existing repo is where such a binary is likeliest to already be sitting in
      the build context, invisible to git.
 - [ ] `.dockerignore` excludes `.claude`, root-anchored and with no `**/`
      prefix. Agent worktrees are entire checkouts of the repo, so they inflate
      the context by a multiple of it and can copy another session's unreviewed
      work into an image layer. Confirm by enumerating the image, not by reading
      the file — `.gitignore` hides these from `git status` too.
 - [ ] **Do agents in this repo run anywhere other than the repo root?** The
      scratch directory is created in the agent's working directory, so the
      canonical anchored entry misses `services/api/.claude/` in a monorepo with
      a per-service agent — it still reaches the build context and the image. An
      existing repo is where such a layout already exists, so check it here
      rather than assuming the canonical entry covers you: add anchored entries
      for the subdirectories that have one (`/services/api/.claude`), or
      `**/.claude` once you have confirmed no legitimately named nested
      directory would be caught.
 - [ ] If the repo embeds a version in a binary, that version is computed on the
      host and passed with `--build-arg VERSION=...` by `script/docker` and
      `script/cibuild`. No stage calls `git describe`: `.dockerignore` excludes
      `.git`, so it yields an empty version without failing the build. A
      tag-derived version additionally needs `fetch-depth: 0` on the CI checkout
      step, which clones shallow and fetches no tags by default.
 - [ ] Every depth-independent pattern in `.dockerignore` carries a `**/` prefix;
      only genuinely root-anchored entries such as `.git` are unprefixed, and
      `.gitignore`'s patterns have not been transplanted unmodified.
      `.dockerignore` anchors an unprefixed pattern at the context root, so the
      transplanted form leaves `config/.env` and `certs/server.key` in the build
      context while reading as solved — see the `.dockerignore` rule in
      `REPO_POLICIES.md`.
 - [ ] Gitea Actions workflow in `.gitea/workflows/` runs `script/cibuild` on
      push — reference
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitea/workflows/check.yml`
 - [ ] Language-specific config:
@@ -100,13 +58,6 @@ with your task.
      `script/install-precommit`, shimmed by `make hooks`) runs it
 - [ ] README has an **Entrypoints** section documenting the `script/`
      entrypoints and linking the standard
 - [ ] Go: `script/lint` isolates golangci-lint per checkout —
      `GOLANGCI_LINT_CACHE` and `TMPDIR` both exported into `.lint-cache/`
      (which is in `.gitignore` and `.dockerignore`), `--allow-serial-runners`
      passed, and the lock error retried rather than reported as findings. Copy
      the canonical block from `REPO_POLICIES.md`. Setting only the cache is the
      common half-fix and leaves `parallel golangci-lint is running` failing
      runs red.
 - [ ] `make check` does not modify any files in the repo
 - [ ] `make test` has a 30-second timeout
 - [ ] `make test` runs real tests, not a no-op (at minimum, import/compile
@@ -153,6 +104,5 @@ with your task.
 # Final
 - [ ] `make check` passes
- [ ] `script/cibuild` succeeds (a bare `docker build .` fails closed by design,
+- [ ] `docker build` succeeds
      on the `CHECK_EPOCH` guard)
 - [ ] Commit and merge fixes before starting your actual task
--- a/prompts/GO_HTTP_SERVER_CONVENTIONS.md
+++ b/prompts/GO_HTTP_SERVER_CONVENTIONS.md
@@ -1,6 +1,6 @@
 ---
 title: Go HTTP Server Conventions
-last_modified: 2026-08-09
+last_modified: 2026-02-22
 ---
 This document defines the architectural patterns, design decisions, and
@@ -991,14 +991,7 @@ func main() {
 Use ldflags to inject version information at build time:
 ```makefile
-# ?= rather than := because this `$(shell git describe ...)` is only correct
+VERSION := $(shell git describe --tags --always)
 # on the host: `.dockerignore` excludes `.git`, so evaluated inside a build
 # stage it expands to the empty string without failing and the binary reports
 # no version. The version is computed on the host by `script/docker` /
 # `script/cibuild` and passed with `--build-arg VERSION=...`; where the build
 # stage invokes make, `ARG VERSION` puts it in the environment and `?=` defers
 # to it. See the git-describe rule in REPO_POLICIES.md.
 VERSION ?= $(shell git describe --tags --always)
 BUILDARCH := $(shell go env GOARCH)
 build:
--- a/prompts/NEW_REPO_CHECKLIST.md
+++ b/prompts/NEW_REPO_CHECKLIST.md
@@ -1,6 +1,6 @@
 ---
 title: New Repo Checklist
-last_modified: 2026-08-09
+last_modified: 2026-07-06
 ---
 Use this checklist when creating a new repository from scratch. Follow the steps
@@ -35,11 +35,7 @@ Template files can be fetched from:
 - [ ] `.gitignore` — fetch from
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore`, extend for
-      language-specific artifacts. Extensions are written to `.gitignore`'s own
+      language-specific artifacts
      semantics, where an unanchored pattern already matches at every depth:
      never add a `**/` prefix here, which is a `.dockerignore` form. The
      canonical file already carries `.claude/` so agent worktrees cannot be
      committed by accident.
 - [ ] `.editorconfig` — fetch from
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.editorconfig`
 - [ ] `Makefile` — fetch from
@@ -56,29 +52,7 @@ Template files can be fetched from:
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md`
 - [ ] `Dockerfile` and `.dockerignore` — fetch `.dockerignore` from
      `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore`
-    - Extend `.dockerignore` with the repo's own host-built artifacts, giving
+    - All Dockerfiles must run `make check` as a build step
      every depth-independent pattern a `**/` prefix — but write a repo-root
      binary anchored, `/myapp` and never `**/myapp`, which would also match
      `cmd/myapp/` and delete the package directory. Do not transplant
      `.gitignore`'s patterns: `.dockerignore` anchors an unprefixed pattern at
      the context root, so the copied form leaves `config/.env` in the build
      context while reading as solved. See the `.dockerignore` rule in
      `REPO_POLICIES.md`. The canonical file's `.claude` entry is anchored for
      the same reason as a repo-root binary; leave it that way, but note it only
      covers agents running at the repo root — if this repo will run them in
      subdirectories, `services/api/.claude/` is not excluded and needs its own
      anchored entry.
    - If the image embeds a version in a binary, the version is computed on the
      host and passed with `--build-arg VERSION=...`. `ARG VERSION=dev` is
      declared in the stage that compiles, and **no stage calls `git describe`**
      — `.dockerignore` excludes `.git`, so it yields an empty version without
      failing the build.
    - All Dockerfiles must run `make check` as a build step, and every stage
      containing a check-running `RUN` must declare `ARG CHECK_EPOCH` with the
      `RUN [ -n "$CHECK_EPOCH" ] || exit 1` guard immediately below it — see the
      `CHECK_EPOCH` rule in `REPO_POLICIES.md`. Without them the check layer is
      served from cache on an unchanged tree and the build reports a green it
      never ran.
    - Server: also builds and runs the application
    - Non-server: brings up dev environment and runs `make check`
    - Image pinned by sha256 hash with version/date comment
@@ -109,17 +83,6 @@ are thin shims calling them. Model scripts:
 - [ ] `script/test` / `make test` — runs real tests, not a no-op (30-second
      timeout)
 - [ ] `script/lint` / `make lint` — runs linter
    - [ ] Go: exports `GOLANGCI_LINT_CACHE` **and** `TMPDIR` into a
          `.lint-cache/` directory inside the checkout, above any
          container-versus-host branch so every path that reaches the linter
          gets them; passes `--allow-serial-runners` (never
          `--allow-parallel-runners`); retries on
          `parallel golangci-lint is running` detected on **stderr** and exits
          75 with a VOID message on exhaustion. Copy the canonical block from
          `REPO_POLICIES.md` rather than writing your own: a version that sets
          only the cache leaves the false-red half live, and one that detects
          the collision by exit status can retry a real finding away.
    - [ ] Go: `.lint-cache/` is in both `.gitignore` and `.dockerignore`
 - [ ] `script/fmt` / `make fmt` — formats code (writes)
 - [ ] `script/fmt-check` / `make fmt-check` — checks formatting (read-only)
 - [ ] `script/check` / `make check` — runs `test`, `lint`, `fmt-check`; must not
@@ -127,30 +90,8 @@ are thin shims calling them. Model scripts:
 - [ ] `script/projectname` — outputs the project name (used by `script/docker`
      for the image tag)
 - [ ] `script/docker` / `make docker` — builds Docker image, tagged via
-      `script/projectname` (byte-identical across repos); carries the same three
+      `script/projectname` (byte-identical across repos)
-      version lines as `script/cibuild` below, and passes
+- [ ] `script/cibuild` — cd to repo root, `docker build .` (what CI runs)
      `--build-arg CHECK_EPOCH="$epoch"` and `--build-arg VERSION="$version"`
 - [ ] `script/cibuild` — cd to repo root, then, each on its own line:
    ```sh
    epoch="$(date +%s%N)$$"
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build \
        --build-arg CHECK_EPOCH="$epoch" \
        --build-arg VERSION="$version" \
        .
    ```
    (what CI runs). Both build args are mandatory, and both assignments must be
    on 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 `[ -n "$version" ]` line is a live check that fires on an
    export with no `.git` and on a repo with no commits — keep it, and do not
    collapse it into `|| echo unknown`, which makes it unreachable. See the
    `CHECK_EPOCH` and git-describe rules in `REPO_POLICIES.md` for why each
    element is load-bearing. A bare `docker build .` fails closed by design.
 - [ ] `script/precommit` — called by the pre-commit hook; runs `script/check`
 - [ ] `script/install-precommit` — installs the pre-commit hook that runs
      `script/precommit`
--- a/prompts/REPO_POLICIES.md
+++ b/prompts/REPO_POLICIES.md
@@ -1,6 +1,6 @@
 ---
 title: Repository Policies
-last_modified: 2026-08-09
+last_modified: 2026-08-10
 ---
 This document covers repository structure, tooling, and workflow standards. Code
@@ -60,11 +60,7 @@ 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
+  repo root and runs `docker build .`; the Gitea workflow calls it. Four further
  `docker build --build-arg CHECK_EPOCH="$epoch" --build-arg VERSION="$version" .`,
  where `epoch` is a per-invocation nonce (see the `CHECK_EPOCH` rule below) and
  `version` is computed on the host because `.git` is not in the build context
  (see the git-describe rule below); the Gitea workflow calls it. 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`;
@@ -94,77 +90,14 @@ style conventions are in separate documents:
  reading the Makefile.
 - Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
-  as a build step so the build fails if the branch is not green — which requires
+  as a build step so the build fails if the branch is not green. For non-server
-  `ARG CHECK_EPOCH` and its guard in every stage containing a check-running
+  repos, the Dockerfile should bring up a development environment and run
-  `RUN`, per the `CHECK_EPOCH` rule below. Without them a Dockerfile satisfies
+  `make check`. For server repos, `make check` should run as an early build
-  this criterion while its check layers are served from cache, so the build
+  stage before the final image is assembled. Dockerfiles install development
-  cannot fail on a branch that is not green. For non-server repos, the
+  prerequisites by running `script/bootstrap` rather than duplicating installs
-  Dockerfile should bring up a development environment and run `make check`. For
+  inline; COPY `script/` and the dependency manifests (`package.json` +
-  server repos, `make check` should run as an early build stage before the final
+  `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it so the bootstrap
-  image is assembled. Dockerfiles install development prerequisites by running
+  layer stays cached until dependencies change.
  `script/bootstrap` rather than duplicating installs inline; COPY `script/` and
  the dependency manifests (`package.json` + `yarn.lock`, `go.mod` + `go.sum`,
  etc.) before running it so the bootstrap layer stays cached until dependencies
  change.
 - **Every check-running `RUN` must be cache-busted with `CHECK_EPOCH`.** Docker
  invalidates a `COPY` layer only when the copied content changes, so on an
  unchanged tree the `RUN make check` layer is served from cache, the suite
  never runs, and the build still exits 0. A sub-second `docker build` reporting
  success is a cache hit, not a result. The canonical form, in **every** stage
  containing a check-running `RUN`:
    ```dockerfile
    ARG CHECK_EPOCH
    RUN [ -n "$CHECK_EPOCH" ] || exit 1
    RUN echo "check epoch: ${CHECK_EPOCH}" && make check
    ```
    and in both `script/cibuild` and `script/docker`:
    ```sh
    epoch="$(date +%s%N)$$"
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build \
        --build-arg CHECK_EPOCH="$epoch" \
        --build-arg VERSION="$version" \
        .
    ```
    The `VERSION` lines are there for a different reason, covered by the
    git-describe rule below; they are shown here so the two rules do not each
    document half a command. All four `CHECK_EPOCH` elements are load-bearing;
    none is optional, and each guards a failure mode that otherwise fails green:
    - `ARG` is stage-scoped, so a single declaration leaves the other check
      stages frozen while the fix reviews as complete. Declare it in every stage
      that runs checks, immediately above the first such `RUN`.
    - Expand the value into the command. This makes the cache miss contractual
      rather than dependent on BuildKit's handling of an unreferenced `ARG`, and
      it puts the epoch in the build log. The guard is itself value-keyed, for
      the same reason: it references `$CHECK_EPOCH`, so BuildKit renders the
      epoch into that layer's description (rendered as
      `RUN [ -n "<epoch>" ] || exit 1`) and re-runs it whenever the value
      changes. Each stage therefore has two independent invalidation points, and
      the guard always precedes the check `RUN`. Keep both: the expansion is
      defence in depth, and it is what makes the epoch visible in the build
      output.
    - The `[ -n ... ]` guard is required: an unset `ARG` is empty, and empty is
      a stable cache key, so without it a bare `docker build .` still produces
      the false green. Failed steps are never cached, so the guard fails on
      every such invocation, loudly. A bare `docker build .` failing is by
      design.
    - Assign `epoch=` on its own line, never inline in the `--build-arg`
      argument: a failing command substitution inside an argument does not trip
      `set -e`, so the inline form silently degrades to an empty constant. The
      `$$` suffix is required because busybox `date` drops `%N` and exits 0, so
      on an alpine host the epoch would degrade to second granularity and
      concurrent invocations would collide.
    This invalidates the check layers and everything after them while leaving
    `go mod download`, `script/bootstrap`, and the pinned toolchain install
    cached, so it does not push against the five-minute Docker build ceiling.
    Blanket `--no-cache` also works but is wasteful and can blow that ceiling.
 - **Dockerfiles must use a separate lint stage for fail-fast feedback.** Go
  repos use a multistage build where linting runs in an independent stage based
@@ -186,9 +119,7 @@ style conventions are in separate documents:
    COPY go.mod go.sum ./
    RUN go mod download
    COPY . .
-    ARG CHECK_EPOCH
+    RUN make fmt-check
    RUN [ -n "$CHECK_EPOCH" ] || exit 1
    RUN echo "check epoch: ${CHECK_EPOCH}" && make fmt-check
    RUN make lint
    # Build stage
@@ -202,13 +133,8 @@ style conventions are in separate documents:
    COPY go.mod go.sum ./
    RUN go mod download
    COPY . .
-    ARG CHECK_EPOCH
+    RUN make test
    RUN [ -n "$CHECK_EPOCH" ] || exit 1
    RUN echo "check epoch: ${CHECK_EPOCH}" && make test
    # VERSION comes from the host via --build-arg; see the git-describe rule
    # below. Never run `git describe` here: .dockerignore excludes .git, so
    # it yields an empty version without failing the build.
    ARG VERSION=dev
    RUN CGO_ENABLED=0 go build -trimpath \
        -ldflags="-s -w -X main.Version=${VERSION}" \
@@ -228,16 +154,6 @@ style conventions are in separate documents:
      a stage dependency. BuildKit runs stages in parallel by default; without
      this line, the build stage would not wait for lint to finish and a lint
      failure might not fail the overall build.
    - **Re-prove that ordering on a warm cache after adopting `CHECK_EPOCH`.**
      The cache-bust turns this no-op `COPY` into a content-cache hit, so an
      ordering guarantee established on a cold cache does not automatically
      carry over; it has to be re-checked warm. This was re-proved in another
      repo in the org that uses the same file-dependency trick (there with a
      marker file in place of `go.sum`), and the ordering held. It has **not**
      been verified in this repo, which is single-stage and has no lint stage to
      order against. Any repo relying on a file-dependency trick for stage
      ordering should re-check it warm after adopting the bust rather than
      assuming this result transfers.
    - 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
      create placeholder files so the embed directives resolve. Example:
@@ -249,34 +165,11 @@ style conventions are in separate documents:
    - The build stage runs `make test` after compilation setup. Tests run in the
      build stage, not the lint stage, because they may require compiled
      artifacts or heavier dependencies.
    - `ARG CHECK_EPOCH` appears in **both** stages, because `ARG` is
      stage-scoped: declaring it only in the lint stage leaves `make test`
      frozen at the last cached result. In each stage the guard sits immediately
      below the `ARG` so a bare `docker build .` fails instead of reusing the
      empty cache key, and the value is expanded into the first check `RUN` so
      the cache miss does not rely on BuildKit's unreferenced-`ARG` handling.
      Both of those lines reference `$CHECK_EPOCH`, so both are value-keyed:
      each stage is invalidated at two independent points. The later `RUN`s in
      the same stage need no expansion of their own: they are already
      invalidated by their busted parent layer.
    - `ARG VERSION=dev` is declared in the build stage, and its value is
      supplied on the host by `script/docker` and `script/cibuild` via
      `--build-arg VERSION=...`. The `dev` default is a placeholder for a local
      build, not a source of truth. **No stage may call `git describe`**:
      `.dockerignore` excludes `.git`, so it yields an empty version without
      failing. See the git-describe rule further down.
 - Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
-  runs `script/cibuild` (which runs
+  runs `script/cibuild` (which runs `docker build .`) on push. Since the
-  `docker build --build-arg CHECK_EPOCH="$epoch" --build-arg VERSION="$version" .`)
+  Dockerfile already runs `make check`, a successful build implies all checks
-  on push. The Dockerfile runs `make check`, so a successful build implies all
+  pass.
  checks pass — but that implication holds **only** because of the `CHECK_EPOCH`
  cache-bust described above. Without it, an unchanged tree serves the check
  layer from cache and the build reports a green it never earned. A bare
  `docker build .` fails closed by design, on the `[ -n "$CHECK_EPOCH" ]` guard;
  always go through `script/cibuild` or `script/docker`. Never accept a
  `script/cibuild` pass as evidence without confirming it ran: a sub-second wall
  time, or `CACHED` on the check layer, means nothing was executed.
 - Use platform-standard formatters: `black` for Python, `prettier` for
  JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
@@ -316,11 +209,16 @@ style conventions are in separate documents:
    ```makefile
    test:
-    	@go test -timeout 30s -race -cover ./... || \
+    	@go test -count=1 -timeout 30s -race -cover ./... || \
    		{ echo "--- Rerunning with -v for details ---"; \
-    		  go test -timeout 30s -race -v ./...; exit 1; }
+    		  go test -count=1 -timeout 30s -race -v ./...; exit 1; }
    ```
    `-count=1` is required on both invocations: it defeats Go's test _result_
    cache, so the target cannot report a pass it did not earn, and the rerun
    reproduces a failure instead of replaying it. It leaves the build cache
    alone, so it costs the runtime of the suite and no recompilation.
    Python example:
    ```makefile
@@ -346,140 +244,10 @@ 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`, `*~`), in-repo agent scratch directories (`.claude/`,
+  editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`.
-  which holds one worktree — an entire additional checkout of the repo — per
+  Fetch the standard `.gitignore` from
  in-flight agent), language build artifacts, and `node_modules/`. Fetch the
  standard `.gitignore` from
  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up
-  a new repo. These patterns are written to `.gitignore`'s own semantics, in
+  a new repo.
  which an unanchored pattern already matches at every depth. They are not a
  `.dockerignore` and must not be transplanted into one unmodified — see the
  next rule.
 - **`.dockerignore` does not use `.gitignore` semantics, and copying patterns
  across unmodified leaves secrets in the build context.** Docker matches with
  `moby/patternmatcher`: Go `filepath.Match` semantics plus a `**` extension,
  compiled to a regexp — plain `filepath.Match` has no `**` at all. 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; `config/.env` and
  `certs/server.key` still reach the context and can land in an image layer.
  That file is more dangerous than a short one with no secret patterns at all,
  because it reads as solved and stops anyone looking. Give every
  depth-independent pattern the `**/` prefix — `**/node_modules`,
  `**/.DS_Store`, and the secret patterns in the canonical file, which are
  additionally case-folded per the rule below — and leave only genuinely
  root-anchored entries unprefixed: `.git`, the in-repo agent scratch directory
  `.claude`, and the repo's own host-built binary. The inverse move is equally
  wrong: never apply `**/` to `.gitignore`, where it is redundant and produces a
  file that is wrong in a way that looks careful. Each file is written to its
  own semantics; neither is derived from the other. Fetch the standard
  `.dockerignore` from
  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` and extend
  it with the repo's own host-built artifacts — a host `make build` that leaves
  a compiled binary in the repo root puts that binary in the build context,
  where `.gitignore` hides it from every git-based check. Write that binary
  anchored, `/myapp` and never `**/myapp`: the prefixed form also matches
  `cmd/myapp/` and deletes the package directory from the context.
 - **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 with `COPY . .` the build context
  inflates by a multiple of the repo, and another session's unreviewed,
  sometimes uncommitted work can be copied into an image layer. The directory is
  also created and destroyed constantly, so it invalidates `COPY . .` for
  reasons that have nothing to do with the repo's own content. In `.gitignore`
  the entry is `.claude/`, unanchored, which already matches at every depth. In
  `.dockerignore` it is `.claude`, anchored and with **no** `**/` prefix: the
  directory occurs exactly once **where agents run at the repo root**, and the
  prefixed form would also match any nested directory of that name and delete it
  from the build. It is not case-folded the way the secret patterns are, because
  tooling creates it in exactly one spelling, so a folded pattern would add no
  coverage.
    **Known gap that comes with the anchored form.** The directory is created in
    the agent's working directory, so the "exactly once, at the root" premise is
    a property of how agents are run and not of the tooling. Where agents run in
    subdirectories — a monorepo with a per-service agent is the ordinary case —
    `services/api/.claude/` is **not** excluded by the canonical entry and still
    reaches the build context and the image, which is the exposure the entry
    exists to close. A repo in that shape adds its own anchored entries
    (`/services/api/.claude`), or `**/.claude` once it has confirmed no
    legitimately named nested directory would be caught. This is stated in the
    canonical `.dockerignore` itself, since that file is what consuming repos
    receive.
 - **`.dockerignore` matching is case-sensitive, so cover capitalisation with
  character classes rather than by doubling patterns.** `**/*.key` does not
  match `certs/SERVER.KEY`, which is reachable on the case-insensitive
  filesystems most laptops use. Adding an ALL-CAPS twin for each pattern is not
  the fix: it still misses `Server.Key` and `Ca.Pem` while reading as though
  case were handled — the same manufactured confidence as the root-anchored
  form. The matcher supports character ranges, so one line covers every
  spelling: `**/*.[kK][eE][yY]`, `**/*.[pP][eE][mM]`. Apply this to every secret
  name, not only to extensions: the extensionless SSH keys and `.envrc` need it
  for the same reason, since on the very filesystems that make `SERVER.KEY`
  reachable, direnv reads `.ENVRC` and ssh reads `ID_RSA`. Note that `*` matches
  the empty string, so `**/*.[eE][nN][vV]` already covers a bare `.ENV` and no
  separate literal `.env` entry is needed.
 - **A pattern that also catches something the build needs is re-included with a
  negation, not deleted.** The canonical `**/*.[eE][nN][vV]` excludes a
  committed env template such as `example.env`; a repo whose build genuinely
  reads one adds `!docs/example.env` after the pattern. Deleting the pattern
  instead reopens the exposure for every other file it covers.
 - **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`). Reading the patterns and
  agreeing they look right is exactly what lets the root-only form through. 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, so the
  reported size describes the transfer and not the contents of the image.
 - **Excluding `.git` means `git describe` cannot run inside any build stage, and
  it fails quietly there.** The `GOLDFLAGS` version-embedding pattern assumes
  `.git` is present; in a build stage there is no repository, so `git describe`
  writes nothing to stdout and the `-X main.Version=` value comes out **empty**
  rather than erroring. The binary then reports no version at all and the build
  still exits 0. Compute the version **on the host** and thread it in as a build
  arg. `script/docker` and `script/cibuild` do this, byte-identically across
  repos:
    ```sh
    # Assign on its own line: a failing command substitution inside an
    # argument does not trip `set -e`, so the inline form degrades to an
    # empty constant — the same silent-empty failure this rule is about.
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build \
        --build-arg CHECK_EPOCH="$epoch" \
        --build-arg VERSION="$version" \
        .
    ```
    `--always` makes an untagged repo yield the abbreviated commit hash instead
    of failing. `|| true` keeps a failing `git describe` from tripping `set -e`
    and leaves the value empty, so the `[ -n "$version" ]` line is the single
    place the fallback is applied — and it is a **live** check, not defence in
    depth: it fires on a build from an export with no `.git`, and on a
    repository with no commits yet. Do not fold the fallback into the
    substitution as `|| echo unknown`; that makes the guard unreachable, and a
    guard that cannot fire is indistinguishable from one that works to everyone
    who copies it. The result is non-empty by construction either way, which is
    the point: an empty version reads as a successful one, while `unknown` is
    visibly wrong. The Dockerfile's side is `ARG VERSION=dev` in the stage that
    compiles, declared there and not inherited, because `ARG` is stage-scoped
    exactly as `CHECK_EPOCH` is. Passing `VERSION` to a repo whose Dockerfile
    declares no such `ARG` is silently ignored by BuildKit and costs nothing,
    which is why the scripts stay byte-identical rather than growing a per-repo
    variant.
    One consequence for CI: the standard checkout action clones shallow and
    fetches no tags, so `git describe --tags` there falls back to a bare commit
    hash. A repo that embeds a tag-derived version must set `fetch-depth: 0` on
    its checkout step; a repo that does not embed a version needs no change.
 - **No build artifacts in version control.** Code-derived data (compiled
  bundles, minified output, generated assets) must never be committed to the
@@ -502,506 +270,6 @@ style conventions are in separate documents:
  commit-pinned via
  `go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@c0d3ddc9cf3faa61a4e378e879ece580256d76e5`.
 - **`script/bootstrap` in Go repos must install the pinned golangci-lint
  whenever the installed version does not match the pin — not merely when the
  binary is absent — and must then verify the install took effect by
  re-resolving the binary through `PATH`.** The presence test
  `if missing golangci-lint; then go install "$GOLANGCI_LINT_REF"; fi` is wrong:
  it tests `PATH` presence and never version, so on any already-provisioned
  machine the pin is inert and a version bump is a no-op. Meanwhile the
  Dockerfile installs unconditionally into a clean image, so CI and local
  silently disagree about what the linter even is. Observed consequences: a
  local `make check` green while `make docker` rejected the same commit with six
  `goconst` findings, and a container linter surfacing thirteen findings the
  host run missed. A stale host linter does not merely fail to prove the tree is
  clean — it hides findings only the container can see. This is a deliberate
  departure from the node handling described above, which uses whatever node is
  installed: the linter version is the specific thing being held equal between
  host and container, so for it, presence is not enough.
    Comparing versions is necessary but **not sufficient**, because the obvious
    fix also fails green. `go install` writes to `GOBIN` (or `GOPATH/bin`) while
    callers resolve `golangci-lint` through `PATH`. If a different binary
    shadows it earlier in `PATH`, the install genuinely succeeds and changes
    nothing any caller will ever see: bootstrap prints success and the next
    `make lint` still runs the stale linter. That is worse than no fix, because
    it converts a known-stale toolchain into one everyone believes is pinned.
    The canonical form, placed in `script/bootstrap` after Go itself is present:
    ```sh
    # golangci-lint v2.12.2, 2026-05-06. GOLANGCI_LINT_VERSION must be exactly
    # what `golangci-lint --version` prints for this ref; update both together.
    GOLANGCI_LINT_VERSION="2.12.2"
    GOLANGCI_LINT_REF="github.com/golangci/golangci-lint/v2/cmd/golangci-lint@c0d3ddc9cf3faa61a4e378e879ece580256d76e5"
    # The version golangci-lint reports, resolved the way callers resolve it.
    # Prints nothing when the binary is absent, exits non-zero, or prints
    # something unparseable: all of those must read as "does not match".
    # The capture is the whole version token, not just its numeric prefix.
    # Stopping at the first `-` would make 2.12.2-rc1 compare equal to 2.12.2
    # and skip the install, which is the defect this whole rule exists to close.
    # The trailing `|| true` is required, not tidiness. Under `set -o pipefail`
    # a non-zero --version would otherwise propagate out of the pipeline and
    # kill the script through `set -e` before the diagnostic below is printed.
    golangci_lint_version() {
        command -v golangci-lint >/dev/null 2>&1 || return 0
        golangci-lint --version 2>/dev/null | head -n 1 |
            sed -n 's/.*has version v\{0,1\}\([0-9][^ ]*\).*/\1/p' || true
    }
    ensure_golangci_lint() {
        if [ "$(golangci_lint_version)" = "$GOLANGCI_LINT_VERSION" ]; then
            echo "bootstrap: golangci-lint $GOLANGCI_LINT_VERSION already installed"
            return 0
        fi
        echo "bootstrap: installing golangci-lint $GOLANGCI_LINT_VERSION"
        go install "$GOLANGCI_LINT_REF"
        # go install writes to GOBIN (or GOPATH/bin); callers resolve through
        # PATH. Re-resolve through PATH and assert the install took effect.
        # `hash -r` is load-bearing: without it a shell that already resolved
        # a stale golangci-lint answers from its own lookup cache, and this
        # check false-fails with the shadowing message below.
        hash -r 2>/dev/null || true
        gcl_got="$(golangci_lint_version)"
        if [ "$gcl_got" = "$GOLANGCI_LINT_VERSION" ]; then
            echo "bootstrap: golangci-lint $GOLANGCI_LINT_VERSION installed," \
                "and PATH resolves it"
            return 0
        fi
        gcl_bin="$(go env GOBIN)"
        [ -n "$gcl_bin" ] || gcl_bin="$(go env GOPATH)/bin"
        # Strip a trailing slash: GOBIN=/x/ would otherwise make the
        # "$gcl_bin"/* test below miss and misreport shadowing.
        while :; do
            case "$gcl_bin" in
                */) gcl_bin="${gcl_bin%/}" ;;
                *) break ;;
            esac
        done
        gcl_found="$(command -v golangci-lint 2>/dev/null || true)"
        echo "bootstrap: installed golangci-lint $GOLANGCI_LINT_VERSION into" \
            "$gcl_bin, but that is not what callers will get." >&2
        case "$gcl_found" in
            "")
                echo "bootstrap: PATH resolves no golangci-lint at all." \
                    "Add $gcl_bin to PATH, then re-run bootstrap." >&2
                ;;
            "$gcl_bin"/*)
                echo "bootstrap: PATH resolves $gcl_found, inside that same" \
                    "directory, reporting version ${gcl_got:-unparseable}." \
                    "Nothing is shadowing it, so the install itself did not" \
                    "produce the pinned version: check that" \
                    "GOLANGCI_LINT_VERSION matches GOLANGCI_LINT_REF." >&2
                ;;
            *)
                echo "bootstrap: PATH resolves $gcl_found instead, reporting" \
                    "version ${gcl_got:-unparseable}. Remove that binary or" \
                    "put $gcl_bin earlier in PATH, then re-run bootstrap." >&2
                ;;
        esac
        exit 1
    }
    # The definitions above are inert on their own; the call site is part of
    # the canonical form. In a script/bootstrap that follows the "define all
    # functions, then call main" convention, this line belongs inside main()
    # next to the other ensure_* steps.
    ensure_golangci_lint
    ```
    Four properties are load-bearing; each guards a failure mode that otherwise
    fails green:
    - **Compare the installed version against the pin**, never test presence.
      This is what makes a version bump propagate to machines that already have
      some golangci-lint. Compare the **whole** version token, exactly: a parser
      that stops at the first `-` reports `2.12.2` for a host running
      `2.12.2-rc1`, which compares equal to a `2.12.2` pin and skips the install
      — the original defect, reintroduced through the comparison meant to fix
      it.
    - **After installing, re-resolve the binary the way callers resolve it** —
      through `PATH`, not the path `go install` wrote to — and assert
      `--version` reports the pin. When it does not, fail non-zero and name the
      path `command -v` actually found, the version it reports, and the
      directory the install wrote to. That is a condition a human has to fix by
      hand, so bootstrap must not print success in it. Use `hash -r` first so
      the shell does not answer from its own lookup cache. Diagnose the cause
      from the resolved path rather than asserting one: only a path **outside**
      the install directory is shadowing. When the resolved path is inside it,
      nothing is shadowing and telling the operator to delete that binary or
      reorder `PATH` sends them after a fault that does not exist.
    - **A mis-parse must fall through to reinstall, never to a false match.**
      Absent binary, non-zero exit, empty output, and unrecognised output all
      yield an empty string, which compares unequal to the pin. The failure
      direction is always a redundant install, never a skipped one.
    - **Call it, and say so on success.** Two function definitions with no call
      site are a silent no-op that reproduces the original defect exactly: exit
      0, nothing installed, no output, stale linter still resolved. A success
      path that prints nothing is byte-identical to that no-op — same exit
      status, same empty output — so both success branches must print a
      confirmation naming the version. In a change about undetectable no-ops,
      "it printed nothing and exited 0" must not be the healthy signal.
    Keep it POSIX sh: no bashisms, no arrays, no `[[`, no `grep -P`.
    **On the hash-pinning rule.** `@c0d3ddc9cf3faa61a4e378e879ece580256d76e5` is
    a commit hash, not a server-mutable version tag, and the go command verifies
    the fetched module against the checksum database — the mechanism the
    hash-pinning rule at the top of this document already names as acceptable
    for Go modules. Note that `go install pkg@version` runs in module-aware mode
    ignoring the `go.mod` in the current directory or any parent, so no repo
    `go.sum` is consulted for this install; the checksum database is what
    verifies it. The linter is a bootstrap prerequisite rather than part of any
    repo's module graph, which is why the canonical form installs it by
    commit-pinned ref instead of declaring it in `go.mod`. Whether a `go.mod`
    tool dependency — which would pin the hash in a committed, reviewable file
    instead — should replace this is an open decision, tracked at
    [prompts#37](https://git.eeqj.de/sneak/prompts/issues/37).
    **Keep `GOLANGCI_LINT_VERSION` and the ref in sync.** The ref is a hash and
    carries no readable version, so the expected version is a separate string,
    and it must be exactly what `--version` prints for that ref — the comparison
    is an exact match on the whole version token. When the pinned commit carries
    a release tag the go command resolves the hash to that tag, so the string is
    simply the release number, `2.12.2` here. When it does not, the go command
    falls back to a pseudo-version and the binary reports something like
    `2.12.3-0.20260506110758-c0d3ddc9cf3f`; that compares exactly like any other
    string, so it works, but it cannot be known without building the binary once
    and reading `--version` off it. Prefer pins on tagged releases for that
    reason — the expected string is then derivable from the ref — not because
    the comparison cannot handle the alternative.
    Because the comparison covers the whole token, a pre-release is never
    confused with its release: a host carrying `2.12.2-rc1` against a `2.12.2`
    pin compares unequal and gets reinstalled. This matters more than it looks,
    because a pre-release tag is still a tag, so a rule requiring merely that
    the pin be tagged would not catch it.
    **Verifying a change to this logic requires a negative control run in an
    environment where a shadowing binary exists earlier in `PATH` than the
    install target.** Without that, the control passes against the naive
    compare-then-install form as well and therefore proves nothing. Also check
    the mis-parse direction by feeding it unparseable `--version` output and
    confirming it reinstalls rather than reporting a match.
    **Run those controls against the block as a consuming repo would adopt it**
    — pasted into a `script/bootstrap`-shaped file that is then executed — not
    by sourcing it and invoking the function yourself. Driving the function
    directly tests something the artifact does not do, and it is exactly how a
    missing call site passes every control while the adopted snippet does
    nothing.
 - **`script/lint` in Go repos must give golangci-lint per-checkout cache and
  lock state, and must never report a lock collision as a lint result.**
  golangci-lint shares two pieces of state across every process on the host, and
  they are separate mechanisms with separate fixes. Isolating one and stopping
  leaves the other fully live while reading as a fix. This is independent of the
  pinned-install rule above and does not replace it: that one makes the host run
  the right linter, this one makes the run's result belong to your own tree.
    **Mechanism 1, the result cache — produces false greens as well as false
    reds.** golangci-lint keys cached results on file **content, not location**,
    so two checkouts of the same commit hold byte-identical files, share cache
    entries, and one tree's findings are served for the other — reported at the
    _other_ tree's path. Observed across the org: 399 issues attributed to a
    `/tmp` worktree that no longer existed, returned from a clean clone that
    genuinely lints 0 issues; ten findings against a deleted worktree; findings
    reported against `../wt82-lint/...`; and, in the dangerous direction, an
    implementer reporting "lint 0 issues" on a branch that was genuinely red.
    Note what content-keying implies: **moving agents from worktrees to their
    own clones does not help.** Two clones of a repo are byte-identical exactly
    as two worktrees were. What own-clones removes is the deleted-worktree path
    artefact — the loud, obviously wrong symptom — while leaving the mechanism
    live, which makes the defect quieter rather than rarer.
    **Mechanism 2, the concurrency lock — and it does not live in the cache
    directory.** From `pkg/commands/run.go`, `acquireFileLock()`:
    ```go
    lockFile := filepath.Join(os.TempDir(), "golangci-lint.lock")
    ```
    That is `$TMPDIR/golangci-lint.lock` — host-global, keyed on the temp
    directory, entirely independent of `GOLANGCI_LINT_CACHE`. It is an `flock`
    retried every second under a **5-second total timeout**, so it fails
    precisely when the host is busiest. On failure the run emits
    `parallel golangci-lint is running` and analyzes nothing. **A private cache
    directory does not prevent this**; that was established by controlled test,
    with two concurrent runs under separate cache directories sharing no mounted
    path, one of which still collided. Anyone who sets only
    `GOLANGCI_LINT_CACHE` has closed the contamination half and left the
    false-red half untouched.
    The canonical form for a Go repo's `script/lint`:
    ```sh
    #!/bin/sh
    # script/lint: run the linter.
    set -eu
    ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
    # Per-checkout golangci-lint state. Both variables are required and they
    # fix different defects; neither is redundant with the other.
    #
    # GOLANGCI_LINT_CACHE: the result cache is keyed on file content, not
    # location, so checkouts holding identical files serve each other's
    # findings. A per-REPO cache directory does NOT fix this — every checkout
    # of that repo still collides — so the path must be inside the invoking
    # checkout.
    #
    # TMPDIR: golangci-lint flocks $TMPDIR/golangci-lint.lock
    # (pkg/commands/run.go, acquireFileLock: filepath.Join(os.TempDir(),
    # "golangci-lint.lock")). That lock is host-global and independent of
    # GOLANGCI_LINT_CACHE, with a 5s acquire timeout. Scoping TMPDIR into the
    # checkout is the only thing here that isolates it. Do not delete this as
    # redundant with the cache variable; it is not.
    #
    # The leading dot in .lint-cache is load-bearing: the go tool skips
    # dot-prefixed directories when expanding ./..., so the linter never reads
    # its own cache and temp files back as source. Do not rename it.
    LINT_STATE="$ROOT/.lint-cache"
    GOLANGCI_LINT_CACHE="$LINT_STATE/cache"
    TMPDIR="$LINT_STATE/tmp"
    export GOLANGCI_LINT_CACHE TMPDIR
    mkdir -p "$GOLANGCI_LINT_CACHE" "$TMPDIR"
    # Capture files, per INVOCATION and not per checkout. Two runs in the same
    # checkout would otherwise redirect into one pair of fixed paths, opened
    # O_TRUNC before the linter even starts, and each would print and scan the
    # other's output — a run reporting a result that is not its own, which is
    # the whole defect this bullet exists to close, one layer up from where it
    # was closed. That case is not hypothetical here: two runs in the same
    # checkout is exactly what --allow-serial-runners below exists to support,
    # and serialising the linter does not serialise the shell's redirections
    # or the grep and cat that read them. mktemp rather than $$: two
    # containerised runs over one bind-mounted checkout are in separate PID
    # namespaces and can both be PID 7, which puts the collision back.
    LINT_OUT="$(mktemp "$LINT_STATE/run.out.XXXXXX")"
    LINT_ERR="$(mktemp "$LINT_STATE/run.err.XXXXXX")"
    # Print whatever the linter had written before the interruption, then exit
    # 128+signal. The exit is what makes this handler TERMINATING, and that is
    # the point: a signal-trap handler that returns RESUMES the script. With
    # the capture files already deleted, execution would fall into the grep
    # below against a missing file, take the not-a-collision branch, and report
    # the FINDINGS exit status with empty output for a run that was killed —
    # after deleting the findings it was about to print. That is why cleanup
    # is on EXIT only. Killing a run is not hypothetical here: it is the stated
    # mitigation for the unbounded wait --allow-serial-runners can produce, and
    # it is what Ctrl-C on a make check does.
    lint_interrupted() {
        if [ -f "$LINT_ERR" ]; then cat "$LINT_ERR" >&2; fi
        if [ -f "$LINT_OUT" ]; then cat "$LINT_OUT"; fi
        echo "lint: interrupted by a signal, so nothing was completed." \
            "This is NOT a lint result." >&2
        exit "$1"
    }
    # The EXIT trap still fires on the way out of a terminating handler, so
    # cleanup happens exactly once on every path. `|| :` because a failing rm
    # — an unwritable state directory is enough — would otherwise change the
    # exit status of an otherwise clean run under set -e.
    trap 'rm -f "$LINT_OUT" "$LINT_ERR" || :' EXIT
    trap 'lint_interrupted 129' HUP
    trap 'lint_interrupted 130' INT
    trap 'lint_interrupted 143' TERM
    # Backstop for a caller that reached the linter without the environment
    # above. With it set, this should never fire.
    LINT_MAX_ATTEMPTS=5
    # EX_TEMPFAIL. Distinct from 1 (findings) and 3 (linter error) so a void
    # run is never counted as either.
    LINT_VOID_EXIT=75
    golangci_lint_run() {
        attempt=1
        delay=2
        while :; do
            rc=0
            # --allow-serial-runners KEEPS the mutual-exclusion guard and makes
            # an overlapping run queue on the lock instead of aborting after
            # 5s. It is NOT --allow-parallel-runners, which removes the guard
            # entirely; never use that one. This is what covers two runs inside
            # the SAME checkout, which TMPDIR scoping cannot — script/precommit
            # overlapping a make check is the realistic trigger.
            golangci-lint run --allow-serial-runners "$@" \
                >"$LINT_OUT" 2>"$LINT_ERR" || rc=$?
            # Detect the lock collision on the STDERR STREAM, never on the exit
            # status. Findings are written to stdout and golangci-lint reports
            # this failure only on stderr, so a finding that quotes the string
            # from source cannot be mistaken for a collision and retried away —
            # that direction would be a false green. The exit status is not a
            # usable discriminator: the collision exits 3 (exitcodes.Failure),
            # which does separate it from findings at 1, but run.go returns it
            # as a plain error that Execute maps to Failure like every other
            # error at that level, so 3 cannot separate a collision from a
            # genuine linter failure — a broken config, an unparseable file.
            # Retrying on 3 would retry real failures into a void.
            if ! grep -q 'parallel golangci-lint is running' "$LINT_ERR"; then
                cat "$LINT_ERR" >&2
                cat "$LINT_OUT"
                return "$rc"
            fi
            if [ "$attempt" -ge "$LINT_MAX_ATTEMPTS" ]; then
                cat "$LINT_ERR" >&2
                echo "lint: VOID after $LINT_MAX_ATTEMPTS attempts:" \
                    "golangci-lint never acquired its lock, so nothing was" \
                    "analyzed. This is NOT a lint result and no verdict may" \
                    "be recorded from it. Re-run it." >&2
                return "$LINT_VOID_EXIT"
            fi
            echo "lint: lock held by another golangci-lint; attempt" \
                "$attempt of $LINT_MAX_ATTEMPTS, retrying in ${delay}s" >&2
            sleep "$delay"
            attempt=$((attempt + 1))
            delay=$((delay * 2))
        done
    }
    main() {
        cd "$ROOT"
        golangci_lint_run ./...
    }
    main "$@"
    ```
    Load-bearing properties, each guarding a mode that otherwise reports a
    verdict it did not earn:
    - **Both variables, per checkout.** Cache alone leaves the false reds;
      `TMPDIR` alone leaves the contamination that produced a confirmed false
      green. A per-repo path for either is not isolation on a host where every
      worker holds its own copy of the same repo.
    - **Set them on every path that reaches the linter.** The export block goes
      _above_ any container-versus-host branch, and a native escape hatch must
      call `golangci_lint_run` rather than `exec golangci-lint` directly. One
      repo in the org had exactly one such path with no cache environment at
      all, inheriting the fleet-wide default, so the fix on the other path was
      worth nothing there.
    - **The lock collision is not a result, and must never be reported as one.**
      Retry it, and on exhaustion exit a status that is neither the findings
      status nor success, with a message that says VOID. Swallowing it into a
      success is the worst available outcome; reporting it as findings sends a
      correct branch back for rework against findings that do not exist.
    - **Detect the collision by the message on stderr, not by exit status, and
      never retry a genuine finding.** Distinguishing "exited non-zero because
      of the lock" from "exited non-zero because of findings" is the whole crux,
      and getting it wrong in the direction of treating findings as a lock error
      retries a real failure into a void — or, if a later implementation decided
      to treat exhaustion as success, into a green.
    - **`--allow-serial-runners`, never `--allow-parallel-runners`.** The first
      keeps the guard and queues; the second deletes it and lets two runs
      corrupt shared state. With the flag set, an overlapping run inside the
      same checkout waits rather than failing, which is what is actually wanted.
      The honest cost is that it waits without bound, so a stale process holding
      the lock hangs the run instead of failing it; the contending set is
      bounded to the same checkout, and an eventual result is preferable to a
      fabricated one.
    - **Capture stdout and stderr to per-INVOCATION paths, and clean them up.**
      Two fixed paths under the checkout are one pair for every run in it, and
      the redirections truncate them before the linter starts, so two
      overlapping runs print and scan each other's output.
      `--allow-serial-runners` does not prevent this — it serialises the linter,
      not the shell — and the overlap it exists to support is precisely
      `script/precommit` against a `make check` in one checkout. The observed
      shapes are a run printing the other's `0 issues.` while its own linter
      found something, and a lock error erased before `grep` reads it, so the
      retry never fires and the void run returns as a result. Both are a run
      reporting a result that is not its own, which is this bullet's entire
      subject reintroduced one layer above where it was fixed. Use `mktemp`
      under the state directory rather than `$$`: two containerised runs over
      one bind-mounted checkout sit in separate PID namespaces and can hold the
      same low PID, which puts the collision back on exactly the fleet's
      arrangement. `$$` is acceptable only where `mktemp` is unavailable and
      that arrangement is ruled out.
    - **Clean up on `EXIT` only, and give each signal a TERMINATING handler.** A
      signal-trap handler that does not exit **resumes** the script: with the
      capture files already deleted, the run falls into the `grep` against a
      missing file, takes the not-a-collision branch, and reports the
      **findings** exit status with empty output for a run that was killed —
      having deleted the findings it was about to print. Measured: `TERM`, `INT`
      and `HUP` all returning 1 with empty stdout, against 143, 130 and 129 for
      the same block without the handler. Exit `128+signal` instead, after
      printing what the linter had already written, and let the `EXIT` trap do
      the cleanup on the way out. Killing a run is not a corner case here — it
      is the stated mitigation for the unbounded wait `--allow-serial-runners`
      can produce, and it is what Ctrl-C on a `make check` does. Put `|| :` on
      the `rm`: an unwritable state directory makes it fail, and a failing
      `EXIT` trap under `set -e` changes the exit status of an otherwise clean
      run to 1, which was measured in both `dash` and `bash`.
    Adopting repos must add `.lint-cache/` to both `.gitignore` and
    `.dockerignore`. The second matters as much as the first: the directory
    reaches tens of megabytes, and without the exclusion it enters the build
    context and invalidates `COPY . .` for reasons unrelated to the repo's
    content.
    **`GOCACHE` does not need isolating, and this was measured rather than
    assumed.** With `GOLANGCI_LINT_CACHE` and `TMPDIR` per checkout and
    `GOCACHE` left at the host default and shared, two checkouts of identical
    content each reported their own paths and neither reported the other's. The
    Go build cache is content-addressed and its entries are compiled artifacts
    rather than diagnostics carrying a foreign tree's paths, and it has no
    equivalent global lock — the whole fleet compiles concurrently against one
    `GOCACHE` all day without a contention error. Isolating it would cost a full
    cold compile per checkout for no measured benefit. The earlier hypothesis
    that Go build-cache contention might explain the lock error is superseded:
    the lock is located in source at `$TMPDIR/golangci-lint.lock`.
    **Verifying a change to this logic requires a negative control, and the
    control must be built out of checkouts with identical content.** Create two
    checkouts of the same tree containing a deliberate lint finding, run the
    linter in the second so it populates the cache, then run it in the first and
    confirm the finding is reported at the first checkout's own path and never
    at the second's. Run the same control against the unisolated form and
    confirm the contamination appears there — a control that passes against the
    broken implementation proves nothing. Note specifically that a control built
    from checkouts whose **content differs** passes against the unisolated form
    too, because differing content does not collide in a content-keyed cache, so
    it is not a test of anything. For the lock half, hold
    `$TMPDIR/golangci-lint.lock` with `flock` and confirm the run queues rather
    than aborting, that a caller never sees the collision as findings, and that
    exhaustion fails loudly and distinguishably.
    **Run those controls against the block as a consuming repo would adopt it**
    — pasted into a `script/lint`-shaped file that is then executed, not sourced
    with the functions driven by hand. The same warning as for the bootstrap
    block above, for the same reason.
 - **Interim rule for reading a golangci-lint result on a shared host, until
  every repo has adopted the isolation above.** A lint run is **VOID** unless
  both hold:
    - the output contains no `parallel golangci-lint is running`, and
    - no reported file path begins with `../`, and none is an absolute path
      outside the tree the run was launched from.
    Do not record a verdict from a void run, and do not "fix" findings in files
    the change does not touch — chasing phantom findings across untouched files
    puts unrelated edits into a reviewed diff, which is more expensive than the
    wasted rework.
    The `../` clause is the one that actually bites, and it is why a filter
    keyed on `/tmp` or on absolute prefixes is not enough: golangci-lint reports
    paths relative to its own resolved root rather than yours, and three of the
    org's reported sightings had relative paths and would have passed such a
    filter. Both clauses are needed and neither alone is sufficient — one
    reproduction exited non-zero with the lock error and no foreign paths at
    all, and another reported 34 well-formed findings, every one of them against
    another checkout.
    **State the limit of these tests rather than treating them as a guarantee.**
    They catch contamination that **names** foreign files. They cannot catch
    contamination that **suppresses** findings through a poisoned entry for
    colliding content, which has no wall-clock tell either — **no evidence of
    that mode has been observed, and nobody should go chasing it**; the point is
    the reach of the tests, not a claim that the mode exists. They are a filter
    for the loud mode, not a proof of soundness — which is the whole argument
    for fixing this in the tooling instead of documenting a discipline that
    depends on every agent remembering to apply it.
 - When pinning images or packages by hash, add a comment above the reference
  with the version and date (YYYY-MM-DD).
--- a/script/cibuild
+++ b/script/cibuild
@@ -1,33 +1,13 @@
 #!/bin/sh
-# script/cibuild: run the CI build. The Dockerfile runs script/check, but
+# script/cibuild: run the CI build. The Dockerfile runs script/check, so
-# that only proves anything because CHECK_EPOCH is a fresh nonce on every
+# a successful build implies all checks pass.
 # invocation: without it Docker serves the check layer from cache on an
 # unchanged tree and the build exits 0 without running the suite.
 set -eu
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 main() {
    cd "$ROOT"
-    # Assign on its own line: a failing command substitution inside an
+    docker build .
    # argument does not trip `set -e`, which would silently degrade the
    # nonce to an empty constant. `$$` is required because busybox `date`
    # drops %N without erroring.
    epoch="$(date +%s%N)$$"
    # VERSION must be computed here, on the host: .dockerignore excludes
    # .git, so `git describe` cannot run in any build stage and fails
    # quietly there rather than erroring. Same own-line discipline as the
    # epoch. `|| true` keeps a failing describe from tripping `set -e`
    # and leaves the value empty; the guard below is then the single
    # place the fallback is applied, and it does fire — on an export with
    # no .git, or a repo with no commits yet. `unknown` is visibly wrong
    # in a binary in a way that an empty version is not.
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build \
        --build-arg CHECK_EPOCH="$epoch" \
        --build-arg VERSION="$version" \
        .
 }
 main "$@"
--- a/script/docker
+++ b/script/docker
@@ -1,9 +1,6 @@
 #!/bin/sh
 # script/docker: build the Docker image tagged with the project name.
-# Identical in all repos; the tag comes from script/projectname. The
+# Identical in all repos; the tag comes from script/projectname.
 # Dockerfile's checks only actually run because CHECK_EPOCH is a fresh
 # nonce on every invocation; without it a warm cache turns this into a
 # green that proves nothing.
 set -eu
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -11,25 +8,7 @@ ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
 main() {
    cd "$ROOT"
-    # Assign on its own line: a failing command substitution inside an
+    docker build -t "$("$SCRIPT_DIR/projectname")" .
    # argument does not trip `set -e`, which would silently degrade the
    # nonce to an empty constant. `$$` is required because busybox `date`
    # drops %N without erroring.
    epoch="$(date +%s%N)$$"
    # VERSION must be computed here, on the host: .dockerignore excludes
    # .git, so `git describe` cannot run in any build stage and fails
    # quietly there rather than erroring. Same own-line discipline as the
    # epoch. `|| true` keeps a failing describe from tripping `set -e`
    # and leaves the value empty; the guard below is then the single
    # place the fallback is applied, and it does fire — on an export with
    # no .git, or a repo with no commits yet. `unknown` is visibly wrong
    # in a binary in a way that an empty version is not.
    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
    [ -n "$version" ] || version="unknown"
    docker build \
        --build-arg CHECK_EPOCH="$epoch" \
        --build-arg VERSION="$version" \
        -t "$("$SCRIPT_DIR/projectname")" .
 }
 main "$@"