sneak/prompts
1
0
Fork 0
Code Issues 4 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Compare commits

base: sneak/prompts:4a0d49b8e0b7df2df28ae023f77b36491f93362d
Branches Tags
sneak/prompts:main sneak/prompts:next sneak/prompts:golangci-lint-v2.13.2 sneak/prompts:issue-52-capability-url-carveout sneak/prompts:policy/name-the-gate-for-repo-type-checks sneak/prompts:fix/25-gomodguard-v2 sneak/prompts:lint-policy-reconcile
..
compare: sneak/prompts:issue-52-capability-url-carveout
Branches Tags
sneak/prompts:next sneak/prompts:main sneak/prompts:golangci-lint-v2.13.2 sneak/prompts:issue-52-capability-url-carveout sneak/prompts:policy/name-the-gate-for-repo-type-checks sneak/prompts:fix/25-gomodguard-v2 sneak/prompts:lint-policy-reconcile
7 Commits
4a0d49b8e0 .. issue-52-capability-url-carveout
Author SHA1 Message Date
sneak 4e6a782edf An unguessable capability URL is the whole credential (closes #52)
check / check (push) Successful in 16s
Details 
The HTTP hardening section ends with "when in doubt, harden", which as
written authorises adding HMAC signing or a shared secret on top of an
endpoint already gated by an unguessable per-entrypoint UUID URL. That
has been ruled against twice, and inbound signature verification was
removed from webhooker on exactly that reasoning; until now the only
text contradicting the policy was webhooker's own README.

Adds one scoped carve-out immediately after that sentence: such a URL is
a complete credential and gets no second factor, not even as defence in
depth. The consequences that do follow — keep it out of logs and
tickets, rotate by minting a new entrypoint — are stated, as is what to
do with a sender that only supports signed payloads. Nothing in the
surrounding hardening guidance is removed or weakened.
 2026-08-25 20:43:48 +00:00
sneak cc6a5a00e7 Run every lint in a container via Dockerfile.lint (closes #40)
check / check (push) Successful in 9s
Details 
script/lint runs the linter directly when it is already inside a
container and otherwise builds Dockerfile.lint, so the linter never runs
on a developer host. That closes three host-only mechanisms: the result
cache golangci-lint keys on file content rather than location, which
produced a confirmed false green and findings reported against other
checkouts; the host-global $TMPDIR/golangci-lint.lock, which fails a run
in a way no caller can distinguish from findings; and host/container
version skew, which hid thirteen findings on one repo.

Detection is on LINT_IN_CONTAINER=1, set by every Dockerfile, and on
nothing else. The two directions are not symmetric: a false negative
inside a container attempts a nested docker build, finds no daemon and
fails loudly, while a false positive on a host silently lints there,
which is the defect this issue exists to kill. /.dockerenv is therefore
rejected even as a fallback -- measured absent inside BuildKit RUN steps
and present on any host that is itself a container, so it fails in both
directions and one of them is the dangerous one.

Nothing else changes shape. The Dockerfile still runs make check,
script/check still runs test, lint and fmt-check, script/cibuild is
still a single docker build with CHECK_EPOCH and VERSION, and the Go
multistage lint stage and its COPY --from=lint ordering dependency
survive with ENV LINT_IN_CONTAINER=1 added. Dockerfile.lint is the
standalone developer-host path and carries the same CHECK_EPOCH guard,
with the ARG below the dependency layer so only the lint re-runs.

The script/bootstrap golangci-lint install and the per-checkout
GOLANGCI_LINT_CACHE/TMPDIR wrapper are deleted as superseded. Neither
has a caller left. A JS repo's yarn install stays: the rule is that no
lint verdict may come from a host invocation, not that no linter binary
may exist there, and in a repo whose formatter is its linter the
formatter necessarily runs on the host.

golangci-lint config verify is kept, on measurement. Under the pinned
v2.12.2 a bogus top-level key and a bogus key under linters.settings.lll
both pass `golangci-lint run` with exit 0 and `0 issues` while config
verify exits 3 and names them; an unknown linter name fails run and
passes config verify. It needs no network: every case reproduced
byte-identically under `docker run --network none`, in a container where
`getent hosts golangci-lint.run` exits 2.

Comment blocks were cut hard across every file this unit touches.
.dockerignore drops from 67 comment lines to 28, script/cibuild from 17
to 12, script/docker from 18 to 12, and prompts/REPO_POLICIES.md from
1182 lines to 907. What remains says why a line is load-bearing; the
discovery narratives are gone.

config verify lives in script/lint's native branch rather than in a
Dockerfile, so every path that lints inherits it: the lint stage of the
main image, which is what CI runs, as well as Dockerfile.lint. Putting
it in one Dockerfile is how the other path silently loses it.
 2026-08-10 14:05:54 +00:00
clawbot 0620416869 Give golangci-lint per-checkout cache and lock state (closes #30)
check / check (push) Successful in 7s
Details 
A golangci-lint result on a host running many concurrent workers does not
reliably belong to the tree that asked for it. Two independent mechanisms,
which have repeatedly been mistaken for one:

The result cache is keyed 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 under the other tree's path. This
produced a confirmed false green as well as the loud false reds. Moving
workers from shared worktrees to their own clones does not address it —
two clones collide exactly as two worktrees did — and removes only the
foreign-path artefact that made the defect noticeable.

The concurrency lock is $TMPDIR/golangci-lint.lock (pkg/commands/run.go,
acquireFileLock), host-global and independent of GOLANGCI_LINT_CACHE, with
a five-second acquire timeout, so it fails when the host is busiest. A
private cache directory does not isolate it. Setting only the cache closes
the contamination half and leaves runs failing red on a condition that is
not a result at all.

REPO_POLICIES.md now carries the canonical Go script/lint: both variables
scoped into a .lint-cache/ directory inside the checkout, above any
container-versus-host branch so every path reaching the linter gets them;
--allow-serial-runners, which keeps the mutual-exclusion guard and queues
rather than aborting, for the same-checkout overlap TMPDIR scoping cannot
cover, with --allow-parallel-runners rejected because it deletes the
guard; and a bounded retry that treats the lock error as VOID rather than
as findings, exiting 75 on exhaustion so it is neither a pass nor a
failure. Detection is on the stderr stream and never on exit status:
findings go to stdout, so a finding quoting the lock message in source
cannot be retried away, and the exit status is not a stable discriminator
anyway. The interim void rule is recorded with the ../ clause that the
original filter missed, and with its limit stated — it catches
contamination that names foreign files, not contamination that suppresses
findings. Both checklists gained the corresponding items, since a half-fix
that sets only the cache reads as complete.

GOCACHE was measured rather than assumed and does not need isolating: with
the two variables scoped per checkout and GOCACHE shared at the host
default, each checkout reported its own paths.

Verified with the snippet extracted from the committed document and
executed as a consuming repo would adopt it, each control paired against
the pre-fix form: contamination reproduced on the pre-fix script and
absent on the adopted one; a stub linter colliding twice then clearing,
with the retry engaging and succeeding; exhaustion exiting 75 with a VOID
message; a genuine finding whose text quotes the lock message reported as
findings with no retry; and a real held lock failing the pre-fix script
with exit 3 while the adopted script, inheriting the same environment,
completed in one second.
 2026-08-09 18:51:22 +00:00
sneak 3a218497b8 Keep in-repo agent scratch out of the build context and out of git (closes #27)
check / check (push) Successful in 17s
Details 
The canonical .dockerignore and .gitignore both omitted the in-repo agent
scratch directory. On this fleet that directory holds one worktree per
in-flight agent -- an entire additional checkout of the repo each -- so under
`COPY . .` all of it reached the build context and the image. Measured on this
repo before the change: five planted scratch files, at every depth beneath the
directory, all present inside a probe image built from the real context.

Three consequences, only the first of which is about size. The context inflates
by a multiple of the repo. Another session's unreviewed and sometimes
uncommitted work is copied into a build artifact. And the directory is created
and destroyed constantly by tooling, so it invalidates `COPY . .` for reasons
that have nothing to do with this repo's content -- which is the accidental
cache protection described at length in the issue thread, and the reason this
change was sequenced behind the CHECK_EPOCH bust rather than landed alongside
the rest of the .dockerignore work.

The two entries are deliberately different shapes, because the two files have
different semantics and neither is derived from the other. In .dockerignore the
entry is anchored, `.claude`, with no `**/` prefix: the directory occurs exactly
once, at the context root, and the prefixed form additionally matches any nested
directory of that name. Measured rather than argued -- the `**/`-prefixed
control was built and enumerated too, and it removes prompts/.claude/ from the
context as well, which in a repo with a legitimately named nested directory
would silently delete it from the build. In .gitignore the entry is unanchored,
`.claude/`, because a .gitignore pattern already matches at every depth;
`git check-ignore -v` confirms it covering both .claude/ and prompts/.claude/,
so a `**/` prefix there would be redundant at best, and on an anchored pattern
it would be actively wrong.

Anchoring buys that at the cost of a residual exposure, and the vendored files
now say so rather than only asserting the reason to anchor. "Occurs exactly
once, at the context root" is a property of how agents are run, not of the
tooling: the directory is created in the agent's working directory, so a
monorepo running a per-service agent in services/api/ still ships
services/api/.claude/ into the context and the image -- the exact exposure this
change exists to close, left open in the repo shape where it is likeliest. The
.dockerignore header block, the REPO_POLICIES.md bullet and both checklists
state the gap and the remedy (anchored entries for the subdirectories that have
one, or `**/.claude` once no legitimately named nested directory would be
caught). Consuming repos receive the files and not the tracker, so a caveat that
lives only in a PR body is not a caveat.

It is not case-folded the way the neighbouring secret patterns are: tooling
creates the directory in exactly one spelling, so a folded pattern would add no
coverage. The earlier justification -- that a miss costs bloat rather than
exposure -- is gone, because it contradicted this issue's own framing, in which
the cost of a miss is unreviewed work in an image layer.

The second half of this change is the consequence that ships broken silently.
Excluding .git means `git describe` cannot run in any build stage, and it fails
quietly there rather than erroring: `-X main.Version=` comes out empty, the
binary reports no version, and the build still exits 0. The Go template in
REPO_POLICIES.md had `ARG VERSION=dev` and never said where VERSION came from,
which is precisely the gap a reader fills in with `git describe` inside the
build. It now says: computed on the host, threaded in with `--build-arg
VERSION=...`, shown as a complete command rather than as two rules each
documenting half of one. script/docker and script/cibuild do it, with the same
discipline the epoch already has -- assignment on its own line, because a
failing command substitution inside an argument does not trip `set -e`, plus a
non-empty fallback so a build from an export with no .git reports `unknown`
rather than an empty string that reads as a successful version.

That fallback is applied in exactly one place, and that place can actually
execute. `git describe ... || true` leaves the value empty when it fails, and
the `[ -n "$version" ]` line is what substitutes `unknown`. Folding the fallback
into the substitution as `|| echo unknown` would have left the guard unreachable
-- harmless in itself, but a guard that cannot fire is indistinguishable from
one that works to every repo that copies it, and canonical text should not carry
a check that is decorative. Measured firing in both sh and dash: not a git
repository -> unknown, repository with no commits yet -> unknown, this
repository -> the describe output. The checklist now carries the guard line as
well, so the vendored guidance and the vendored script no longer disagree.

The scripts pass VERSION unconditionally rather than growing a per-repo variant.
This repo's Dockerfile declares no `ARG VERSION`, and BuildKit was measured
accepting the unconsumed arg silently -- no warning, no cache effect, confirmed
by the paired runs below in which the bootstrap layer still caches. The
alternative, leaving it to each repo, reintroduces the trap: a repo that needs a
version and finds no VERSION in its scripts writes `git describe` into the
Dockerfile, which is the failure being closed.

The same correction reaches the two Go documents that carry the GOLDFLAGS
pattern, since a `$(shell git describe)` evaluated inside a build stage is
exactly this empty version. Both are now `?=`, and their comments say precisely
when that matters: where a build stage compiles by invoking make, `ARG VERSION`
puts the value in the environment and `?=` defers to it, whereas the canonical
Go template compiles with `go build` directly and uses the Makefile on the host
only -- still `?=`, so that a repo which later moves its build behind make does
not silently start shipping an empty version. Leaving them as `:=`
would have left the corpus telling a reader one thing in the policy and the
opposite in the styleguide.

Both repo checklists gain the entries too. They are what an agent reads while
writing these files, so they are where the wrong shape actually gets written:
the .gitignore item is the one an existing repo never re-fetches, and it now
names `.claude/` explicitly along with the warning not to prefix it.

Verification, by enumerating a probe image rather than by reading the patterns.
Standalone minimal Dockerfile held outside the context, `--no-cache` scoped to
that one image, no prune of any kind. Before: all five planted scratch files in
the image, 42 files total. After: zero, 37 files total, with README.md,
script/check, prompts/NEW_REPO_CHECKLIST.md and a planted probe_src/app.md all
still present as positive controls, so the exclusion is a real exclusion and not
a COPY that stopped copying. Transferred context fell from 161.86kB to 68.82kB,
recorded as corroboration only: BuildKit reports a delta, not a total, and an
earlier run in this repo transferred 2.18kB while shipping 43 files.

The CHECK_EPOCH verification was re-run under the changed context, because the
context moved underneath the earlier measurement. Two consecutive script/cibuild
runs on an unchanged tree: run 1 in 17.07s, run 2 in 5.73s, both executing the
check layer with a distinct epoch and real prettier output from both lint and
fmt-check. The `RUN script/bootstrap` layer is CACHED in run 2, which is the
validity control -- it proves no concurrent prune landed between the runs and
that no --no-cache path was taken, so the check layer executing is the bust
working rather than a cold cache.

Planted files were removed afterwards and their absence confirmed against the
filesystem with `find`, not against `git status`, which cannot see them once
.gitignore covers the directory -- the same blind spot that made the earlier
secret exposure invisible.
 2026-08-09 17:13:10 +00:00
sneak fd78aeb003 Keep secrets out of the Docker build context at every depth (closes #29)
check / check (push) Successful in 21s
Details 
The canonical .dockerignore was three lines -- .git, node_modules, .DS_Store
-- while the canonical Dockerfile does `COPY . .`, so a developer's local
.env, *.pem or *.key was shipped into the build context and could land in an
image layer. Nothing surfaced it because .gitignore covers those patterns, so
the files are invisible to every git-based check.

The obvious repair, copying .gitignore's secret patterns across, is worse than
the gap it closes. .dockerignore does not use .gitignore semantics: Docker
matches with moby/patternmatcher, which is filepath.Match semantics plus a `**`
extension compiled to a regexp. `*` does not cross `/`, and a pattern without
a leading `**/` is anchored at the build-context root. A file listing .env,
*.pem and *.key therefore reads as solved, reviews as solved, and protects
only the repository root, while config/.env and certs/server.key still ship.
The three-line file at least invited scrutiny; the transplanted form
manufactures confidence and stops anyone looking.

So every depth-independent pattern here carries the `**/` prefix and only
genuinely root-anchored entries stay unprefixed. `**/node_modules` fixes a
defect the three-line file had today for any nested node_modules,
independently of the secret exposure.

Coverage is not limited to the three patterns the issue names, because the
enumeration found more shapes reaching the image. `**/*.env` covers the
prod.env / local.env convention, which the .env and .env.* spellings miss
entirely; `.envrc` is a secrets file by direnv convention; *.p12 and *.pfx are
bundles carrying private keys; and id_rsa, id_dsa, id_ecdsa and id_ed25519 are
the extensionless SSH keys that were covered before only when someone happened
to append a .key suffix.

Matching is case-sensitive, so `**/*.key` does not match certs/SERVER.KEY,
which is reachable on the case-insensitive filesystems most laptops use.
Doubling each pattern with an ALL-CAPS twin is not the fix: measured against
the planted set it still ships certs/Server.Key and certs/Ca.Pem while reading
as though case were handled, which is this issue's failure mode restated in a
new place. The matcher supports character ranges, so every secret name is
written that way -- `**/*.[kK][eE][yY]`, `**/*.[pP][eE][mM]`,
`**/.[eE][nN][vV][rR][cC]`, `**/[iI][dD]_[rR][sS][aA]` and the rest. The
extensionless SSH keys and .envrc are folded for the same reason the
extensions are: on the very filesystems that make SERVER.KEY reachable, direnv
reads .ENVRC and ssh reads ID_RSA, so exempting them would have contradicted
the rule that justifies the folding. Since `*` matches the empty string,
`**/*.[eE][nN][vV]` already covers a bare .ENV and no separate literal .env
entry is needed; the literal one is gone rather than left to imply that case
is unhandled there.

Deliberately not covered: bare `key` and `pem` filenames, which no tool
produces and which collide with legitimate paths (a `**/key` pattern would
delete an internal/key/ package directory from the context); `**/id_*`, which
would match ordinary source such as id_generator.go and ID_MAP.go; and *.crt
and *.cer, which are public certificates rather than secrets and are sometimes
a legitimate build input. Each of those is planted as a positive control and
verified present in the image after the change.

The one predictable false positive is a committed env template: `**/*.env`
excludes example.env. The remedy travels with the file rather than living in a
review thread -- the header comment and the policy both say to re-include it
with a negation, `!docs/example.env`, and never to delete the pattern, which
would reopen the exposure for everything else it covers.

The OS and editor patterns are included on their own merits rather than by
mirroring .gitignore. None of them is ever a build input, and editor state in
particular churns under a developer's hands, so each one is a source of
`COPY . .` invalidation carrying no information about the source tree. Now
that the checks are keyed on CHECK_EPOCH rather than on accidental context
churn, there is no reason left to keep churn in the context. Language build
artifacts are deliberately absent: they are per-repo, and the file's header
comment tells consuming repos to add their own host-built binaries, which is
the case that actually bites -- a host `make build` drops a multi-megabyte
artifact into the context where .gitignore hides it from every git-based
check. That comment gives the anchored form explicitly, `/myapp` rather than
`**/myapp`, because the prefixed spelling also matches cmd/myapp/ and deletes
the package directory. The header comment is the only part of this guidance a
consuming repo actually receives, since it is vendored with the file.

.gitignore is untouched. Its semantics are the inverse: an unanchored pattern
already matches at any depth, so `**/`-prefixing it produces a file that is
wrong in a way that looks careful. That asymmetry is why "derive one from the
other" was the wrong instruction, and it is now written down in
REPO_POLICIES.md in both directions, together with the case-sensitivity rule,
the negation remedy, and the requirement to verify by enumerating the image
rather than by reading the patterns. Every consuming repo inherits
.dockerignore by copy, so the trap has to live where the next person looks,
not only be fixed once here. Both repo checklists gain the same requirements.

Verified by planting 130 secret files -- twenty-six name shapes, including
every capitalisation of .env, .env.*, prod.env, .envrc, id_rsa, id_ed25519,
ca.pem, server.key, bundle.p12 and bundle.pfx, at five depths from the context
root to a/b/c -- alongside nine positive controls, then building a standalone
probe image doing `COPY . .` and listing what actually landed inside it. The
patterns as first written leaked 35 of the 130: every .ENVRC, .Envrc, ID_RSA,
Id_Rsa, ID_ED25519, .ENV.PRODUCTION and .Env.Local, at all five depths. A
lowercase-only control leaks 80, so the probe is not vacuous. After this
change: zero, with all nine controls still present, including
internal/ID_MAP.go and certs/CA.CRT.

Transferred-context size is recorded but load-bearing on nothing: an earlier
run reported 2.18kB transferred while 43 files, five of them secrets, were in
the image. BuildKit transfers only the delta from the previous build, so the
number describes the transfer and not the contents.

Planted files were removed and their absence confirmed against the filesystem
rather than against `git status`, which could not have seen them.

`make docker` re-run after the change: the check layer executed rather than
being served from cache, so the CHECK_EPOCH verification still holds under the
altered build context.
 2026-08-09 16:42:00 +00:00
clawbot d173e69f85 Make the pinned golangci-lint actually reach the host (closes #28)
check / check (push) Successful in 9s
Details 
REPO_POLICIES.md now carries the canonical script/bootstrap snippet for Go
repos alongside the .golangci.yml bullet, where the pinned linter version
already lives.

The guard it replaces, `if missing golangci-lint; then go install ...; fi`,
tests PATH presence and never version, so on any already-provisioned machine
the pin is inert and a version bump is a no-op. The Dockerfile installs
unconditionally into a clean image, so CI and local then disagree about what
the linter is: a local `make check` green while `make docker` rejects the same
commit, and a container run surfacing findings the host run cannot see.

Comparing versions alone is not enough. `go install` writes to GOBIN (or
GOPATH/bin) while callers resolve through PATH, so a shadowing binary earlier
in PATH lets the install succeed and change nothing a caller ever sees, while
bootstrap prints success. The canonical form therefore compares the installed
version against the pin, re-resolves through PATH after installing and asserts
the pin, and treats any unparseable --version output as a mismatch so the
failure direction is a redundant install rather than a skipped one.

The comparison is exact over the whole version token. 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, reachable
through the comparison meant to close it, and not caught by requiring the pin
to be tagged, since a pre-release is tagged too.

When the assert fails the diagnosis is derived from the resolved path rather
than asserted: a path outside the install directory is shadowing and the
operator is told to remove it or reorder PATH; a path inside it is not, and
saying so would send them after a fault that does not exist; no resolution at
all means the install directory is simply absent from PATH. A trailing slash
on GOBIN is normalised away, since it would otherwise make the inside-the-
directory test miss and misreport shadowing.

The snippet ends with a call site, and both success paths print a confirmation
naming the version. Two definitions with no invocation are a silent no-op with
exactly the shape this change exists to close, and a success path that prints
nothing is byte-identical to that no-op: same exit status, same empty output.

The version helper ends in `|| true` so a --version that exits non-zero cannot
kill the script through `set -e` under `set -o pipefail` before the diagnostic
is printed, which the styleguide's bash form would otherwise do.

The policy text states each of those as a requirement rather than leaving them
implicit in the code, and records why the commit-pinned `go install` ref
satisfies the hash-pinning rule: a commit hash is not a mutable tag, and the
checksum database verifies the fetch, with no repo go.sum consulted, since
`go install pkg@version` ignores the go.mod in the current directory or any
parent. Whether a go.mod tool dependency should replace that is an open
decision and is linked rather than settled here. The two version strings must
be kept in sync and must match exactly what --version prints; tagged pins are
preferred because the expected string is then derivable from the ref, rather
than because the comparison cannot handle a pseudo-version.

Verification runs the controls against the block as a consuming repo would
adopt it, pasted into a script/bootstrap-shaped file and executed, rather than
sourcing it and calling the function directly.

The node and yarn handling described earlier in the document is untouched.
 2026-08-09 16:01:36 +00:00
clawbot 51c394552e Bust the Docker check-layer cache with a per-invocation CHECK_EPOCH (closes #26)
check / check (push) Successful in 7s
Details 
script/cibuild was a plain `docker build .`, and the Dockerfile does
`COPY . .` followed by `RUN make check`. Docker invalidates a COPY layer
only when the copied content changes, so on an unchanged tree the check
layer was served from cache, the suite never ran, and the build still
exited 0. Measured here: run 1 took 18.5s and ran the suite; run 2 on a
byte-identical tree took 0.286s with `RUN make check` CACHED.

script/cibuild and script/docker now assign a per-invocation nonce on its
own line and pass it as --build-arg CHECK_EPOCH. The Dockerfile declares
ARG CHECK_EPOCH, guards it with `[ -n "$CHECK_EPOCH" ] || exit 1`, and
expands it into the check command. Post-fix, two consecutive runs both
execute make check (17.4s / 8.1s) with `RUN script/bootstrap` still
CACHED, so dependency layers are untouched and the build ceiling is not
at risk.

The guard is what makes a bare `docker build .` — the command
REPO_POLICIES named verbatim — fail closed rather than reuse the empty
and therefore stable cache key; verified failing in 0.455s. Holding the
epoch constant restores the false green (run 2 fully CACHED), which pins
the varying value as the operative mechanism rather than a coincidence.

Because the guard references $CHECK_EPOCH it is itself value-keyed:
BuildKit renders the epoch into that layer's description and re-runs the
layer when the value changes. Each stage therefore has two independent
invalidation points, the guard and the expansion, and the guard always
precedes the check RUN. Both are kept and the prose now records this;
the expansion remains defence in depth and is what puts the epoch in the
build log.

The false guarantee was org-canonical text in more than one document, so
it is corrected everywhere it appeared rather than only where the issue
first found it. REPO_POLICIES.md carried it in two places, and its Go
multistage template had check steps in two stages; ARG is stage-scoped,
so both stages get the treatment or the fleet inherits the half-fixed
shape. CODE_STYLEGUIDE_GO.md restated the guarantee for the bare command
this change makes fail closed. NEW_REPO_CHECKLIST.md specified the
pre-fix script/cibuild verbatim, so every new repo would have been born
with the false green, and EXISTING_REPO_CHECKLIST.md ended on a
`docker build` acceptance item that the guard makes unsatisfiable by
design — an agent working that checklist would have been led to delete
the guard to tick the last box. Both checklists' Dockerfile criteria were
also satisfiable by a Dockerfile whose check layers are still frozen, and
now require the ARG and guard in every check-running stage.

REPO_POLICIES.md's own Dockerfile criterion carried that same incomplete
form; it is tightened by cross-reference to the CHECK_EPOCH rule rather
than by duplicating the canonical block. The Go template's Key points
gain a caveat that the cache-bust turns the `COPY --from=lint` no-op into
a content-cache hit, so a repo using a file-dependency trick for stage
ordering must re-prove that ordering on a warm cache after adopting it.
That was re-proved in another repo in the org which uses the trick with a
marker file, where the ordering held; the caveat states explicitly that
it was not verified here, this repo being single-stage with no lint stage
to order against.
 2026-08-09 15:15:03 +00:00
19 changed files with 1060 additions and 842 deletions
Expand all files Collapse all files
.dockerignore
+4 -9
View File
@@ -2,7 +2,7 @@
# moby/patternmatcher: filepath.Match plus `**`, so `*` does not cross # moby/patternmatcher: filepath.Match plus `**`, so `*` does not cross
# `/` and an unprefixed pattern is anchored at the context root. Every # `/` and an unprefixed pattern is anchored at the context root. Every
# depth-independent pattern therefore needs `**/`, or `config/.env` and # depth-independent pattern therefore needs `**/`, or `config/.env` and
# `certs/server.key` still ship while this file reads as solved. Only # `certs/server.key` still ship while the file reads as solved. Only
# genuinely root-anchored entries go unprefixed. Never transplant these # genuinely root-anchored entries go unprefixed. Never transplant these
# into .gitignore, where `**/` is wrong. # into .gitignore, where `**/` is wrong.
# #
@@ -13,14 +13,9 @@
# `/myapp`, never `**/myapp`, which also matches `cmd/myapp/` and # `/myapp`, never `**/myapp`, which also matches `cmd/myapp/` and
# deletes the package directory from the context. # deletes the package directory from the context.
# .git is sent without its config. Without a VERSION build argument the # Excluding .git means `git describe` cannot run in any build stage and
# stage that compiles runs `git describe --tags --always` on .git, which # fails quietly there; pass the version in with --build-arg VERSION.
# does not need .git/config; that file can hold a credential, such as a .git
# password in a remote URL or the token the CI checkout step stores there.
# Each submodule keeps a config with the same exposure in its git directory
# under .git/modules/, nested again for a submodule's own submodules.
.git/config
.git/modules/**/config
# Agent scratch: one full checkout of the repo per in-flight agent. # Agent scratch: one full checkout of the repo per in-flight agent.
# Anchored because it occurs once where agents run at the repo root. # Anchored because it occurs once where agents run at the repo root.
.gitignore
+5 -23
View File
@@ -20,26 +20,8 @@ Thumbs.db
# Node # Node
node_modules/ node_modules/
# Secrets. Unanchored like every entry above, so each matches at every # Environment / secrets
# depth. Matching is case-sensitive on Linux, so names use character .env
# ranges rather than a lowercase form that misses `Server.Key`. .env.*
*.pem
# Environment files. `*.env` covers bare `.env` and the `prod.env` *.key
# convention. Only the templates `example.env` and `sample.env` are
# re-included below. A repository that commits any other template adds
# its own negation after these lines, for example `!.env.example`.
*.[eE][nN][vV]
.[eE][nN][vV].*
.[eE][nN][vV][rR][cC]
!example.env
!sample.env
# Private keys and the bundles carrying them.
*.[pP][eE][mM]
*.[kK][eE][yY]
*.[pP]12
*.[pP][fF][xX]
[iI][dD]_[rR][sS][aA]
[iI][dD]_[dD][sS][aA]
[iI][dD]_[eE][cC][dD][sS][aA]
[iI][dD]_[eE][dD]25519
.golangci.yml
+2 -67
View File
@@ -10,21 +10,14 @@ run:
linters: linters:
default: all default: all
enable:
# Successor to the deprecated gomodguard. Named explicitly, rather than
# left to `default: all`, because it carries the module policy below.
- gomodguard_v2
disable: disable:
# Genuinely incompatible with project patterns # Genuinely incompatible with project patterns
- exhaustruct # Requires all struct fields - exhaustruct # Requires all struct fields
- exhaustruct_v5 # Requires all struct fields (successor to exhaustruct) - depguard # Dependency allow/block lists
- godot # Requires comments to end with periods - godot # Requires comments to end with periods
- wsl # Deprecated, replaced by wsl_v5
- wrapcheck # Too verbose for internal packages - wrapcheck # Too verbose for internal packages
- varnamelen # Short names like db, id are idiomatic Go - varnamelen # Short names like db, id are idiomatic Go
# Deprecated: the warning is attached to the old name, so it is
# silenced by disabling that name, not by enabling the successor.
- wsl # Deprecated, replaced by wsl_v5
- gomodguard # Deprecated, replaced by gomodguard_v2
settings: settings:
lll: lll:
line-length: 88 line-length: 88
@@ -35,64 +28,6 @@ linters:
max-complexity: 15 max-complexity: 15
dupl: dupl:
threshold: 100 threshold: 100
depguard:
# Test-support code must not be compiled into the shipped binary. A
# test-support package exists to hand a test privileges the program
# itself must never have, so a file that is not a test must not import
# one. Test files, and the files inside a package whose directory name
# ends in `test`, are where that code belongs, and are exempt.
#
# The deny list below is the one part of this file a repository is
# expected to extend, and the only part it may. depguard matches an
# import path against a list of prefixes, so it cannot be told "any path
# whose last segment ends in test"; a repository's own test-support
# packages have to be named here one at a time, by full import path,
# under a module path that differs from repository to repository. Add
# them; change nothing else.
rules:
test-support:
list-mode: lax
files:
- "$all"
- "!$test"
- "!**/*test/**"
deny:
- pkg: net/http/httptest
desc: >-
Test-support code belongs in test files and in packages whose
directory name ends in test, not in the shipped binary.
# Only decisions already recorded in the Go package defaults are
# listed here. Every entry matches the module path exactly.
gomodguard_v2:
blocked:
- module: github.com/rs/zerolog
recommendations:
- log/slog
reason: "Structured logging is stdlib log/slog."
# One entry per pre-fork module path, because the later releases
# are separate paths. A prefix match would be shorter but would
# also reach github.com/go-redis/redismock, the test double for
# the successor these entries recommend.
- module: github.com/go-redis/redis
recommendations:
- github.com/redis/go-redis/v9
reason: "Pre-fork module; use the maintained go-redis v9."
- module: github.com/go-redis/redis/v7
recommendations:
- github.com/redis/go-redis/v9
reason: "Pre-fork module; use the maintained go-redis v9."
- module: github.com/go-redis/redis/v8
recommendations:
- github.com/redis/go-redis/v9
reason: "Pre-fork module; use the maintained go-redis v9."
- module: github.com/sergi/go-diff
recommendations:
- github.com/aymanbagabas/go-udiff
reason: "No unified diff output; use go-udiff."
- module: github.com/hexops/gotextdiff
recommendations:
- github.com/aymanbagabas/go-udiff
reason: "Unmaintained fork; use go-udiff."
issues: issues:
max-issues-per-linter: 0 max-issues-per-linter: 0
Dockerfile
+14 -45
View File
@@ -1,48 +1,11 @@
# Lint phase. The linter is invoked directly rather than through `make
# lint` or `script/lint`, which are themselves a docker build and would
# recurse into a daemon that does not exist in a build step.
#
# node 22-alpine, 2026-02-22
FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS lint
WORKDIR /app
COPY script/ script/
COPY package.json yarn.lock ./
RUN script/bootstrap
COPY . .
RUN yarn run prettier --check '**/*.md' --tab-width 4 --prose-wrap always
# Test phase, same shape and for the same reason.
#
# node 22-alpine, 2026-02-22
FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 AS test
WORKDIR /app
COPY script/ script/
COPY package.json yarn.lock ./
RUN script/bootstrap
COPY . .
RUN echo "No tests defined."
# Development environment, and the last stage: a plain `docker build .`
# names no target and so builds this one. Nothing is wanted from the two
# phases above; the copies are what make BuildKit build them first, so
# this image cannot be produced unless lint and test passed. A stage
# appended after this one would drop all three out of a plain build.
#
# node 22-alpine, 2026-02-22 # node 22-alpine, 2026-02-22
FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34 FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34
WORKDIR /app WORKDIR /app
COPY --from=lint /app/package.json /dev/null # Makes script/lint run the linter directly rather than building
COPY --from=test /app/package.json /dev/null # Dockerfile.lint, which would need a docker daemon here.
ENV LINT_IN_CONTAINER=1
# script/bootstrap installs all prerequisites. Manifests are copied # script/bootstrap installs all prerequisites. Manifests are copied
# first so that layer stays cached until dependencies change. # first so that layer stays cached until dependencies change.
@@ -52,8 +15,14 @@ RUN script/bootstrap
COPY . . COPY . .
# Nothing here is compiled and a LABEL cannot run git, so the version is # CHECK_EPOCH is a per-invocation nonce from script/cibuild and
# the VERSION build argument that script/docker and script/cibuild pass; # script/docker; without it an unchanged tree serves this layer from
# a plain `docker build .` leaves it empty. # cache and the build reports a green it never ran. ARG is stage-scoped,
ARG VERSION # so declare it in every stage that runs checks. The guard fails a bare
LABEL org.opencontainers.image.version="${VERSION}" # `docker build .`, which would otherwise reuse the empty (and therefore
# stable) cache key. The value is also expanded into the check command,
# so the cache miss does not depend on BuildKit's handling of an
# unreferenced ARG; keep both references.
ARG CHECK_EPOCH
RUN [ -n "$CHECK_EPOCH" ] || exit 1
RUN echo "check epoch: ${CHECK_EPOCH}" && make check
Dockerfile.lint
+27
View File
@@ -0,0 +1,27 @@
# Lint-only image, built by script/lint when it is not already inside a
# container. Linting is a build step, so a successful build is a clean
# lint, and nothing is bind-mounted, which matters when the daemon is
# remote.
#
# node 22-alpine, 2026-02-22
FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e34
WORKDIR /app
# Makes script/lint run the linter directly instead of recursing into
# another docker build, which has no daemon here.
ENV LINT_IN_CONTAINER=1
COPY script/ script/
COPY package.json yarn.lock ./
RUN script/bootstrap
COPY . .
# ARG sits after the dependency layer so that layer stays cached and
# only the lint re-runs. The guard fails a bare `docker build
# -f Dockerfile.lint .`, which would otherwise reuse the empty (stable)
# cache key and report a lint it never ran.
ARG CHECK_EPOCH
RUN [ -n "$CHECK_EPOCH" ] || exit 1
RUN echo "lint epoch: ${CHECK_EPOCH}" && make lint
README.md
+15 -16
View File
@@ -116,23 +116,22 @@ alpine. We provide:
`script/bootstrap`, then `script/install-precommit` `script/bootstrap`, then `script/install-precommit`
- `script/projectname` — output the project name (our own extension); used by - `script/projectname` — output the project name (our own extension); used by
`script/docker` for the image tag `script/docker` for the image tag
- `script/test` — `docker build --no-cache --target test -t prompts-test .`, - `script/test` — run the test suite (no tests defined here)
building the `test` phase of the `Dockerfile` (no tests defined here) - `script/lint` — lint the markdown files with prettier. Inside a container
- `script/lint` — `docker build --no-cache --target lint -t prompts-lint .`, (`LINT_IN_CONTAINER=1`, set by both Dockerfiles) it runs prettier directly; on
building the `lint` phase, which runs prettier over the markdown files a host it builds `Dockerfile.lint` so the linter still runs in a container
- `script/fmt` — format all markdown files with prettier (writes; native, not in - `script/fmt` — format all markdown files with prettier (writes)
a container) - `script/fmt-check` — check formatting (read-only)
- `script/fmt-check` — check formatting (read-only; native)
- `script/check` — run all checks: `test`, `lint`, `fmt-check` (our own - `script/check` — run all checks: `test`, `lint`, `fmt-check` (our own
extension); builds no image of its own extension)
- `script/docker` — - `script/docker` — build the Docker image, tagged via `script/projectname`
`docker build --no-cache --build-arg VERSION="$version" -t prompts .`, the tag (byte-identical across repos); passes the same `CHECK_EPOCH` nonce as
coming from `script/projectname` (byte-identical across repos) `script/cibuild`
- `script/cibuild` — cd to the repo root, run `script/bootstrap`, run - `script/cibuild` — cd to the repo root, assign `epoch="$(date +%s%N)$$"`, then
`script/check`, compute `version` from `git describe`, then `docker build --build-arg CHECK_EPOCH="$epoch" .` (what CI runs; the image
`docker build --no-cache --build-arg VERSION="$version" -t prompts .` (what CI build runs `script/check`, and the per-invocation `CHECK_EPOCH` nonce is what
runs; it bootstraps because CI checks out and runs this alone while stops Docker serving that check from cache on an unchanged tree — a bare
`script/fmt-check` is native) `docker build .` fails closed on purpose)
- `script/precommit` — run by the git pre-commit hook (our own extension); calls - `script/precommit` — run by the git pre-commit hook (our own extension); calls
`script/check` `script/check`
- `script/install-precommit` — installs the git pre-commit hook (our own - `script/install-precommit` — installs the git pre-commit hook (our own
TODO.md
+111 -81
View File
@@ -21,87 +21,117 @@ fmt-check, and commit.
# Completed Steps # Completed Steps
- 2026-10-04: `REPO_POLICIES.md` now states that guidance for coding agents - 2026-08-25: Carved capability-URL services out of "when in doubt, harden" in
lives in one `AGENTS.md` at the repository root, never under a file or REPO_POLICIES.md: an unguessable per-entrypoint UUID URL is a complete
directory named after one agent tool and never in separate memory files (issue credential and gets no second authentication factor.
31). This retires the rule, still present in older vendored copies, that kept - 2026-08-10: Moved every lint run into a container. `script/lint` now runs the
agent memory as committed files under `.claude/memory/`. `AGENTS.md` joins the linter directly when `LINT_IN_CONTAINER=1` and otherwise builds
list of files allowed in the root, and both checklists say so. `Dockerfile.lint`, so the linter never runs on a developer host — closing the
- 2026-10-04: The canonical `.dockerignore` now also keeps out each submodule's content-keyed result cache that produced a confirmed false green, the
`config` (issue 75). A submodule's git directory lives under `.git/modules/`, host-global `$TMPDIR/golangci-lint.lock`, and host/container version skew.
nested again for its own submodules, and its `config` can hold a credential Detection is on that marker alone: a false negative inside a container fails
just like `.git/config`. The pattern `.git/modules/**/config` covers every loudly on the missing daemon, while a false positive on a host would silently
depth and leaves the top-level `.git` that `git describe` reads untouched. restore host linting, so `/.dockerenv` is rejected outright — measured absent
`REPO_POLICIES.md` and both checklists say so in the same words. inside BuildKit `RUN` steps and present on hosts that are themselves
- 2026-10-03: Fixed two defects in the canonical Go `Dockerfile` example (issue containers. Everything else keeps its existing shape: `make check` still runs
73). The test phase now uses the Debian Go image, since `-race` needs cgo and in the image, `script/cibuild` is still one build, and the Go multistage lint
the alpine image has no C compiler, so the phase failed before running a test. stage survives with `ENV LINT_IN_CONTAINER=1`. `Dockerfile.lint` carries the
The stage that compiles runs `git config --system --add safe.directory /src`, same `CHECK_EPOCH` guard, with the `ARG` below the dependency layer so only
because a context sent as a tar stream keeps the sender's file owners and git the lint re-runs. The `script/bootstrap` golangci-lint install and the
refuses that checkout, leaving the version empty. Both checklists state that per-checkout cache/lock/`.lint-cache` wrapper are deleted as superseded; a JS
step in the same words. repo's `yarn install` stays, since the rule is about where a verdict comes
- 2026-10-03: Moved the canonical golangci-lint to v2.14.0, built with go1.27, from, not about which binaries exist. `golangci-lint config verify` was kept
because v2.12.2 refuses to lint a module whose `go` directive is 1.27 (issue on measurement: a bogus config key passes `golangci-lint run` with `0 issues`
65). Releases from v2.13.0 deprecate `exhaustruct` in favour of and fails `config verify`, and every case reproduced byte-identically under
`exhaustruct_v5`, which `default: all` switches on, so the canonical `--network none`, so the schema is embedded and the line costs no network.
`.golangci.yml` now disables `exhaustruct_v5` beside `exhaustruct`. v2.12.2 Comment blocks across the touched files were cut hard in the same pass.
rejects that file, so `REPO_POLICIES.md` and both repo checklists now say a - 2026-08-09: Made a golangci-lint result belong to the tree that asked for it.
repo sets the lint phase digest and re-vendors `.golangci.yml` in one commit. REPO_POLICIES.md now carries the canonical Go `script/lint`, which gives the
- 2026-10-03: Brought the canonical `.gitignore` level with `.dockerignore` on linter per-checkout `GOLANGCI_LINT_CACHE` and per-checkout `TMPDIR`. The two
secrets (issue 38): it now also ignores `prod.env`-style `*.env` files, are separate defects and the second is the one that gets dropped: the result
`.envrc`, `*.p12`, `*.pfx` and the extensionless SSH private keys, written to cache is keyed on file content rather than location, so checkouts holding
`.gitignore`'s own rules (no `**/` prefix) and case-folded with character identical files serve each other's findings under the other's path, while the
ranges. `example.env` and `sample.env` stay trackable through negations. concurrency lock is `$TMPDIR/golangci-lint.lock` — host-global, independent of
- 2026-10-02: The image version now comes from git inside the build (issues 69 the cache, and unaffected by isolating it. Moving workers from worktrees to
and 71), superseding the 2026-09-08 entry that excluded `.git`. The canonical their own clones does not help either half; it only removes the foreign-path
`.dockerignore` sends `.git` but keeps out `.git/config`, which can hold a artefact that made the defect visible. The lock error is retried rather than
credential. The Dockerfile example in `REPO_POLICIES.md` installs `git`, takes surfaced, because it is not a result: it exits non-zero exactly as findings
the `VERSION` build argument when one is given and otherwise do, and reporting it as findings sends a correct branch back for rework.
`git describe --tags --always`, and fails when `.git` exists but the version Detection is on the stderr stream and never on exit status, so a finding
is empty, `dev` or `unknown`; a plain `docker build .` with no build arguments quoting the lock message in source cannot be retried away, and exhaustion
must succeed. This repo's `script/docker` and `script/cibuild` still pass exits 75 with a VOID message rather than passing or failing quietly.
`--build-arg VERSION`, since its own `Dockerfile` compiles nothing. `--allow-serial-runners` (which keeps the guard and queues) covers the
- 2026-09-08: Moved linting and testing into Docker as phases of the main same-checkout overlap that `TMPDIR` scoping cannot; `--allow-parallel-runners`
`Dockerfile`, per the owner ruling on issue 40. `script/lint` and is rejected outright. The stdout and stderr capture files are per invocation
`script/test` build one phase each by name with `--no-cache` — the same answer rather than per checkout, because serialising the linter does not serialise
issue 26 got, so no separate cache-busting mechanism survives — and the final the shell's redirections: two runs in one checkout — the overlap the flag
stage copies a harmless file from both, so the image cannot be built unless exists to support — would otherwise truncate and read each other's output,
they pass. This also closes issue 30: a container has its own result cache and which is the same defect one layer above where it was fixed. Both checklists
its own lock, so a lint verdict can no longer belong to another checkout. No gained the corresponding items, since a half-fix that sets only the cache
separate lint Dockerfile, and no `golangci-lint config verify` step. reads as complete. `GOCACHE` was measured and does not need isolating.
`script/check` runs the gates and nothing else, and `script/cibuild` Verified with the snippet extracted from the committed document and executed
bootstraps first, since it is all CI runs and `script/fmt-check` is native. as a consuming repo would adopt it, against paired controls: contamination
- 2026-09-08: Kept in-repo agent scratch out of the Docker build context and out reproduced on the pre-fix form and absent on the adopted one, retry engaged,
of version control: `.claude/` is one full checkout of the repo per in-flight exhaustion loud, a genuine finding still reported, and a held host lock
agent, and under `COPY . .` all of it was reaching the image. Also closed the failing the pre-fix script while leaving the adopted one untouched.
consequence of excluding `.git` — `git describe` yields an empty version - 2026-08-09: Kept in-repo agent scratch out of the Docker build context and out
inside a build stage without failing, so `script/docker` and `script/cibuild` of version control. `.claude/` holds one worktree — an entire additional
now compute the version on the host and pass `--build-arg VERSION`. checkout of the repo — per in-flight agent, and under `COPY . .` all of it was
- 2026-09-08: Closed the secret exposure in the canonical `.dockerignore`: a reaching the image: another session's unreviewed, sometimes uncommitted work,
local `.env`, `*.pem` or `*.key` was reaching the build context under inflating the context by a multiple of the repo and invalidating `COPY` for
`COPY . .`, invisible to every git-based check. The patterns are now written reasons unrelated to the repo's own content. The `.dockerignore` entry is
to `.dockerignore`'s own semantics — `**/`-prefixed so they hold at every root-anchored, because the directory occurs exactly once where agents run at
depth, case-folded with character ranges — and `REPO_POLICIES.md` requires the repo root and the `**/` form additionally deletes any nested directory of
verifying by enumerating the image rather than by reading the file. that name — with the residual gap that follows from anchoring (a monorepo
- 2026-09-08: Made a pinned tool in `script/bootstrap` actually reach the host. running agents in subdirectories still ships `services/api/.claude/`) stated
`REPO_POLICIES.md` now requires comparing the installed version against the in the canonical `.dockerignore`, the policy and the existing-repo checklist,
pin rather than testing `PATH` presence, and re-resolving the binary through since consuming repos receive the files rather than the tracker; the
`PATH` after installing, so a version bump cannot be a silent no-op and a `.gitignore` entry is unanchored, because `.gitignore` patterns already match
shadowed install cannot report success. at every depth, and each file is written to its own semantics rather than
- 2026-09-08: Closed the false green in the canonical CI gate: `script/cibuild` derived from the other. Also closed the consequence that ships broken
and `script/docker` now build with `--no-cache`, so the Dockerfile's check silently: excluding `.git` means `git describe` cannot run in any build stage
layers cannot be served from cache on an unchanged tree, and the text claiming and yields an empty version without erroring, so `script/docker` and
a bare `docker build .` proves the checks ran is corrected in `script/cibuild` now compute the version on the host and pass
`REPO_POLICIES.md`, both checklists and the Go styleguide. `--build-arg VERSION`, and `REPO_POLICIES.md` states where `VERSION` comes
- 2026-09-03: Added `-count=1` to both `go test` invocations in the canonical Go from instead of leaving the reader to fill the gap with `git describe` inside
`make test` example in `REPO_POLICIES.md`, so the target cannot report a the build. The two Go documents that carry the `GOLDFLAGS` pattern were
cached pass it did not earn, and documented that Go's test-result cache is a corrected in the same pass, from `:=` to `?=`, since a `$(shell git describe)`
second, independent cache stacked below the Docker layer cache. evaluated inside a build stage is exactly the empty version this closes.
- 2026-08-31: Migrated the canonical `.golangci.yml` from the deprecated Verified by enumerating a probe image before, after, and against the
`gomodguard` to `gomodguard_v2`: the old linter is disabled by name (which is `**/`-prefixed form, with a positive control and the `CHECK_EPOCH` cache
what silences the deprecation warning), the successor is named explicitly in verification re-run under the changed build context.
`linters.enable`, and it carries a `blocked` module list drawn only from - 2026-08-09: Closed the secret exposure in the canonical `.dockerignore`: a
decisions already recorded in the Go package defaults. 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 - 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 config already deployed byte-identical across the org's Go repos (settings
under `linters.settings` so thresholds like lll/funlen/cyclop/dupl actually under `linters.settings` so thresholds like lll/funlen/cyclop/dupl actually
prompts/CODE_STYLEGUIDE_GO.md
+41 -30
View File
@@ -1,6 +1,6 @@
--- ---
title: Code Styleguide — Go title: Code Styleguide — Go
last_modified: 2026-10-02 last_modified: 2026-08-10
--- ---
1. Try to hard wrap long lines at 77 characters or less. 1. Try to hard wrap long lines at 77 characters or less.
@@ -24,8 +24,7 @@ last_modified: 2026-10-02
1. Embed the git commit hash into the binary and include it in startup logs and 1. Embed the git commit hash into the binary and include it in startup logs and
in health check output. This is to make it easier to correlate running in health check output. This is to make it easier to correlate running
instances with their code. Do not include build time or build user, as these instances with their code. Do not include build time or build user, as these
will make the build nondeterministic. The architecture is not passed in at will make the build nondeterministic.
build time; a program that reports it reads `runtime.GOARCH` at run time.
Example relevant Makefile sections: Example relevant Makefile sections:
@@ -36,25 +35,38 @@ last_modified: 2026-10-02
import ( import (
"fmt" "fmt"
"runtime"
) )
var Version string var (
Version string
Buildarch string
)
func main() { func main() {
fmt.Printf("Version: %s\n", Version) fmt.Printf("Version: %s\n", Version)
fmt.Printf("Arch: %s\n", runtime.GOARCH) fmt.Printf("Buildarch: %s\n", Buildarch)
} }
``` ```
```make ```make
# ?= rather than := so that a `VERSION` build argument takes precedence: # ?= rather than := because this `$(shell git describe ...)` is only
# where a build stage invokes make, `ARG VERSION` puts it in the # correct on the host. `.dockerignore` excludes `.git`, so evaluated
# environment and `?=` defers to it. Otherwise `git describe` runs, in a # inside a build stage it expands to the empty string without failing
# build stage on the `.git` the build context carries. # and the binary reports no version at all. The version is computed on
VERSION ?= $(shell git describe --tags --always) # 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) GOLDFLAGS += -X main.Version=$(VERSION)
GOLDFLAGS += -X main.Buildarch=$(BUILDARCH)
# osx can't statically link apparently?! # osx can't statically link apparently?!
ifeq ($(UNAME_S),Darwin) ifeq ($(UNAME_S),Darwin)
@@ -100,18 +112,22 @@ last_modified: 2026-10-02
1. For anything beyond a simple script or tool, or anything that is going to 1. For anything beyond a simple script or tool, or anything that is going to
run in any sort of "production" anywhere, make sure it passes run in any sort of "production" anywhere, make sure it passes
`golangci-lint`. Run it with `make lint`, never by invoking the binary: the `golangci-lint`. Run it with `make lint`, never by invoking the binary: the
linter runs as a phase of the `Dockerfile` and is not installed on the host linter always runs in a container, and `golangci-lint` is not installed on
by any repo. Invoked directly on a shared host it reads a result cache keyed the host by any repo. Invoked directly on a shared host it reads a result
on file content rather than location, and a host-global lock, so its answer cache keyed on file content rather than location, and a host-global lock, so
may belong to another checkout entirely. its answer may belong to another checkout entirely.
1. Write a `Dockerfile` for every repo, even if it only runs the tests and 1. Write a `Dockerfile` for every repo, even if it only runs the tests and
linting. It carries the lint and test phases, and the final stage depends on linting. `script/cibuild` and `script/docker` should always make sure that
both, so a build makes sure the code is in an able-to-be-compiled state, the code is in an able-to-be-compiled state, linted, and any tests run, and
linted, and its tests run. Go through `script/cibuild` or `script/docker` the build should fail if linting doesn't pass. That guarantee holds only
rather than a bare `docker build .`: they pass `--no-cache`, without which because those scripts pass a per-invocation `CHECK_EPOCH` build arg that
an unchanged tree serves the gate layers from cache and the build reports a busts the check layers out of the Docker cache; without it an unchanged tree
green it never ran. 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 1. Every repo must have a `Makefile`. See
[Repository Policies](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md) [Repository Policies](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md)
@@ -132,15 +148,10 @@ last_modified: 2026-10-02
1. Keep the `main()` function as small as possible. 1. Keep the `main()` function as small as possible.
1. Keep the `main` package as small as possible. Each `cmd/<name>/` directory 1. Keep the `main` package as small as possible. Move as much code as is
contains a single `main.go` whose body is one call into library code (for feasible to a library package, even if it's an internal one. `main` is just
example `os.Exit(cli.Main())` calling `internal/cli`). All CLI logic — flag an entrypoint to your code, not a place for implementations. Exception:
parsing, subcommand dispatch, argument handling, output formatting — lives single-file scripts.
in `internal/` or `pkg/`, not in `cmd/`. `main` is just an entrypoint to
your code, not a place for implementations. Exception: single-file scripts.
1. No project logic outside `internal/` or `pkg/`. Anything in `cmd/` is a thin
entrypoint only.
1. HTTP HandleFuncs should be returned from methods or functions that need to 1. HTTP HandleFuncs should be returned from methods or functions that need to
handle HTTP requests. Don't use methods or your top level functions as handle HTTP requests. Don't use methods or your top level functions as
prompts/EXISTING_REPO_CHECKLIST.md
+75 -87
View File
@@ -1,6 +1,6 @@
--- ---
title: Existing Repo Checklist title: Existing Repo Checklist
last_modified: 2026-10-04 last_modified: 2026-08-10
--- ---
Use this checklist when beginning work in a repo that may not yet conform to our Use this checklist when beginning work in a repo that may not yet conform to our
@@ -24,75 +24,71 @@ with your task.
- [ ] `LICENSE` file exists and matches the README - [ ] `LICENSE` file exists and matches the README
- [ ] `REPO_POLICIES.md` exists and version date is current — fetch from - [ ] `REPO_POLICIES.md` exists and version date is current — fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md` `https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md`
- [ ] Guidance for coding agents, if the repo has any, is one `AGENTS.md` at the
root — never a file or directory named after one agent tool, such as
`CLAUDE.md` or `.claude/`, and never separate memory files. Move what any
such committed file says into `AGENTS.md` and delete it.
- [ ] `.gitignore` is comprehensive (OS, editor, agent scratch, language - [ ] `.gitignore` is comprehensive (OS, editor, agent scratch, language
artifacts, secrets) — fetch from artifacts, secrets) — fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` if missing. `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` if missing.
An existing repo usually has a hand-written one that is never re-fetched, An existing repo usually has a hand-written one that is never re-fetched,
so check the entries rather than the file's presence. 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 - [ ] `.editorconfig` exists — fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.editorconfig` `https://git.eeqj.de/sneak/prompts/raw/branch/main/.editorconfig`
- [ ] `Dockerfile` and `.dockerignore` exist; the Dockerfile carries a `lint` - [ ] `Dockerfile` and `.dockerignore` exist (fetch `.dockerignore` from
phase and a `test` phase, and the final stage carries a `COPY --from=` of `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore`);
a harmless file from each — 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
- [ ] Nothing has been appended after the final stage, and the gate phases are `RUN [ -n "$CHECK_EPOCH" ] || exit 1` guard immediately below it — see the
reachable from it. A stage nothing depends on is built only when `CHECK_EPOCH` rule in `REPO_POLICIES.md`. Without them the check layer is
`--target` names it, so a lost `COPY --from=` edge leaves `docker build .` served from cache on an unchanged tree and the build reports a green it
passing while the gate never runs. Confirm by planting a violation, not by never ran.
reading the file. - [ ] **Every stage that runs checks sets `ENV LINT_IN_CONTAINER=1`** — the lint
- [ ] The gate phases invoke their tools directly, never through `make lint` or stage and the build stage both. This is the item an existing repo most
`script/test` — those are themselves a `docker build` and would recurse often fails after adopting the containerised lint: without it
inside a build step `script/lint` tries to build `Dockerfile.lint` from inside a build step,
- [ ] Every depth-independent pattern in `.dockerignore` carries a `**/` prefix, where there is no daemon.
only genuinely root-anchored entries such as `.claude` are unprefixed, and - [ ] `Dockerfile.lint` exists and `script/lint` builds it when not already in a
`.gitignore`'s patterns have not been transplanted unmodified — the container — see the containerised-lint rule in `REPO_POLICIES.md`. Base
transplanted form leaves `config/.env` and `certs/server.key` in the build image pinned by sha256 with a version/date comment, `ARG CHECK_EPOCH`
context while reading as solved **after** the dependency layer with the guard below it.
- [ ] `.dockerignore` excludes the repo's own host-built artifacts (compiled - [ ] `.dockerignore` excludes the repo's own host-built artifacts (compiled
binaries, test binaries, coverage output), written root-anchored — binaries, test binaries, coverage output), written root-anchored —
`/myapp`, never `**/myapp`. An existing repo is where such a binary is `/myapp`, never `**/myapp`, which would also match `cmd/myapp/`. An
likeliest to already be sitting in the build context, invisible to git. existing repo is where such a binary is likeliest to already be sitting in
- [ ] `.claude/` is in `.gitignore` (unanchored) and `.claude` in the build context, invisible to git.
`.dockerignore` (anchored, no `**/` prefix). Agent worktrees are entire - [ ] `.dockerignore` excludes `.claude`, root-anchored and with no `**/`
checkouts of the repo, so they inflate the context by a multiple of it and prefix. Agent worktrees are entire checkouts of the repo, so they inflate
can copy another session's unreviewed work into an image layer. If agents the context by a multiple of it and can copy another session's unreviewed
here run anywhere other than the repo root, the anchored entry misses work into an image layer. Confirm by enumerating the image, not by reading
`services/api/.claude/`: add anchored entries for those directories. the file — `.gitignore` hides these from `git status` too.
- [ ] If the repo embeds a version in a binary: `.dockerignore` lets `.git` into - [ ] **Do agents in this repo run anywhere other than the repo root?** The
the build context. It keeps out `.git/config` and each submodule's scratch directory is created in the agent's working directory, so the
`config` under `.git/modules/` at any depth (`.git/modules/**/config`), canonical anchored entry misses `services/api/.claude/` in a monorepo with
which `git describe` does not need and which can hold a credential: a a per-service agent — it still reaches the build context and the image. An
password in a remote URL, or the token the CI checkout step stores there. existing repo is where such a layout already exists, so check it here
The stage that compiles has `git` (the Debian Go image has it; an alpine rather than assuming the canonical entry covers you: add anchored entries
one needs `apk add --no-cache git`) and takes the version from the for the subdirectories that have one (`/services/api/.claude`), or
`VERSION` build argument when one is given, otherwise from `**/.claude` once you have confirmed no legitimately named nested
`git describe --tags --always`. That gives the tag on a tagged commit; on directory would be caught.
a later commit, the tag, the number of commits since it and the short - [ ] If the repo embeds a version in a binary, that version is computed on the
commit (`v1.2.3-4-gabc1234`); and the short commit when no tag is host and passed with `--build-arg VERSION=...` by `script/docker` and
reachable. The stage that compiles also marks its working directory safe `script/cibuild`. No stage calls `git describe`: `.dockerignore` excludes
for git (`git config --system --add safe.directory /src`): a context sent `.git`, so it yields an empty version without failing the build. A
as a tar stream keeps the sender's file owners, and git refuses a checkout tag-derived version additionally needs `fetch-depth: 0` on the CI checkout
owned by another user, so the version would come out empty. `ARG VERSION` step, which clones shallow and fetches no tags by default.
has no default, and the build fails if the context carries `.git` and the - [ ] Every depth-independent pattern in `.dockerignore` carries a `**/` prefix;
version still comes out empty, `dev` or `unknown`. A plain only genuinely root-anchored entries such as `.git` are unprefixed, and
`docker build .` with no build arguments must succeed; a Dockerfile that `.gitignore`'s patterns have not been transplanted unmodified.
refuses an empty build argument drops that refusal and keeps the argument. `.dockerignore` anchors an unprefixed pattern at the context root, so the
`script/docker` and `script/cibuild` pass the version they compute on the transplanted form leaves `config/.env` and `certs/server.key` in the build
host; it takes precedence. A tag-derived version additionally needs context while reading as solved — see the `.dockerignore` rule in
`fetch-depth: 0` on the CI checkout step, which clones shallow and fetches `REPO_POLICIES.md`.
no tags by default.
- [ ] Gitea Actions workflow in `.gitea/workflows/` runs `script/cibuild` on - [ ] Gitea Actions workflow in `.gitea/workflows/` runs `script/cibuild` on
push — reference push — reference
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitea/workflows/check.yml` `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitea/workflows/check.yml`
- [ ] Language-specific config: - [ ] Language-specific config:
- [ ] Go: `go.mod`, `go.sum`, `.golangci.yml` (fetch from - [ ] Go: `go.mod`, `go.sum`, `.golangci.yml` (fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml` and, `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`)
in the same commit, set the lint phase digest to the one named in the
`.golangci.yml` paragraph of `REPO_POLICIES.md`)
- [ ] JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore` - [ ] JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
(fetch from (fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.prettierrc` and `https://git.eeqj.de/sneak/prompts/raw/branch/main/.prettierrc` and
@@ -113,33 +109,26 @@ with your task.
`script/install-precommit`, shimmed by `make hooks`) runs it `script/install-precommit`, shimmed by `make hooks`) runs it
- [ ] README has an **Entrypoints** section documenting the `script/` - [ ] README has an **Entrypoints** section documenting the `script/`
entrypoints and linking the standard entrypoints and linking the standard
- [ ] `script/lint` and `script/test` build their phase by name - [ ] `script/lint` is the canonical detect-and-branch form, and no host
(`docker build --no-cache --target <phase> -t <name>-<phase> .`), and no invocation anywhere in the repo can produce a lint **verdict** — grep for
host invocation anywhere in the repo can produce a lint verdict — grep for
the linter's own name across `script/`, the `Makefile` and CI config, not the linter's own name across `script/`, the `Makefile` and CI config, not
just `script/lint`. A second path is likeliest here: a `make lint-fast`, just `script/lint`. A second path is likeliest here: a `make lint-fast`,
an older host-versus-container branch, or a CI step calling the binary an older container-versus-host branch, or a CI step calling the binary
directly. `script/fmt` and `script/fmt-check` are expected hits and stay directly. **Expected hits that are not the defect**: `script/fmt`, and in
on the host. a repo whose formatter is also its linter, `script/fmt-check`. Everything
- [ ] Every `docker build` in `script/` is tagged — an untagged one leaves a else the grep finds is a real second path and goes.
dangling image behind on every run, on every host and CI runner - [ ] Detection is on `LINT_IN_CONTAINER` alone. Reject any `/.dockerenv` or
- [ ] `script/cibuild` runs `script/bootstrap` before `script/check`, and builds cgroup heuristic: absent in BuildKit `RUN` steps, present on hosts that
the image with `--no-cache`. Without the bootstrap the CI run dies in are themselves containers, and a false positive lints on the host.
`script/fmt-check`, which runs the formatter on the host and finds nothing - [ ] `script/bootstrap` installs no golangci-lint. Delete the block, its
installed. version and ref variables, and its call site. A JS repo's `yarn install`
- [ ] `script/fmt` and `script/fmt-check` source nvm for the pinned node version stays — it brings a linter along with every other dependency, which is
before invoking `yarn`, as `script/bootstrap`'s own install step does. fine as long as no verdict is taken from it.
`script/bootstrap` leaves the node and yarn it installs off the `PATH` of - [ ] The per-checkout lint state is gone: no `GOLANGCI_LINT_CACHE` or `TMPDIR`
the shell that called it, so a bare `yarn` exits 127 on a runner carrying exports, no `--allow-serial-runners`, and `.lint-cache/` removed from
nothing but docker and git. `.gitignore` and `.dockerignore`.
- [ ] `script/bootstrap` installs no linter of its own — delete the block, its
version variables and its call site. A JS repo's `yarn install` stays; it
brings a linter along with every other dependency, and no verdict is taken
from it.
- [ ] `make check` does not modify any files in the repo - [ ] `make check` does not modify any files in the repo
- [ ] `make test` has a 90-second timeout and completes within the 60-second - [ ] `make test` has a 30-second timeout
hard cap (over 20 seconds is green but must be filed as an improvement
bug)
- [ ] `make test` runs real tests, not a no-op (at minimum, import/compile - [ ] `make test` runs real tests, not a no-op (at minimum, import/compile
check) check)
- [ ] `make check` passes on current branch - [ ] `make check` passes on current branch
@@ -184,10 +173,9 @@ with your task.
# Final # Final
- [ ] `make check` passes - [ ] `make check` passes
- [ ] `script/cibuild` succeeds in a fresh clone on a host carrying nothing but - [ ] `make lint` runs twice on an unchanged tree with the lint layer `DONE`
docker and git, with no node or yarn on `PATH`, which is what CI has, and both times, never `CACHED` and never sub-second
demonstrably executed the checks — a sub-second build, or `CACHED` on a - [ ] `script/cibuild` succeeds (a bare `docker build .` or
gate layer, means nothing ran `docker build -f Dockerfile.lint .` fails closed by design, on the
- [ ] A planted lint violation fails both `make lint` and a plain `CHECK_EPOCH` guard)
`docker build .`; revert it afterwards
- [ ] Commit and merge fixes before starting your actual task - [ ] Commit and merge fixes before starting your actual task
prompts/GO_HTTP_SERVER_CONVENTIONS.md
+28 -17
View File
@@ -1,6 +1,6 @@
--- ---
title: Go HTTP Server Conventions title: Go HTTP Server Conventions
last_modified: 2026-10-02 last_modified: 2026-08-09
--- ---
This document defines the architectural patterns, design decisions, and This document defines the architectural patterns, design decisions, and
@@ -118,13 +118,15 @@ import (
) )
var ( var (
Appname string = "CHANGEME" Appname string = "CHANGEME"
Version string Version string
Buildarch string
) )
func main() { func main() {
globals.Appname = Appname globals.Appname = Appname
globals.Version = Version globals.Version = Version
globals.Buildarch = Buildarch
fx.New( fx.New(
fx.Provide( fx.Provide(
@@ -824,7 +826,7 @@ func (l *Logger) Identify() {
l.log.Info("starting", l.log.Info("starting",
"appname", l.params.Globals.Appname, "appname", l.params.Globals.Appname,
"version", l.params.Globals.Version, "version", l.params.Globals.Version,
"arch", runtime.GOARCH, "buildarch", l.params.Globals.Buildarch,
) )
} }
``` ```
@@ -944,20 +946,23 @@ import "go.uber.org/fx"
// Package-level variables (set from main) // Package-level variables (set from main)
var ( var (
Appname string Appname string
Version string Version string
Buildarch string
) )
// Struct for DI // Struct for DI
type Globals struct { type Globals struct {
Appname string Appname string
Version string Version string
Buildarch string
} }
func New(lc fx.Lifecycle) (*Globals, error) { func New(lc fx.Lifecycle) (*Globals, error) {
n := &Globals{ n := &Globals{
Appname: Appname, Appname: Appname,
Version: Version, Buildarch: Buildarch,
Version: Version,
} }
return n, nil return n, nil
} }
@@ -968,13 +973,15 @@ func New(lc fx.Lifecycle) (*Globals, error) {
```go ```go
// cmd/httpd/main.go // cmd/httpd/main.go
var ( var (
Appname string = "CHANGEME" // Default, overridden by build Appname string = "CHANGEME" // Default, overridden by build
Version string // Set at build time Version string // Set at build time
Buildarch string // Set at build time
) )
func main() { func main() {
globals.Appname = Appname globals.Appname = Appname
globals.Version = Version globals.Version = Version
globals.Buildarch = Buildarch
// ... // ...
} }
``` ```
@@ -984,14 +991,18 @@ func main() {
Use ldflags to inject version information at build time: Use ldflags to inject version information at build time:
```makefile ```makefile
# ?= rather than := so that a `VERSION` build argument takes precedence: # ?= rather than := because this `$(shell git describe ...)` is only correct
# where a build stage invokes make, `ARG VERSION` puts it in the # on the host: `.dockerignore` excludes `.git`, so evaluated inside a build
# environment and `?=` defers to it. Otherwise `git describe` runs, in a # stage it expands to the empty string without failing and the binary reports
# build stage on the `.git` the build context carries. # 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) VERSION ?= $(shell git describe --tags --always)
BUILDARCH := $(shell go env GOARCH)
build: build:
go build -ldflags "-X main.Version=$(VERSION)" ./cmd/httpd go build -ldflags "-X main.Version=$(VERSION) -X main.Buildarch=$(BUILDARCH)" ./cmd/httpd
``` ```
--- ---
prompts/NEW_REPO_CHECKLIST.md
+77 -69
View File
@@ -1,6 +1,6 @@
--- ---
title: New Repo Checklist title: New Repo Checklist
last_modified: 2026-10-04 last_modified: 2026-08-10
--- ---
Use this checklist when creating a new repository from scratch. Follow the steps Use this checklist when creating a new repository from scratch. Follow the steps
@@ -54,9 +54,6 @@ Template files can be fetched from:
- [ ] `LICENSE` file matching the chosen license - [ ] `LICENSE` file matching the chosen license
- [ ] `REPO_POLICIES.md` — fetch from - [ ] `REPO_POLICIES.md` — fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md` `https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md`
- [ ] Guidance for coding agents, if the repo has any, is one `AGENTS.md` at the
root — never a file or directory named after one agent tool, such as
`CLAUDE.md` or `.claude/`, and never separate memory files
- [ ] `Dockerfile` and `.dockerignore` — fetch `.dockerignore` from - [ ] `Dockerfile` and `.dockerignore` — fetch `.dockerignore` from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore`
- Extend `.dockerignore` with the repo's own host-built artifacts, giving - Extend `.dockerignore` with the repo's own host-built artifacts, giving
@@ -65,46 +62,44 @@ Template files can be fetched from:
`cmd/myapp/` and delete the package directory. Do not transplant `cmd/myapp/` and delete the package directory. Do not transplant
`.gitignore`'s patterns: `.dockerignore` anchors an unprefixed pattern at `.gitignore`'s patterns: `.dockerignore` anchors an unprefixed pattern at
the context root, so the copied form leaves `config/.env` in the build the context root, so the copied form leaves `config/.env` in the build
context while reading as solved. The canonical file's `.claude` entry is context while reading as solved. See the `.dockerignore` rule in
anchored for the same reason as a repo-root binary; leave it that way, but `REPO_POLICIES.md`. The canonical file's `.claude` entry is anchored for
note that it only covers agents running at the repo root — if this repo the same reason as a repo-root binary; leave it that way, but note it only
will run them in subdirectories, `services/api/.claude/` needs its own 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. anchored entry.
- If the image embeds a version in a binary: `.dockerignore` lets `.git` - If the image embeds a version in a binary, the version is computed on the
into the build context. It keeps out `.git/config` and each submodule's host and passed with `--build-arg VERSION=...`. `ARG VERSION=dev` is
`config` under `.git/modules/` at any depth (`.git/modules/**/config`), declared in the stage that compiles, and **no stage calls `git describe`**
which `git describe` does not need and which can hold a credential: a — `.dockerignore` excludes `.git`, so it yields an empty version without
password in a remote URL, or the token the CI checkout step stores there. failing the build.
The stage that compiles has `git` (the Debian Go image has it; an alpine - All Dockerfiles must run `make check` as a build step, and every stage
one needs `apk add --no-cache git`) and takes the version from the containing a check-running `RUN` must declare `ARG CHECK_EPOCH` with the
`VERSION` build argument when one is given, otherwise from `RUN [ -n "$CHECK_EPOCH" ] || exit 1` guard immediately below it — see the
`git describe --tags --always`. That gives the tag on a tagged commit; on `CHECK_EPOCH` rule in `REPO_POLICIES.md`. Without them the check layer is
a later commit, the tag, the number of commits since it and the short served from cache on an unchanged tree and the build reports a green it
commit (`v1.2.3-4-gabc1234`); and the short commit when no tag is never ran.
reachable. The stage that compiles also marks its working directory safe - Every stage that runs checks sets `ENV LINT_IN_CONTAINER=1`, so
for git (`git config --system --add safe.directory /src`): a context sent `script/lint` runs the linter natively instead of trying to build
as a tar stream keeps the sender's file owners, and git refuses a checkout `Dockerfile.lint` where there is no daemon.
owned by another user, so the version would come out empty. `ARG VERSION` - Go repos: separate `lint` stage on the `golangci/golangci-lint` image,
has no default, and the build fails if the context carries `.git` and the with `COPY --from=lint /src/go.sum /dev/null` in the build stage to force
version still comes out empty, `dev` or `unknown`. A plain the ordering. Re-prove that ordering warm after adopting `CHECK_EPOCH`.
`docker build .` with no build arguments must succeed; a Dockerfile that - Server: also builds and runs the application
refuses an empty build argument drops that refusal and keeps the argument. - Non-server: brings up dev environment and runs `make check`
- The Dockerfile carries a `lint` phase and a `test` phase, each invoking
its tool directly rather than through `make` or `script/`, and the final
stage carries a `COPY --from=` of a harmless file from each so the image
cannot be built unless both passed. Keep the final stage last: a stage
nothing depends on is built only when `--target` names it.
- Server: the final stage builds and runs the application
- Non-server: the final stage brings up the dev environment
- Image pinned by sha256 hash with version/date comment - Image pinned by sha256 hash with version/date comment
- [ ] `Dockerfile.lint` — the lint-only image `script/lint` builds when it is
not already inside a container. Sets `ENV LINT_IN_CONTAINER=1`; same
`ARG CHECK_EPOCH` + guard + expanded-value discipline as above, with the
`ARG` **after** the dependency layer so only the lint re-runs. Base image
pinned by sha256 with a version/date comment. Copy from
`REPO_POLICIES.md`.
- [ ] Gitea Actions workflow at `.gitea/workflows/check.yml` that runs - [ ] Gitea Actions workflow at `.gitea/workflows/check.yml` that runs
`script/cibuild` on push — reference `script/cibuild` on push — reference
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitea/workflows/check.yml` `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitea/workflows/check.yml`
- [ ] Language-specific: - [ ] Language-specific:
- [ ] Go: `go mod init sneak.berlin/go/<name>`, `.golangci.yml` (fetch from - [ ] Go: `go mod init sneak.berlin/go/<name>`, `.golangci.yml` (fetch from
`https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml` and, `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`)
in the same commit, set the lint phase digest to the one named in the
`.golangci.yml` paragraph of `REPO_POLICIES.md`)
- [ ] JS: `yarn init`, `yarn add --dev prettier` - [ ] JS: `yarn init`, `yarn add --dev prettier`
- [ ] Python: `pyproject.toml` - [ ] Python: `pyproject.toml`
@@ -123,34 +118,51 @@ are thin shims calling them. Model scripts:
installs installs
- [ ] `script/setup` / `make setup` — readies a fresh clone: runs `bootstrap`, - [ ] `script/setup` / `make setup` — readies a fresh clone: runs `bootstrap`,
then `install-precommit`, plus repo-specific init then `install-precommit`, plus repo-specific init
- [ ] `script/test` / `make test` — `docker build --no-cache --target test .`, - [ ] `script/test` / `make test` — runs real tests, not a no-op (30-second
tagged; the phase runs real tests, not a no-op (90-second timeout, timeout)
60-second hard cap on wall time) - [ ] `script/lint` / `make lint` — runs the linter directly when
- [ ] `script/lint` / `make lint` — `docker build --no-cache --target lint .`, `LINT_IN_CONTAINER=1`, otherwise `epoch="$(date +%s%N)$$"` on its own line
tagged. No lint verdict may come from a host invocation of the linter. then `docker build --build-arg CHECK_EPOCH="$epoch" -f Dockerfile.lint .`.
- [ ] `script/fmt` / `make fmt` — formats code (writes; native, never in a No lint verdict may come from a host invocation. Copy from
container) `REPO_POLICIES.md`. Detect on `LINT_IN_CONTAINER` only — never
- [ ] `script/fmt-check` / `make fmt-check` — checks formatting (read-only; `/.dockerenv`, which is absent in BuildKit `RUN` steps and present on
native) hosts that are themselves containers. Without the nonce this exits 0 on an
unchanged tree having linted nothing; without `-f Dockerfile.lint` it
builds the main image and lints nothing at all.
- [ ] `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 - [ ] `script/check` / `make check` — runs `test`, `lint`, `fmt-check`; must not
modify files modify files
- [ ] `script/projectname` — outputs the project name (used by `script/docker` - [ ] `script/projectname` — outputs the project name (used by `script/docker`
for the image tag) for the image tag)
- [ ] `script/docker` / `make docker` — builds Docker image, tagged via - [ ] `script/docker` / `make docker` — builds Docker image, tagged via
`script/projectname` (byte-identical across repos); `--no-cache`, plus the `script/projectname` (byte-identical across repos); carries the same three
version as a build arg version lines as `script/cibuild` below, and passes
- [ ] `script/cibuild` — cd to repo root, run `script/bootstrap`, run `--build-arg CHECK_EPOCH="$epoch"` and `--build-arg VERSION="$version"`
`script/check`, then - [ ] `script/cibuild` — cd to repo root, then, each on its own line:
`docker build --no-cache --build-arg VERSION="$version" .` (what CI runs).
The bootstrap is required: CI checks out and runs this alone, and ```sh
`script/fmt-check` runs the formatter on the host. epoch="$(date +%s%N)$$"
- [ ] `script/fmt` and `script/fmt-check` source nvm for the pinned node version version="$(git describe --tags --always --dirty 2>/dev/null || true)"
before invoking `yarn`, as `script/bootstrap`'s own install step does. [ -n "$version" ] || version="unknown"
`script/bootstrap` leaves the node and yarn it installs off the `PATH` of docker build \
the shell that called it, so a bare `yarn` exits 127 on a runner carrying --build-arg CHECK_EPOCH="$epoch" \
nothing but docker and git. --build-arg VERSION="$version" \
- [ ] Every `docker build` in `script/` is tagged, so no invocation leaves a .
dangling image behind ```
(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, and
so does a bare `docker build -f Dockerfile.lint .`. The image runs
`make check`, which includes lint, so `script/cibuild` needs no separate
lint step.
- [ ] `script/precommit` — called by the pre-commit hook; runs `script/check` - [ ] `script/precommit` — called by the pre-commit hook; runs `script/check`
- [ ] `script/install-precommit` — installs the pre-commit hook that runs - [ ] `script/install-precommit` — installs the pre-commit hook that runs
`script/precommit` `script/precommit`
@@ -161,16 +173,12 @@ are thin shims calling them. Model scripts:
# 4. Verify # 4. Verify
- [ ] `make check` passes - [ ] `make check` passes
- [ ] `make lint` demonstrably runs the linter rather than returning a cached
build: run it twice on an unchanged tree and confirm the lint layer says
`DONE`, never `CACHED`, both times
- [ ] `make docker` succeeds - [ ] `make docker` succeeds
- [ ] `script/cibuild` succeeds in a fresh clone on a host carrying nothing but - [ ] `script/cibuild` succeeds and demonstrably executes
docker and git, with no node or yarn on `PATH`, which is what CI has, and - [ ] No secrets in repo
demonstrably executed the checks — a sub-second build, or `CACHED` on a
gate layer, means nothing ran
- [ ] Plant a lint violation and confirm both `make lint` and a plain
`docker build .` fail on it; revert. A plain build that passes proves the
final stage is missing its `COPY --from=` edge to the gate phases.
- [ ] No secrets in repo, and none in the build context: enumerate a probe image
rather than reading `.dockerignore`
- [ ] No mutable image/package references - [ ] No mutable image/package references
- [ ] No unnecessary files in repo root - [ ] No unnecessary files in repo root
- [ ] All dates written as YYYY-MM-DD - [ ] All dates written as YYYY-MM-DD
prompts/REPO_POLICIES.md
+602 -308
View File
File diff suppressed because it is too large Load Diff
script/check
+1 -3
View File
@@ -1,8 +1,6 @@
#!/bin/sh #!/bin/sh
# script/check: run all checks (test, lint, fmt-check). Our own # script/check: run all checks (test, lint, fmt-check). Our own
# extension to scripts-to-rule-them-all. test and lint are Docker # extension to scripts-to-rule-them-all. Must not modify any files.
# phases; fmt-check is native, because a formatter writes the working
# tree. Must not modify any files.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
script/cibuild
+16 -16
View File
@@ -1,28 +1,28 @@
#!/bin/sh #!/bin/sh
# script/cibuild: run the CI build. It bootstraps first: a CI runner # script/cibuild: run the CI build. The Dockerfile runs script/check, but
# checks out and runs this and nothing else, and script/fmt-check runs # that only proves anything because CHECK_EPOCH is a fresh nonce on every
# the formatter on the host, which a pristine checkout cannot do. # invocation: without it Docker serves the check layer from cache and the
# --no-cache for the same reason as script/docker: the gate phases the # build exits 0 without running the suite.
# final stage depends on are RUN steps, and a cached one is a check that
# did not run.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
"$SCRIPT_DIR/bootstrap" # Both assignments on their own line: a failing command substitution
"$SCRIPT_DIR/check" # inside an argument does not trip `set -e`, so the inline form
# Own line: a failing command substitution inside an argument does # degrades silently to an empty constant. `$$` because busybox `date`
# not trip `set -e`, so the inline form degrades silently to an # drops %N without erroring. VERSION is computed here because
# empty constant. The VERSION build argument takes precedence over # .dockerignore excludes .git, so `git describe` in a build stage
# the version a build stage derives from the .git in the context. # yields an empty version without failing; the guard below is the
# single place the fallback is applied.
epoch="$(date +%s%N)$$"
version="$(git describe --tags --always --dirty 2>/dev/null || true)" version="$(git describe --tags --always --dirty 2>/dev/null || true)"
[ -n "$version" ] || version="unknown" [ -n "$version" ] || version="unknown"
docker build --no-cache \ docker build \
--build-arg CHECK_EPOCH="$epoch" \
--build-arg VERSION="$version" \ --build-arg VERSION="$version" \
-t "$("$SCRIPT_DIR/projectname")" . .
} }
main "$@" main "$@"
script/docker
+13 -8
View File
@@ -1,8 +1,9 @@
#!/bin/sh #!/bin/sh
# script/docker: build the Docker image tagged with the project name. # script/docker: build the Docker image tagged with the project name.
# Identical in all repos; the tag comes from script/projectname. # Identical in all repos; the tag comes from script/projectname. The
# --no-cache because the gate phases the final stage depends on are RUN # Dockerfile's checks only actually run because CHECK_EPOCH is a fresh
# steps, and a cached one is a check that did not run. # nonce on every invocation; without it a warm cache turns this into a
# green that proves nothing.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -10,13 +11,17 @@ ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
# Own line: a failing command substitution inside an argument does # Both assignments on their own line: a failing command substitution
# not trip `set -e`, so the inline form degrades silently to an # inside an argument does not trip `set -e`, so the inline form
# empty constant. The VERSION build argument takes precedence over # degrades silently to an empty constant. `$$` because busybox `date`
# the version a build stage derives from the .git in the context. # drops %N without erroring. VERSION is computed here because
# .dockerignore excludes .git, so `git describe` in a build stage
# yields an empty version without failing.
epoch="$(date +%s%N)$$"
version="$(git describe --tags --always --dirty 2>/dev/null || true)" version="$(git describe --tags --always --dirty 2>/dev/null || true)"
[ -n "$version" ] || version="unknown" [ -n "$version" ] || version="unknown"
docker build --no-cache \ docker build \
--build-arg CHECK_EPOCH="$epoch" \
--build-arg VERSION="$version" \ --build-arg VERSION="$version" \
-t "$("$SCRIPT_DIR/projectname")" . -t "$("$SCRIPT_DIR/projectname")" .
} }
script/fmt
+1 -20
View File
@@ -4,28 +4,9 @@ set -eu
ROOT="$(cd "$(dirname "$0")/.." && pwd -P)" ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
# Must match the pin in script/bootstrap.
NODE_VERSION="22.17.0"
# script/bootstrap installs node and yarn under nvm and leaves neither
# on the PATH of the shell that called it, so resolve the pinned
# toolchain here the way bootstrap's own install step does. nvm is a
# bash script, hence the subshell.
run_yarn() {
if command -v yarn >/dev/null 2>&1; then
exec yarn "$@"
fi
if [ ! -s "$HOME/.nvm/nvm.sh" ]; then
echo "fmt: no yarn; run script/bootstrap first" >&2
exit 1
fi
exec bash -c '. "$HOME/.nvm/nvm.sh" && nvm use "$1" >/dev/null &&
shift && exec yarn "$@"' bash "$NODE_VERSION" "$@"
}
main() { main() {
cd "$ROOT" cd "$ROOT"
run_yarn run prettier --write '**/*.md' --tab-width 4 --prose-wrap always yarn run prettier --write '**/*.md' --tab-width 4 --prose-wrap always
} }
main "$@" main "$@"
script/fmt-check
+1 -20
View File
@@ -4,28 +4,9 @@ set -eu
ROOT="$(cd "$(dirname "$0")/.." && pwd -P)" ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
# Must match the pin in script/bootstrap.
NODE_VERSION="22.17.0"
# script/bootstrap installs node and yarn under nvm and leaves neither
# on the PATH of the shell that called it, so resolve the pinned
# toolchain here the way bootstrap's own install step does. nvm is a
# bash script, hence the subshell.
run_yarn() {
if command -v yarn >/dev/null 2>&1; then
exec yarn "$@"
fi
if [ ! -s "$HOME/.nvm/nvm.sh" ]; then
echo "fmt-check: no yarn; run script/bootstrap first" >&2
exit 1
fi
exec bash -c '. "$HOME/.nvm/nvm.sh" && nvm use "$1" >/dev/null &&
shift && exec yarn "$@"' bash "$NODE_VERSION" "$@"
}
main() { main() {
cd "$ROOT" cd "$ROOT"
run_yarn run prettier --check '**/*.md' --tab-width 4 --prose-wrap always yarn run prettier --check '**/*.md' --tab-width 4 --prose-wrap always
} }
main "$@" main "$@"
script/lint
+24 -13
View File
@@ -1,23 +1,34 @@
#!/bin/sh #!/bin/sh
# script/lint: run the linter. Linting is a phase of the Dockerfile and # script/lint: run the linter. Inside a container, run it directly;
# this builds that phase alone; the linter is never installed or run on # on a host, build Dockerfile.lint so it runs in one anyway. The linter
# a developer host, where a shared result cache and a host-global lock # is never run on a developer host, where a shared result cache, a
# make its answer untrustworthy. # host-global lock and a stale toolchain make its answer untrustworthy.
# #
# The phase is not the last stage in the file, so it is built only when # LINT_IN_CONTAINER is set by this repo's Dockerfiles and is the ONLY
# --target names it. --no-cache because a cached lint layer is a lint # accepted signal. Do not add a /.dockerenv fallback: it is absent
# that did not run. The tag makes each build replace the previous image # inside BuildKit RUN steps and present on hosts that are themselves
# instead of leaving a dangling one behind. # containers, so it both misses and false-positives — and a false
# positive silently restores host linting.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
docker build --no-cache \
--target lint \ if [ "${LINT_IN_CONTAINER:-}" = "1" ]; then
-t "$("$SCRIPT_DIR/projectname")-lint" . exec yarn run prettier --check '**/*.md' \
--tab-width 4 --prose-wrap always
fi
# Own line, and `$$` because busybox `date` drops %N silently.
# Without a fresh nonce the lint layer is cached and this exits 0
# having linted nothing.
epoch="$(date +%s%N)$$"
docker build \
--build-arg CHECK_EPOCH="$epoch" \
-f Dockerfile.lint \
.
} }
main "$@" main "$@"
script/test
+3 -10
View File
@@ -1,19 +1,12 @@
#!/bin/sh #!/bin/sh
# script/test: run the test suite. Testing is a phase of the Dockerfile # script/test: run the test suite.
# and this builds that phase alone, on the same terms as script/lint:
# --target because a phase that is not the last stage is built only when
# named, --no-cache because a cached test layer is a test that did not
# run, and a tag so each build replaces the previous image.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
docker build --no-cache \ echo "No tests defined."
--target test \
-t "$("$SCRIPT_DIR/projectname")-test" .
} }
main "$@" main "$@"