docs: reconcile lifecycle delivery with PR 13

Record the accepted rule for root-module versions and nested modules
for heavy dependencies or independent releases. Update repository
instructions and link implementation evidence to the ADR.

Closes #2

.gitea/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+      # Keep embedded Markdown templates in CI; paths-ignore cannot undo a match.
+      - "*.md"
+      - "docs/**"
+  pull_request:
+    paths-ignore:
+      - "*.md"
+      - "docs/**"
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7.0.1
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-go@v7.0.0
+        with:
+          go-version-file: go.mod
+      - name: gofmt
+        run: test -z "$(gofmt -l .)"
+      - run: go vet ./...
+      - run: go test -race ./...
+      - name: Require issue URLs in TODO comments
+        run: |
+          find . -type d \( -name .git -o -name node_modules -o -name vendor -o -name generated -o -name gen -o -name target -o -name dist -o -name build -o -name .svelte-kit -o -name .next \) -prune -o -type f \( -name '*.go' -o -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.svelte' -o -name '*.rs' -o -name '*.sql' -o -name '*.sh' -o -name '*.proto' -o -name '*.graphql' -o -name '*.yml' -o -name '*.yaml' -o -name '*.toml' \) -exec awk 'match($0, "((^|[^:])[/][/]|[/][*]|(^|[[:space:]])(#|--)|^[[:space:]]*([*]|<!--))") { comment=substr($0, RSTART + RLENGTH); todo=index(comment, "TO" "DO"); if (todo && substr(comment, todo + 4) !~ "https?:[/][/]") { print FILENAME ":" FNR ":" $0; bad=1 } } END { exit bad }' {} + # shortcut: line-based scan can flag comment-like strings and misses multiline issue links, use a parser when these need accurate coverage
+      - name: Go lint
+        run: go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.15.0 run ./...
+      - uses: goreleaser/goreleaser-action@v7.3.0
+        with:
+          distribution: goreleaser
+          version: v2.19.0
+          args: check
+      - uses: goreleaser/goreleaser-action@v7.3.0
+        with:
+          distribution: goreleaser
+          version: v2.19.0
+          args: release --snapshot --clean

.gitea/workflows/docs-check.yml

@@ -0,0 +1,15 @@
+name: Documentation
+on:
+  push:
+    branches: [main]
+  pull_request:
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7.0.1
+      - uses: actions/setup-go@v7.0.0
+        with:
+          go-version-file: go.mod
+          cache: false
+      - run: go run ./cmd/docs check

.gitea/workflows/release.yml

@@ -0,0 +1,29 @@
+name: release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7.0.1
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-go@v7.0.0
+        with:
+          go-version-file: go.mod
+      - name: Require issue URLs in TODO comments
+        run: |
+          find . -type d \( -name .git -o -name node_modules -o -name vendor -o -name generated -o -name gen -o -name target -o -name dist -o -name build -o -name .svelte-kit -o -name .next \) -prune -o -type f \( -name '*.go' -o -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.svelte' -o -name '*.rs' -o -name '*.sql' -o -name '*.sh' -o -name '*.proto' -o -name '*.graphql' -o -name '*.yml' -o -name '*.yaml' -o -name '*.toml' \) -exec awk 'match($0, "((^|[^:])[/][/]|[/][*]|(^|[[:space:]])(#|--)|^[[:space:]]*([*]|<!--))") { comment=substr($0, RSTART + RLENGTH); todo=index(comment, "TO" "DO"); if (todo && substr(comment, todo + 4) !~ "https?:[/][/]") { print FILENAME ":" FNR ":" $0; bad=1 } } END { exit bad }' {} + # shortcut: line-based scan can flag comment-like strings and misses multiline issue links, use a parser when these need accurate coverage
+      - uses: goreleaser/goreleaser-action@v7.3.0
+        with:
+          distribution: goreleaser
+          version: v2.19.0
+          args: release --clean
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          # goreleaser fails on more than one token; an empty value counts as unset.
+          GITHUB_TOKEN: ""

.gitignore

@@ -0,0 +1 @@
+dist/

.golangci.yml

@@ -0,0 +1,12 @@
+version: "2"
+linters:
+  default: none
+  enable:
+    - revive
+  settings:
+    revive:
+      rules:
+        - name: exported
+        - name: package-comments
+  exclusions:
+    presets: []

.goreleaser.yaml

@@ -0,0 +1,29 @@
+version: 2
+project_name: docs
+
+builds:
+  - id: docs
+    main: ./cmd/docs
+    binary: docs
+    env:
+      - CGO_ENABLED=0
+    goos: [darwin, linux]
+    goarch: [amd64, arm64]
+    flags: [-trimpath]
+    ldflags: [-s -w]
+
+archives:
+  - formats: [tar.gz]
+    name_template: "docs_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
+
+checksum:
+  name_template: checksums.txt
+
+gitea_urls:
+  api: https://gitea.auvem.com/api/v1
+  download: https://gitea.auvem.com
+
+release:
+  gitea:
+    owner: corestack
+    name: go

AGENTS.md

@@ -0,0 +1,51 @@
+# AGENTS.md
+
+## Commands
+- Check: `go build ./...`, `go vet ./...`, `go test -race ./...`, `go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.15.0 run ./...`; from the project root, run the TODO check below.
+- Generate: No code generation is configured; format with `gofmt -w .`.
+- Documentation: `go run ./cmd/docs check`; create records with `go run ./cmd/docs new adr|plan "Title"`. This checker repository uses its local implementation as the source of truth.
+
+## Scope and decisions
+- Before editing under a directory with its own AGENTS.md, read it. Scoped files: none currently; this root governs the repository, including nested Go modules unless nearer instructions override it.
+- Explicit user instructions win; nearer scoped rules override broader rules.
+- Distinguish confirmed requirements, proposed defaults and unresolved decisions; resolve material ambiguity before dependent work.
+- Proposed ADRs are context, not authority; read relevant accepted decisions before changing their scope.
+- Before final review and merge, reconcile affected records against the latest target branch plus the PR, following [/docs/adr/README.md](/docs/adr/README.md).
+- Documentation tier: ADRs only. Create a plan only when work needs durable execution context across areas, phases or sessions; then enable the plans tier.
+- In a sandbox, request required network/cache access before first codegen; on permission/cache errors retry once with that access. Never hand-edit generated output.
+- Shared databases and ports may belong to other worktrees/agents; read project rules before starting, stopping or resetting them.
+- Ask before lint/autofix changes that could alter runtime behavior.
+- Report commands actually run and their results; never claim an unrun check passed.
+- Name branches `<type>/<kebab>` without agent-name prefixes.
+
+## Comments
+- Document package/module purpose, ownership and boundaries, and every public/exported contract in native doc comments; document generated surfaces at their source.
+- Explain why at invariants, auth decisions, concurrency/ordering, destructive edges and deliberate deviations; no narration, changelog comments or commented-out code.
+- Use `invariant: <property>`, `authz: <who and enforcement>`, `shortcut: <limit>, <when to upgrade>` on relevant code; retain Go `Deprecated:` and Rust `// SAFETY:`.
+- Every TODO needs an issue URL; reviewers recheck tagged comments on touched code.
+
+## Project map
+
+Go module `go.auvem.com/corestack`.
+
+- Docs format (the spec `docs check` implements): `docs/docs-format.md`.
+- Decisions live in `docs/adr/`, plans in `docs/plans/`. Records are permanent; never rename them.
+- Add dependencies only to the module that needs them; heavy dependencies go in nested modules (see the [module-boundary ADR](/docs/adr/20261025T214616275Z-version-light-core-packages-in-the-root-module-and-nest-heavy-dependency-modules.md)).
+
+## Go
+- Default backend language is Go; follow existing package boundaries.
+- Define interfaces at the consumer only when a second implementation or a test seam needs one.
+- Wrap contextual errors with `%w`; inspect causes with `errors.Is`/`errors.As`.
+- Do not add package-level mutable state or `init` side effects.
+- Put `context.Context` first in parameters; never store it in a struct.
+- Give every goroutine an owner and a shutdown path.
+- Run `gofmt`, `go vet ./...`, tests and the project's configured linter from the owning module.
+- Use `.golangci.yml` (revive exported/package-comments); the pinned linter command is listed above.
+
+## TODO check
+
+Run from the project root (also enforced in CI):
+
+```sh
+find . -type d \( -name .git -o -name node_modules -o -name vendor -o -name generated -o -name gen -o -name target -o -name dist -o -name build -o -name .svelte-kit -o -name .next \) -prune -o -type f \( -name '*.go' -o -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.svelte' -o -name '*.rs' -o -name '*.sql' -o -name '*.sh' -o -name '*.proto' -o -name '*.graphql' -o -name '*.yml' -o -name '*.yaml' -o -name '*.toml' \) -exec awk 'match($0, "((^|[^:])[/][/]|[/][*]|(^|[[:space:]])(#|--)|^[[:space:]]*([*]|<!--))") { comment=substr($0, RSTART + RLENGTH); todo=index(comment, "TO" "DO"); if (todo && substr(comment, todo + 4) !~ "https?:[/][/]") { print FILENAME ":" FNR ":" $0; bad=1 } } END { exit bad }' {} + # shortcut: line-based scan can flag comment-like strings and misses multiline issue links, use a parser when these need accurate coverage
+```

CLAUDE.md

@@ -0,0 +1 @@
+See [AGENTS.md](AGENTS.md).

LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Elijah Duffy
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1 +1,54 @@
 # corestack go
+
+Shared Go building blocks. Includes `docs`, a checker for architecture decision records (ADRs) and implementation plans, and `lifecycle`, a service and worker coordinator.
+
+## docs
+
+Install:
+
+```sh
+go install go.auvem.com/corestack/cmd/docs@latest
+```
+
+Use, from a repository root:
+
+```sh
+docs new adr "Use Example Queue for background jobs"   # creates docs/adr/<id>.md
+docs new plan "Adopt Example Queue"                    # creates docs/plans/<id>.md
+docs check [--root DIR]                                # prints path:line: message; exit 1 on problems
+```
+
+The format is specified in [docs/docs-format.md](docs/docs-format.md); that document is the complete rule set. Exit status is `0` when every record is valid, `1` when problems are reported and `2` for usage errors.
+
+## lifecycle
+
+`go.auvem.com/corestack/lifecycle` sets up modules in registration order, runs
+services concurrently, and tears down successful setups in reverse order.
+Construct an `App` with a required `*slog.Logger`, register `Module` callbacks,
+and call `Run(ctx)` once. See the [two-service example](lifecycle/example_test.go).
+
+Launch background work with `app.Go(ctx, name, fn)` using the callback's lifecycle
+context or a descendant, and handle admission errors. Run waits for every service
+and admitted worker; raw goroutines remain your responsibility. First failure or
+an injected signal cancels work before teardown. One shared shutdown deadline
+(default 30 seconds) covers hooks and callback completion; a second signal
+abandons shutdown. Callbacks must cooperate: abandonment cannot kill goroutines,
+and the caller owns process exit and any unreleased resources.
+
+During App-initiated shutdown, callback errors containing only the callback's
+context cancellation are omitted. Mixed cancellation and independent failures
+are retained intact to preserve wrapper types, identity and custom matching;
+these errors may still match cancellation through `errors.Is`.
+
+The caller owns signal subscription, SIGINT/SIGTERM filtering, a channel buffered
+for at least two signals, and subscription cleanup. Nil signals disable reception.
+There are no signal subscriptions, process exits, external dependencies or CLI
+integration in this package.
+
+## Status
+
+No support is guaranteed. Breaking changes, including to the format rules, may happen before 1.0 and are listed in the release notes.
+
+## License
+
+BSD-3-Clause, see [LICENSE](LICENSE).

cmd/docs/main.go

@@ -0,0 +1,66 @@
+// Command docs creates and checks ADR and plan records. See docs/docs-format.md.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"go.auvem.com/corestack/internal/docs"
+)
+
+const usage = `usage:
+  docs new adr|plan "Title"
+  docs check [--root DIR]
+`
+
+func main() { os.Exit(run(os.Args[1:], os.Stdout, os.Stderr, time.Now())) }
+
+// run returns the exit status: 0 success, 1 problems or failure, 2 usage error.
+func run(args []string, stdout, stderr io.Writer, now time.Time) int {
+	if len(args) == 0 {
+		fmt.Fprint(stderr, usage)
+		return 2
+	}
+	switch args[0] {
+	case "new":
+		if len(args) != 3 || (args[1] != "adr" && args[1] != "plan") {
+			fmt.Fprint(stderr, usage)
+			return 2
+		}
+		path, err := docs.New(".", args[1], args[2], now)
+		if err != nil {
+			fmt.Fprintf(stderr, "docs: %v\n", err)
+			return 1
+		}
+		fmt.Fprintln(stdout, path)
+		return 0
+	case "check":
+		fs := flag.NewFlagSet("docs check", flag.ContinueOnError)
+		fs.SetOutput(stderr)
+		root := fs.String("root", ".", "repository root")
+		if err := fs.Parse(args[1:]); err != nil || fs.NArg() != 0 {
+			if fs.NArg() != 0 {
+				fmt.Fprint(stderr, usage)
+			}
+			return 2
+		}
+		res, err := docs.Check(*root)
+		if err != nil {
+			fmt.Fprintf(stderr, "docs: %v\n", err)
+			return 1
+		}
+		for _, p := range res.Problems {
+			fmt.Fprintln(stdout, p)
+		}
+		if len(res.Problems) > 0 {
+			return 1
+		}
+		fmt.Fprintf(stdout, "ok: %d records checked\n", res.Records)
+		return 0
+	}
+	fmt.Fprint(stderr, usage)
+	return 2
+}

cmd/docs/main_test.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+var now = time.Date(2026, 10, 23, 20, 45, 12, 345_000_000, time.UTC)
+
+func do(t *testing.T, args ...string) (code int, stdout, stderr string) {
+	t.Helper()
+	var out, errw bytes.Buffer
+	code = run(args, &out, &errw, now)
+	return code, out.String(), errw.String()
+}
+
+func TestCLI(t *testing.T) {
+	root := t.TempDir()
+	t.Chdir(root)
+
+	if code, out, _ := do(t, "check"); code != 0 || out != "ok: 0 records checked\n" {
+		t.Fatalf("empty check: %d %q", code, out)
+	}
+	code, out, _ := do(t, "new", "adr", "Use X")
+	if code != 0 || out != "docs/adr/20261023T204512345Z-use-x.md\n" {
+		t.Fatalf("new: %d %q", code, out)
+	}
+	code, out, _ = do(t, "check")
+	var want strings.Builder
+	for _, line := range []string{"6", "8", "20", "24", "28", "32"} { // numeric, not lexical, order
+		want.WriteString("docs/adr/20261023T204512345Z-use-x.md:" + line + ": unfinished placeholder {{docs:todo}}\n")
+	}
+	if code != 1 || out != want.String() {
+		t.Fatalf("check with markers: %d %q", code, out)
+	}
+	// --root checks another directory; the working directory is not used.
+	t.Chdir(t.TempDir())
+	if code, _, _ := do(t, "check", "--root", root); code != 1 {
+		t.Errorf("--root: %d", code)
+	}
+	if code, out, _ := do(t, "check"); code != 0 || !strings.HasPrefix(out, "ok: ") {
+		t.Errorf("cwd root: %d %q", code, out)
+	}
+}
+
+func TestCLIExitCodes(t *testing.T) {
+	t.Chdir(t.TempDir())
+	must := func(err error) {
+		t.Helper()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	must(os.MkdirAll("docs/adr", 0o755))
+	must(os.WriteFile(filepath.Join("docs", "adr", "bad.md"), nil, 0o644))
+	for _, tt := range []struct {
+		args []string
+		code int
+	}{
+		{nil, 2},
+		{[]string{"bogus"}, 2},
+		{[]string{"new"}, 2},
+		{[]string{"new", "adr"}, 2},
+		{[]string{"new", "note", "T"}, 2},
+		{[]string{"new", "adr", "T", "extra"}, 2},
+		{[]string{"new", "adr", "!!!"}, 1},
+		{[]string{"check", "--bogus"}, 2},
+		{[]string{"check", "extra"}, 2},
+		{[]string{"check", "--root", "missing-dir"}, 1},
+		{[]string{"check"}, 1}, // bad.md is not a valid name
+	} {
+		if code, _, stderr := do(t, tt.args...); code != tt.code {
+			t.Errorf("docs %v = %d, want %d (stderr %q)", tt.args, code, tt.code, stderr)
+		}
+	}
+}

docs/adr/20261023T214738672Z-adopt-a-checked-format-for-adrs-and-implementation-plans.md

@@ -0,0 +1,82 @@
+---
+title: Adopt a checked format for ADRs and implementation plans
+date: 2026-10-23
+status: accepted
+implementation: implemented
+summary: Use one documented ADR and plan format, enforced by a shared Go CLI (docs check).
+tags:
+  - documentation
+  - adr
+  - tooling
+supersedes: []
+superseded_by: []
+related: []
+tracking: []
+implemented_by:
+  - https://gitea.auvem.com/corestack/go/pulls/1
+---
+
+# Adopt a checked format for ADRs and implementation plans
+
+## Context and Problem Statement
+
+We record architecture decisions as ADRs and track delivery work as implementation plans. Across our repositories, four independent implementations of this practice grew up: each had its own filename scheme, frontmatter keys, status vocabulary and checking script (or none). The same concept was spelled differently from repository to repository, cross-references were relative paths that broke when files moved, and "accepted" did not say whether anything had been built. Tooling and agents had to learn each variant, and fixes to one checker did not reach the others.
+
+We need one format that people and tools can write without surprises, that separates *the decision* from *its delivery*, and that is verified mechanically so records do not rot. The format must be public and documented well enough that someone can write valid files from the specification alone.
+
+## Decision Drivers
+
+* One vocabulary and one layout everywhere, so a record means the same thing in every repository.
+* Stable identity: a record's ID and path never change, so references stay valid.
+* The decision status and the implementation status are tracked separately.
+* Checks run locally and in CI with no service dependency.
+* Low upkeep: one tool to maintain, not one per repository.
+
+## Considered Options
+
+* MADR 4 template plus generic Markdown and link linting.
+* Keep a checking script per repository, converging informally.
+* Extract and publish one existing checker.
+* Define one format and implement one shared Go CLI that creates and checks records.
+
+## Decision Outcome
+
+Chosen option: "Define one format and implement one shared Go CLI that creates and checks records", because it is the only option that gives a single enforced vocabulary and identity scheme while keeping the checks free of service dependencies.
+
+The format is specified in [docs-format](/docs/docs-format.md). It uses the MADR 4 layout, with `### Consequences` under Decision Outcome made mandatory, and adds the parts MADR leaves open: timestamp-based permanent IDs in filenames, a fixed frontmatter schema, a separate `implementation` field, reciprocal supersession, durable repo-root references, and a plan record with its own lifecycle. The CLI, `docs`, offers `docs new adr|plan` and `docs check`.
+
+### Consequences
+
+* Good, because the format has one specification, one checker and one set of error messages.
+* Good, because records are validated, so dead links, missing sections and contradictory statuses fail CI instead of accumulating.
+* Good, because the permanent ID survives title edits.
+* Bad, because the format is ours: we own the specification and the tool, and breaking changes before 1.0 will require updating adopters.
+* Neutral, because the check validates structure only; it cannot tell whether a decision is sound.
+
+## Pros and Cons of the Options
+
+### MADR 4 template plus generic Markdown and link linting
+
+* Good, because it is a public, widely understood template and nothing custom is built.
+* Bad, because MADR is a template with no checker of its own, and generic linters enforce no ID, status, supersession or reference rules.
+
+### Keep a checking script per repository
+
+* Good, because there is no new shared artifact and each team keeps full control.
+* Bad, because the four existing variants already diverged; nothing stops further divergence.
+* Bad, because each script is maintained, tested and fixed separately, and most repositories would simply not have one.
+
+### Extract and publish one existing checker
+
+* Good, because it is cheaper: an existing Go checker already handles timestamp IDs, exclusive creation and reciprocal supersession.
+* Bad, because it has no plan record, no `implementation` field and no public specification, and it is tied to one repository's conventions.
+
+### Define one format and implement one shared Go CLI that creates and checks records
+
+* Good, because one specification and one implementation can be tested thoroughly and installed with `go install`.
+* Good, because the same binary creates records, so new files start with the required structure.
+* Bad, because we commit to maintaining a small public tool and a specification.
+
+## More Information
+
+MADR 4: https://adr.github.io/madr/. The specification is [docs-format](/docs/docs-format.md); the implementation lands in the same pull request that records this decision.

docs/adr/20261025T214616275Z-version-light-core-packages-in-the-root-module-and-nest-heavy-dependency-modules.md

@@ -0,0 +1,51 @@
+---
+title: "Version light core packages in the root module and nest heavy-dependency modules"
+date: 2026-10-25
+status: accepted
+implementation: implemented
+summary: Keep light core packages on root-module versions and isolate heavy or independently versioned packages in nested modules from their first commit.
+tags:
+  - modules
+  - versioning
+supersedes: []
+superseded_by: []
+related: []
+tracking:
+  - https://gitea.auvem.com/corestack/go/issues/2
+implemented_by:
+  - https://gitea.auvem.com/corestack/go/pulls/4
+---
+
+# Version light core packages in the root module and nest heavy-dependency modules
+
+## Context and Problem Statement
+
+The repository currently has one Go module, `go.auvem.com/corestack`. A plain `vX.Y.Z` tag versions every package in that module together and triggers a release of the `docs` binary. Light core packages can share this version stream and one changelog per tag; packages with heavy dependencies or independent release needs benefit from their own module boundaries.
+
+Carving a package out after it has shipped in the root module is the expensive case: older root versions still contain it, while the new nested module supplies the same import path. Consumers can encounter ambiguous imports until coordinated releases and dependency upgrades remove the overlap. Starting a package as a nested module from its first commit avoids that migration.
+
+The fixed dependency list in AGENTS.md described only the docs checker. It would block the planned Bob and Goose dependencies for `page` and `migrate`; dependency placement needs a module-boundary rule instead of a repository-wide allowlist.
+
+## Considered Options
+
+* Keep every package in the root module: simplest releases, but couples heavy and independently versioned packages to core releases and makes later extraction costly.
+* Give every package a nested module immediately: avoids later extraction, but adds module and release bookkeeping to light core packages that can share a version.
+* Keep light core packages in the root module and start heavy or independently versioned packages as nested modules: retain simple core releases while avoiding the costly extraction case.
+
+## Decision Outcome
+
+Choose the mixed boundary: light core packages share the root module; heavy-dependency or independently versioned packages begin as nested modules.
+
+* Root module, plain `v*` tags: `lifecycle`, `lifecycle/cli`, `migrate`, `page`, and `cmd/docs`. They share one version stream and one changelog per root tag. Before 1.0, breaking changes use minor version bumps.
+* Nested modules from their first commit: `gql`, `connect`, and any future package that brings heavy dependencies, such as gqlgen or protobuf, or is likely to need independent versioning. Each has its own `go.mod` and directory-prefixed tags, for example `gql/v0.1.0` and `connect/v0.1.0`.
+* Add dependencies only to the module that needs them. The named core packages remain in the root module; heavy dependencies belong in the relevant nested module.
+* Keep `cmd/docs` in the root module. The [release workflow](/.gitea/workflows/release.yml) listens only for plain `v*` tags, and [GoReleaser](/.goreleaser.yaml) builds `./cmd/docs`, so only root-module tags publish binaries. Prefixed library tags never publish binaries.
+
+This decision establishes the boundary before the planned packages are added. The rule is implemented in [AGENTS.md](/AGENTS.md), and the existing release configuration already follows it. Future packages apply the rule when introduced; no empty modules are needed.
+
+### Consequences
+
+* Light core packages retain coordinated versions and releases. Consumers do not compile dependencies of packages they do not import; module graph pruning helps limit the dependency graph they load.
+* Heavy-dependency and independently versioned packages avoid overlapping ownership of an import path with older root-module versions.
+* Each nested module needs its own dependency maintenance, checks, and prefixed release tags. That bookkeeping is reserved for packages that need the boundary.
+* Root-module consumers share version bumps even when only another core package changes. Moving a shipped root package into a nested module later still requires coordinated releases and consumer upgrades.

docs/adr/20261027T184038082Z-supervise-module-lifecycle-and-managed-workers-within-one-shutdown-budget.md

@@ -0,0 +1,75 @@
+---
+title: "Supervise module lifecycle and managed workers within one shutdown budget"
+date: 2026-10-27
+status: accepted
+implementation: implemented
+summary: Order module startup and reverse cleanup while supervising services and background workers under one bounded shutdown.
+tags:
+  - lifecycle
+supersedes: []
+superseded_by: []
+related:
+  - /docs/adr/20261025T214616275Z-version-light-core-packages-in-the-root-module-and-nest-heavy-dependency-modules.md
+tracking:
+  - https://gitea.auvem.com/corestack/go/issues/5
+implemented_by:
+  - https://gitea.auvem.com/corestack/go/pulls/13
+---
+
+# Supervise module lifecycle and managed workers within one shutdown budget
+
+## Context and Problem Statement
+
+[Issue 5](https://gitea.auvem.com/corestack/go/issues/5) needs ordered startup and supervised concurrent services for Lark Relay's daemons and muxer. Its [follow-up](https://gitea.auvem.com/corestack/go/issues/5#issuecomment-7805) also requires explicit coordination of background workers: canceling service contexts alone cannot establish that the entire app has stopped.
+
+The owner approved a standard-library-only root package, registration-order setup, reverse rollback/teardown, injected signals and logging, joined errors, and one configurable shutdown budget (default 30 seconds) covering teardown and worker completion. Cancellation precedes teardown, which may unblock workers; a second signal abandons shutdown. The owner accepted the API and ownership details after independent review, including the R1/R2/R3 clarifications. It is a clean-room design; no go-toolkit/app source is used.
+
+## Considered Options
+
+* Keep coordination in each application's main function: least library code, but duplicates signal, rollback and worker ownership rules across the initial consumers.
+* Provide only ordered hooks and service supervision: smaller package, but callers still need a second worker coordinator to satisfy the follow-up and share its shutdown deadline.
+* Provide ordered hooks plus a managed-worker launch method: one owner for cancellation, registration closure, errors and the shutdown budget, without a dependency graph or framework.
+
+## Decision Outcome
+
+Choose the third option in `go.auvem.com/corestack/lifecycle`, sharing root-module versions under the accepted module-boundary decision. No CLI integration, dependency DAG, external dependency, restart policy or UI is included.
+
+The public surface is:
+
+```go
+type Module struct {
+    Name     string
+    Setup    func(context.Context) error
+    Teardown func(context.Context) error
+    Run      func(context.Context) error // optional
+}
+type Config struct {
+    Logger          *slog.Logger
+    Signals         <-chan os.Signal
+    ShutdownTimeout time.Duration
+}
+type App struct { /* private state; no stored context */ }
+func New(config Config) (*App, error)
+func (a *App) Register(module Module) error
+func (a *App) Go(ctx context.Context, name string, fn func(context.Context) error) error
+func (a *App) Run(ctx context.Context) error
+```
+
+The accepted signatures have the following edge semantics:
+
+* `New` requires a non-nil logger; zero timeout selects 30 seconds and negative durations fail. `Register` requires a unique nonempty module name and non-nil setup/teardown. Registration closes when `Run` begins; an App runs once. Invalid or late calls return errors without launching work. Configuration is captured by `New` and modules by `Register`, with no global state or initialization side effects.
+* `Run` sets up modules sequentially in registration order using a shared child of its parent context. Only after every setup succeeds does it launch the optional service callbacks concurrently. Dependencies are expressed by registration order and ordinary Go wiring, not lookup or dependency injection APIs. Service scheduling order is unspecified.
+* `Go` is the explicit tooling for background work. A setup or service callback can capture the App and call `Go`; the supplied context must be that callback's lifecycle context or a descendant. Context ancestry is a caller precondition that App cannot generally enforce; detached contexts forfeit graceful cancellation. It launches `fn(ctx)` immediately, tracks completion and errors, and returns once admitted; admission is atomic with shutdown closure. It is available only during setup/running, accepts a nonempty diagnostic name and non-nil function, and is safe for concurrent callers. Worker names need not be unique. Callers must handle admission errors. Raw goroutines remain the caller's responsibility and cannot be included in the completion guarantee.
+* Once startup completes, normal completion means every service and admitted worker has returned nil; no services/workers means immediate normal shutdown. A nil return from just one service/worker does not stop the others. Normal completion atomically closes worker admission so a racing launch is either tracked or rejected. Before startup completes, temporarily having no workers does not end the run.
+* The first setup/service/worker failure, parent cancellation, or received SIGINT/SIGTERM starts shutdown and closes worker admission. Cancel the shared context first, then tear down successfully completed setups in reverse order while services/workers unwind concurrently. Do not wait for workers before teardown: closing a listener or queue may be what releases them. A failing setup owns cleanup of its partial acquisition and is not torn down by App.
+* One fresh shutdown context retains parent values but is detached from parent cancellation and has the configured deadline, measured from the shutdown trigger. Reverse teardown hooks run sequentially with that context; all admitted services/workers share the same remaining completion budget. An in-flight setup is canceled and awaited only within this budget before reverse rollback, avoiding concurrent setup and teardown. Its successful return before abandonment adds it to rollback; failure does not. No further setup starts after shutdown begins.
+* The deadline or a second signal cancels the shutdown context and returns without starting remaining teardown hooks or waiting further for callbacks. App must observe setup/teardown results asynchronously so an uncooperative hook cannot block its return. App will not later call teardown for an abandoned setup, even if it later succeeds; its acquisitions may leak until caller-owned process exit. A cancellation-aware setup must clean up partial acquisitions and return an error when it observes cancellation. Completion reporting must not block after App returns. Go cannot forcibly kill uncooperative goroutines: the bound covers App's coordination and return, not guaranteed resource release or goroutine termination. Callbacks must honor cancellation, and the caller owns process exit and must not reuse abandoned resources. Injected logging must not block shutdown.
+* The caller owns OS signal subscription, filtering to SIGINT/SIGTERM, buffering (at least two), and subscription cleanup. App only receives from the injected channel, never closes it or calls `signal.Notify`, `signal.Stop`, or `os.Exit`. Nil disables signals and a closed channel is disabled. If shutdown began for another reason, the first subsequently received signal counts as the first signal; the next abandons shutdown. Signal counting spans startup and shutdown.
+* Wrap callback failures with module/worker name and phase and combine observed errors using `errors.Join`; retain every completed teardown error, including cancellation errors. A setup/service/worker error solely wrapping its callback context's cancellation/deadline caused by an already-established shutdown is expected and omitted; independent failures and non-cancellation components of joined errors remain errors. An instance-private cancellation cause proves App-initiated cancellation; retain ambiguous parent-propagated cancellation conservatively, including independently canceled descendants. The runtime context remains a direct child of its parent and preserves its deadline. The initiating setup failure remains an error. Parent cancellation returns its context error; graceful signal/normal completion returns nil if cleanup succeeds. Deadline abandonment adds `context.DeadlineExceeded`; signal abandonment adds an error wrapping `context.Canceled` with the signal as context. Retain errors already observed on abandonment, with no promise to collect later results or deterministic concurrent-error order. Do not recover panics.
+
+### Consequences
+
+* One coordinator owns admission, cancellation, hook ordering and completion accounting. Applications must route background work through `Go` and supply cooperative callbacks to claim graceful whole-app completion; this is an explicit boundary, not automatic goroutine discovery.
+* The shutdown bound requires asynchronous hook invocation and synchronized worker admission/completion, even when a consumer has no background workers. A blocked hook can consume the entire budget and leave earlier modules without teardown; a second signal deliberately accepts that same incomplete cleanup sooner.
+* Delivery should remain approximately 300–500 production lines plus focused race tests, a two-service package Example and public/package docs, in one PR. Verify startup/reverse ordering, partial rollback, service and worker failure propagation, normal completion, cancellation/error classification (including a first signal during setup with successful partial cleanup and rollback returning nil, and an initiating setup failure remaining observable), admission races, teardown unblocking workers, a shared deadline (including an uncooperative hook), second signals and joined errors. Test with injected signals, release blocked test goroutines explicitly, and use no real process signals.
+* No plan tier is needed. The accepted decision is implemented by [PR 13](https://gitea.auvem.com/corestack/go/pulls/13), including managed workers, bounded shutdown, focused race tests, the two-service example and public documentation. Independent standard and high implementation reviews are complete with no outstanding findings, and required local checks passed on the reviewed code. Publication is complete; CI and merge readiness are tracked in the PR. Delivery was reconciled against main at `46c4416ed44b4c8cfc69570b9bcb572b624d765e` plus the PR; this records implementation evidence, not a merge or release.

docs/adr/README.md

@@ -0,0 +1,29 @@
+Baseline copied from corestack/standards at a36288e7cec933a32f4819a1308201027c9f57ec; this project owns and may adapt it.
+
+# Documentation policy
+
+The [corestack/go docs-format specification](https://gitea.auvem.com/corestack/go/src/branch/main/docs/docs-format.md) owns record format, templates, and validation. In scaffolded projects, generate records and run checks with the pinned documentation command in the root AGENTS.md; do not maintain local format templates.
+
+The copied policy is a project-owned baseline that the project may adapt; scaffold re-runs never refresh it unless the owner explicitly asks. The project owns its locked checker pin and upgrades: update the tag and ensure compliance; scaffold re-runs retain the existing pin unless the owner asks.
+
+## Choose the smallest useful tier
+
+| Tier | Use when | Scaffold output |
+| --- | --- | --- |
+| Neither | A single-purpose CLI, library, or script has no consequential architectural choice or durable execution context yet. | No record directories and no docs-check CI step; root instructions tell agents to ask the owner to run scaffold-project to enable records when a consequential choice arises. |
+| ADRs only | Consequential choices need durable rationale, but execution fits a short issue or PR. | Local policy in docs/adr/README.md, ADRs as warranted and docs-check CI. |
+| ADRs + plans | Work spans areas, phases, or sessions and needs durable execution context. | Local policy in docs/adr/README.md, a docs/plans/README.md pointer, ADRs as warranted, one file per plan, and docs-check CI. |
+
+Project size is a signal, not an exemption: a small security-sensitive library can warrant an ADR. Add the CI docs-check step exactly when the selected tier enables records. Change tiers when actual work warrants it; do not create empty record directories in anticipation.
+
+## Decisions and execution
+
+Write an ADR for a consequential choice among real alternatives: difficult to reverse, crossing areas, changing a boundary, data model or security posture, or establishing a convention. Routine details and choices already governed by an accepted ADR or practice guide do not need another record. Read relevant accepted decisions and verify their claims against code before dependent work. Proposed ADRs are context, not authority; only the owner accepts a decision.
+
+Write a plan when work spanning areas, phases or sessions needs durable execution context. Otherwise keep planning in a PR, issue or chat. Each plan has its own file; the directory is the index. Never create a central living plan or living PRD checklist that parallel worktrees continually edit. Closed plans are history, never standing instructions.
+
+Use `write-adr` and `review-adr` when available: they guide reasoning while deferring textual format to repository conventions. Seek independent review and owner acceptance before treating a proposal as binding. Neither a self-check nor an independent recommendation accepts an ADR. ADRs may share a PR with implementation; no separate ADR PR or extra sections are required by this policy.
+
+## Reconcile before final review and merge
+
+Compare the latest target branch plus the PR with the affected decisions and plans, not just the working branch's previous metadata. Update ADR implementation state and `implemented_by` with the real PR URL when delivery evidence supports it. Close finished plans with completion evidence and an Outcome; keep work active when scope remains. Never invent PR links, completed checks, owner acceptance, or delivery evidence. Run `docs check` using the pinned documentation command in the root AGENTS.md after reconciliation.

docs/docs-format.md

@@ -0,0 +1,245 @@
+# Docs format
+
+This is the complete specification for architecture decision records (ADRs) and implementation plans checked by `docs check`. It is standalone: a file that follows this document is valid without running the tool. The words MUST, MUST NOT and MAY are used in their RFC 2119 sense.
+
+The ADR body uses the [MADR 4](https://adr.github.io/madr/) layout; `Consequences` is mandatory. The frontmatter, naming and cross-reference rules are specific to this format.
+
+## 1. Files and directories
+
+- ADRs live in `docs/adr/`, plans in `docs/plans/`, relative to the repository root. Both are flat: subdirectories are not scanned and are errors.
+- A missing directory is treated as empty. `docs/adr` and `docs/plans` MUST be real directories: a symlink in their place is an error, and neither may resolve outside the repository through a symlinked parent such as `docs`.
+- Entries whose name starts with `.` (such as `.DS_Store` or editor swap files) are ignored. `README.md` in either directory is skipped. Every other entry MUST be a regular file whose name matches section 2 and ends in `.md`. Any other file, directory or name is an error. There are no other exceptions: no templates and no companion files; every `.md` file is a record.
+- Files are UTF-8 without a byte order mark. LF and CRLF line endings are both accepted.
+
+## 2. Names and IDs
+
+A record file is named `YYYYMMDDTHHMMSSmmmZ-slug.md`, for example `20261023T204512345Z-use-example-queue.md`.
+
+- The timestamp is UTC to the millisecond and MUST be a real date and time.
+- The slug is lowercase `a-z0-9` words joined by single hyphens: no leading, trailing or doubled hyphen, 1 to 80 characters.
+- The filename without `.md` (the stem) is the record's permanent ID. Never rename a record, even to fix its slug; change the title instead.
+- IDs MUST be unique across `docs/adr` and `docs/plans` (compared by the timestamp-and-slug stem).
+- Tools create `docs/<type>/<stem>.md` exclusively (`O_EXCL`) and advance the timestamp by 1 ms on `EEXIST`, or while any record in either directory has the same stem. This is tool behavior and does not affect validity.
+
+## 3. Frontmatter
+
+Every record starts with a YAML frontmatter block: the first line is exactly `---`, and the block ends at the next line that is exactly `---`. The block MUST be a mapping containing exactly the keys listed for the record type, no more, no fewer, each once. Key order is free. Empty lists are written `[]`. A key with no value (null) is an error.
+
+A plain `~`, `null`, `Null` or `NULL` is null, the same as an empty value, and is an error. Every other scalar is a string with no type resolution: its parsed text, whether quoted or not. For example, `date` may be quoted or unquoted, `title: 2026` is the string `2026`, and `title: "null"` is the string `null`. A block scalar (`|`, `>`) is its parsed text. Anchors, aliases, explicit tags and multiple YAML documents are errors. "Single line" means the parsed value contains no line break.
+
+### 3.1 ADR keys
+
+| Key | Type | Rule |
+| --- | --- | --- |
+| `title` | string | Non-empty, single line. |
+| `date` | `YYYY-MM-DD` | Valid date. Equals the date in the filename (UTC). |
+| `status` | enum | `proposed`, `accepted`, `rejected`, `deprecated`, `superseded`. |
+| `implementation` | enum | `not-started`, `in-progress`, `implemented`, `deferred`, `not-applicable`. |
+| `summary` | string | Non-empty, single line. |
+| `tags` | list of strings | Non-empty list. Each tag is lowercase `a-z0-9` words joined by single hyphens; no duplicates. |
+| `supersedes` | list of references | May be empty. |
+| `superseded_by` | list of references | May be empty. |
+| `related` | list of references | May be empty. |
+| `tracking` | list of references | May be empty. |
+| `implemented_by` | list of references | May be empty. |
+
+### 3.2 Plan keys
+
+| Key | Type | Rule |
+| --- | --- | --- |
+| `status` | enum | `draft`, `active`, `completed`, `cancelled`. |
+| `tracking` | list of references | May be empty unless `active`. |
+| `adrs` | list of references | May be empty. |
+| `completion` | list of references | May be empty unless `completed` or `cancelled`. |
+
+A plan has no `title` key; its title is its H1.
+
+### 3.3 References in frontmatter
+
+Every list item is a string. No list may contain duplicates. Which kinds of reference each key accepts:
+
+| Key | Accepts |
+| --- | --- |
+| `supersedes`, `superseded_by`, plan `adrs` | Repo-root paths to ADRs (`/docs/adr/<id>.md`). |
+| `related` | Repo-root paths to any record (`/docs/adr/...` or `/docs/plans/...`). |
+| ADR `tracking` | `http` or `https` URLs, or repo-root paths to plans (`/docs/plans/<id>.md`). |
+| Plan `tracking` | `http` or `https` URLs. |
+| `implemented_by`, `completion` | `http` or `https` URLs (pull request, commit, release), or repo-root paths to existing files. |
+
+See section 7 for what a valid path or URL is. A record MUST NOT reference itself. An ADR whose delivery is tracked by a plan lists the plan in `tracking`; other record-to-record links go in `related`.
+
+Reference lists MUST be durable: an item that is a bare issue number such as `#123` or `owner/repo#123`, or one of the placeholders "this PR", "this pull request" or "this commit" (any case), is rejected. Use a full URL. This applies to whole list items in frontmatter reference lists only; `title`, `summary` and body text are not inspected for it.
+
+## 4. Status
+
+`status` is the decision; `implementation` is delivery of that decision. They are independent except where stated.
+
+ADR `status`:
+
+- `proposed`: under discussion; not binding.
+- `accepted`: the decision stands. Accepting is the owner's act.
+- `rejected`: considered and declined. Requires `implementation: not-applicable`.
+- `deprecated`: once accepted, no longer recommended, with no replacement.
+- `superseded`: replaced by another ADR. Requires non-empty `superseded_by`.
+
+ADR `implementation`:
+
+- `not-started`, `in-progress`, `deferred`: delivery state.
+- `implemented`: requires non-empty `implemented_by`.
+- `not-applicable`: nothing to deliver (required for `rejected`; allowed for any other status).
+
+Per-status requirements, summarized:
+
+| Condition | Requirement |
+| --- | --- |
+| `status: superseded` | `superseded_by` non-empty. |
+| `superseded_by` non-empty | `status: superseded`. |
+| `status: rejected` | `implementation: not-applicable`. |
+| `implementation: implemented` | `implemented_by` non-empty. |
+
+Plan `status`:
+
+| Status | Meaning | `tracking` | `completion` |
+| --- | --- | --- | --- |
+| `draft` | Being written. | any | MUST be empty |
+| `active` | Work under way. | MUST be non-empty | MUST be empty |
+| `completed` | All steps done. | any | MUST be non-empty |
+| `cancelled` | Abandoned. | any | MUST be non-empty |
+
+## 5. Supersession
+
+- If ADR A lists B in `supersedes`, then B MUST list A in `superseded_by`, and the reverse. Both records exist and are ADRs.
+- Supersession MUST NOT form a cycle.
+- The superseding record (A, the one whose `supersedes` lists the other) MUST have status `accepted`, or `superseded` or `deprecated` (it was accepted once and has since moved on). It MUST NOT be `proposed` or `rejected`.
+- While a replacement is `proposed`, list the ADR it would replace in `related`. On acceptance, in the same change, move it to `supersedes` and set the target's `status: superseded` and `superseded_by`.
+- A superseded record keeps its original `date` and filename; only its `status` and `superseded_by` change.
+
+## 6. Body
+
+The body is Markdown (CommonMark) after the frontmatter. Headings inside fenced code blocks or HTML comments do not count. Only headings at the top level of the document count. Required section headings are matched case-sensitively and exactly, at level 2 (`##`). A section runs until the next heading of level 1 or 2, so its subsections belong to it. A required section MUST appear exactly once and contain non-empty prose: at least one paragraph (including paragraphs inside blockquotes), list item or table cell of text. HTML comments and code (fenced, indented or inline) do not count as prose. Extra sections are allowed anywhere.
+
+Heading text is the raw source after the `#` markers, trimmed, with any closing `#` run removed; it is compared byte for byte, with no inline-markup rendering. Setext headings are read as the equivalent ATX heading.
+
+### 6.1 ADR
+
+- The first heading is an H1 whose heading text equals `title`. There is one H1.
+- Required H2 sections: `Context and Problem Statement`, `Considered Options`, `Decision Outcome`.
+- `Decision Outcome` MUST contain exactly one `### Consequences` (H3) subsection with non-empty prose, and at least one prose block before its first H3 subsection. A level-2 `## Consequences` is an error.
+- Optional MADR sections (for example `Decision Drivers`, `Pros and Cons of the Options`, `More Information`) MAY be added.
+
+### 6.2 Plan
+
+- The first heading is a non-empty H1: the plan title. There is one H1.
+- Required H2 sections: `Scope`, `Steps`, `Validation`.
+- `## Outcome` is optional for every status. Closed plans still require `completion` (section 4).
+
+### 6.3 Placeholders
+
+A record is invalid if it still contains the exact marker `{{docs:todo}}` anywhere outside code, including inside a frontmatter string value or list item (write it quoted there: `summary: "{{docs:todo}}"`). A list item equal to the marker reports only the marker error, not the format error for its key. `docs new` writes this marker into each field and section it leaves for you to fill; replace it with content. No other text is treated as a placeholder, so words like TODO or TBD are fine. To mention the marker itself, put it in inline or fenced code.
+
+## 7. References and links
+
+A reference is either a repo-root path or a URL. This applies to frontmatter reference lists and to every Markdown link and image destination in the body (inline, reference-style and autolinks; bare URLs in text are not checked). In the body, link rules apply only to Markdown link destinations: forge autolink shortcuts in plain text (`#123`, `owner/repo#123`, `@user`, commit SHAs) and raw HTML (`<a href>`, `<img src>`) are not inspected. Every link reference definition is checked, whether or not it is used.
+
+Repo-root path:
+
+- Starts with a single `/` and is relative to the repository root, for example `/docs/adr/20261023T204512345Z-use-example-queue.md`. A leading `//` (protocol-relative `//host/...`) is rejected.
+- Repo-root links render correctly on Git forges (GitHub, Gitea) but not in every Markdown viewer.
+- The destination is percent-decoded before the existence check (`%20` is a space). A `?query` is an error.
+- The target MUST exist as a regular file inside the repository, and the path MUST match the target's case exactly, component by component, even on case-insensitive filesystems. Symlinks that resolve outside the repository are rejected.
+- In body links only, a `#fragment` suffix is allowed; the fragment is not verified. In frontmatter, a fragment is an error.
+- Rejected: relative paths (`foo.md`, `./foo.md`), any `..` segment and backslashes. Other non-existent targets, including machine paths such as `/Users/...` or `/home/...`, fail the existence rule; `file:` URLs fail the scheme rule.
+
+URL:
+
+- Scheme `http` or `https` with a host, for example `https://example.com/org/repo/pull/42`. Credentials in the URL (`user:pass@`) are rejected. URLs are not fetched.
+
+Always allowed in body prose only: in-page anchors (`#section`) and `mailto:` links. Any other scheme is rejected.
+
+## 8. What `docs check` reports
+
+`docs check [--root DIR]` checks every record under `DIR` (default: the working directory) and prints one line per problem:
+
+```
+path:line: message
+```
+
+`path` is relative to the root using `/` separators. `line` is the best location of the problem (the key, heading or link), or `1` for file-level problems. Output is sorted by path, then line, then message. The exit status is `1` if any problem is reported, `2` for usage errors, and `0` otherwise, in which case a one-line summary of the records checked is printed.
+
+It reports violations of everything above:
+
+- unexpected files, directories or names; bad timestamps or slugs; duplicate IDs;
+- missing, malformed or unterminated frontmatter; unknown, missing, duplicate or null keys; wrong types or values; `date` not matching the filename;
+- status/implementation/field combinations from section 4;
+- supersession problems from section 5, and self-references;
+- missing, repeated or empty required sections; H1 problems; `{{docs:todo}}` markers;
+- invalid, unresolvable or non-durable references and links.
+
+It does not judge whether a decision is good, whether a record should have been written, or whether a link's fragment exists.
+
+## 9. Minimal valid examples
+
+`docs/adr/20261023T204512345Z-use-example-queue.md`:
+
+```markdown
+---
+title: Use Example Queue for background jobs
+date: 2026-10-23
+status: proposed
+implementation: not-started
+summary: Run background jobs on Example Queue.
+tags:
+  - jobs
+supersedes: []
+superseded_by: []
+related: []
+tracking: []
+implemented_by: []
+---
+
+# Use Example Queue for background jobs
+
+## Context and Problem Statement
+
+Jobs currently run inline and block requests.
+
+## Considered Options
+
+* Example Queue
+* Keep running jobs inline
+
+## Decision Outcome
+
+Chosen option: Example Queue, because it decouples jobs from requests.
+
+### Consequences
+
+* We operate one more service.
+```
+
+`docs/plans/20261023T210000000Z-adopt-example-queue.md`:
+
+```markdown
+---
+status: draft
+tracking: []
+adrs:
+  - /docs/adr/20261023T204512345Z-use-example-queue.md
+completion: []
+---
+
+# Adopt Example Queue
+
+## Scope
+
+Move the email job to Example Queue.
+
+## Steps
+
+1. Add the queue client.
+2. Move the email job.
+
+## Validation
+
+The email job runs from the queue in staging.
+```

go.mod

@@ -0,0 +1,8 @@
+module go.auvem.com/corestack
+
+go 1.27.1
+
+require (
+	github.com/yuin/goldmark v1.8.6
+	go.yaml.in/yaml/v3 v3.0.5
+)

go.sum

@@ -0,0 +1,4 @@
+github.com/yuin/goldmark v1.8.6 h1:d0VcaP1sx9GkFVkoW+KtggpGi2KZ965i14b0+bDQST4=
+github.com/yuin/goldmark v1.8.6/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
+go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
+go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=

internal/docs/adr.go

@@ -0,0 +1,45 @@
+package docs
+
+import "time"
+
+var (
+	adrStatuses = []string{"proposed", "accepted", "rejected", "deprecated", "superseded"}
+	adrImpls    = []string{"not-started", "in-progress", "implemented", "deferred", "not-applicable"}
+	adrRefs     = []refSpec{
+		{"supersedes", kAdr}, {"superseded_by", kAdr}, {"related", kAdr | kPlan},
+		{"tracking", kPlan | kURL}, {"implemented_by", kURL | kFile},
+	}
+)
+
+// adr checks the ADR frontmatter and returns its title for the body check.
+func (c *checker) adr(r *record, m *fm) (string, bool) {
+	m.keys("title", "date", "status", "implementation", "summary", "tags", "supersedes", "superseded_by", "related", "tracking", "implemented_by")
+	title, titleOK := m.text("title")
+	if d, line, ok := m.scalar("date"); ok {
+		if _, err := time.Parse(time.DateOnly, d); err != nil || len(d) != len(time.DateOnly) {
+			c.add(r.path, line, "date must be a valid YYYY-MM-DD date")
+		} else if d != r.date {
+			c.add(r.path, line, "date %s does not match the filename date %s", d, r.date)
+		}
+	}
+	status, statusOK := m.enum("status", adrStatuses...)
+	impl, implOK := m.enum("implementation", adrImpls...)
+	m.text("summary")
+	m.tags()
+	m.refs(adrRefs...)
+	r.status = status
+	if statusOK {
+		if n := len(r.lists["superseded_by"]); status == "superseded" && n == 0 {
+			m.problemf("status", "status superseded requires superseded_by")
+		} else if status != "superseded" && n > 0 {
+			m.problemf("superseded_by", "superseded_by requires status superseded")
+		}
+		if status == "rejected" && implOK && impl != "not-applicable" {
+			m.problemf("implementation", "status rejected requires implementation not-applicable")
+		}
+	}
+	if implOK && impl == "implemented" && len(r.lists["implemented_by"]) == 0 {
+		m.problemf("implementation", "implementation implemented requires implemented_by")
+	}
+	return title, titleOK
+}

internal/docs/body.go

@@ -0,0 +1,322 @@
+package docs
+
+import (
+	"bytes"
+	"regexp"
+	"strings"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/text"
+	"github.com/yuin/goldmark/util"
+)
+
+var (
+	adrSections  = []string{"Context and Problem Statement", "Considered Options", "Decision Outcome"}
+	planSections = []string{"Scope", "Steps", "Validation"}
+)
+
+var atxRe = regexp.MustCompile(`(?m)^ {0,3}#{1,6}(?:[ \t]|$)`)
+
+type heading struct {
+	level int
+	text  string
+	line  int
+	at    int // index among the document's top-level nodes
+}
+
+type doc struct {
+	c         *checker
+	r         *record
+	src       []byte
+	startLine int
+	kids      []ast.Node
+	heads     []heading
+}
+
+func (d *doc) lineAt(off int) int {
+	return d.startLine + bytes.Count(d.src[:min(off, len(d.src))], []byte("\n"))
+}
+
+// blockEnd is the end offset of the last line under n. Only block nodes have lines.
+func blockEnd(n ast.Node) (end int) {
+	_ = ast.Walk(n, func(c ast.Node, enter bool) (ast.WalkStatus, error) {
+		if enter && c.Type() == ast.TypeBlock {
+			for i := range c.Lines().Len() {
+				end = max(end, c.Lines().At(i).Stop)
+			}
+		}
+		return ast.WalkContinue, nil
+	})
+	return end
+}
+
+// emptyHeadingAt is the offset of an empty ATX heading, which has no lines: the first `#`
+// line at or after from, the end of everything before it.
+func (d *doc) emptyHeadingAt(from int) int {
+	if m := atxRe.FindIndex(d.src[from:]); m != nil {
+		return from + m[0]
+	}
+	return from
+}
+
+// lineOf is the line of the first text under n. Without text (an autolink, an image with
+// no alt text) it is the line where needle appears in the enclosing block, else the block's first line.
+func (d *doc) lineOf(n ast.Node, needle string) int {
+	var off = -1
+	_ = ast.Walk(n, func(c ast.Node, enter bool) (ast.WalkStatus, error) {
+		if t, ok := c.(*ast.Text); ok && enter {
+			off = t.Segment.Start
+			return ast.WalkStop, nil
+		}
+		return ast.WalkContinue, nil
+	})
+	for p := n; off < 0 && p != nil; p = p.Parent() {
+		if p.Type() == ast.TypeBlock && p.Lines().Len() > 0 {
+			off = p.Lines().At(0).Start
+			if i := bytes.Index(d.src[off:p.Lines().At(p.Lines().Len()-1).Stop], []byte(needle)); needle != "" && i >= 0 {
+				off += i
+			}
+		}
+	}
+	if off < 0 {
+		return d.startLine
+	}
+	return d.lineAt(off)
+}
+
+func (c *checker) body(r *record, src string, startLine int, title string, titleOK bool) {
+	b := []byte(src)
+	root := goldmark.DefaultParser().Parse(text.NewReader(b))
+	d := &doc{c: c, r: r, src: b, startLine: startLine}
+	from := 0 // end of the blocks seen so far
+	for n := root.FirstChild(); n != nil; n = n.NextSibling() {
+		if h, ok := n.(*ast.Heading); ok {
+			at := from
+			if h.Lines().Len() > 0 {
+				at = h.Lines().At(0).Start
+			} else {
+				at = d.emptyHeadingAt(from)
+				from = at + bytes.IndexByte(d.src[at:], '\n') + 1 // the next line; ^ would match mid-line
+			}
+			d.heads = append(d.heads, heading{h.Level, strings.TrimSpace(string(h.Lines().Value(b))), d.lineAt(at), len(d.kids)})
+		}
+		from = max(from, blockEnd(n))
+		d.kids = append(d.kids, n)
+	}
+	d.placeholders(root)
+	d.links(root)
+	d.title(title, titleOK)
+	if r.kind == "adr" {
+		for _, name := range adrSections {
+			d.section(name)
+		}
+		d.decisionOutcome()
+	} else {
+		for _, name := range planSections {
+			d.section(name)
+		}
+	}
+}
+
+// title checks the single leading H1.
+func (d *doc) title(title string, titleOK bool) {
+	h1s := 0
+	for _, h := range d.heads {
+		if h.level == 1 {
+			if h1s++; h1s > 1 {
+				d.c.add(d.r.path, h.line, "more than one H1")
+			}
+		}
+	}
+	switch first := d.heads; {
+	case len(first) == 0 || first[0].level != 1:
+		d.c.add(d.r.path, d.startLine, "the first heading must be an H1")
+	case d.r.kind == "plan" && first[0].text == "":
+		d.c.add(d.r.path, first[0].line, "the H1 (plan title) must not be empty")
+	case d.r.kind == "adr" && titleOK && first[0].text != title:
+		d.c.add(d.r.path, first[0].line, "H1 %q must equal title %q", first[0].text, title)
+	}
+}
+
+// extent returns the top-level nodes after heading h up to the next heading of level <= upTo.
+func (d *doc) extent(h heading, upTo int) []ast.Node {
+	end := len(d.kids)
+	for _, o := range d.heads {
+		if o.at > h.at && o.level <= upTo {
+			end = o.at
+			break
+		}
+	}
+	return d.kids[h.at+1 : end]
+}
+
+// section finds the one H2 called name and checks that it has prose.
+func (d *doc) section(name string) (heading, bool) {
+	var found []heading
+	for _, h := range d.heads {
+		if h.level == 2 && h.text == name {
+			found = append(found, h)
+		}
+	}
+	switch {
+	case len(found) == 0:
+		d.c.add(d.r.path, 1, "missing required section %q", name)
+	case len(found) > 1:
+		d.c.add(d.r.path, found[1].line, "section %q appears more than once", name)
+	case !d.hasProse(d.extent(found[0], 2)):
+		d.c.add(d.r.path, found[0].line, "section %q has no prose", name)
+		return found[0], true
+	default:
+		return found[0], true
+	}
+	return heading{}, false
+}
+
+func (d *doc) decisionOutcome() {
+	for _, h := range d.heads {
+		if h.level == 2 && h.text == "Consequences" {
+			d.c.add(d.r.path, h.line, "Consequences must be a ### subsection of Decision Outcome, not a ## section")
+		}
+	}
+	var outcome []heading
+	for _, h := range d.heads {
+		if h.level == 2 && h.text == "Decision Outcome" {
+			outcome = append(outcome, h)
+		}
+	}
+	if len(outcome) != 1 {
+		return
+	}
+	h := outcome[0]
+	nodes := d.extent(h, 2)
+	// Prose before the first subsection is the decision itself.
+	pre := nodes
+	for i, n := range nodes {
+		if h, ok := n.(*ast.Heading); ok && h.Level == 3 {
+			pre = nodes[:i]
+			break
+		}
+	}
+	if !d.hasProse(pre) {
+		d.c.add(d.r.path, h.line, "Decision Outcome needs prose before its first subsection")
+	}
+	var cons []heading
+	for _, s := range d.heads {
+		if s.level == 3 && s.text == "Consequences" && s.at > h.at && s.at < h.at+len(nodes)+1 {
+			cons = append(cons, s)
+		}
+	}
+	switch {
+	case len(cons) == 0:
+		d.c.add(d.r.path, h.line, "Decision Outcome must contain a ### Consequences subsection")
+	case len(cons) > 1:
+		d.c.add(d.r.path, cons[1].line, "### Consequences appears more than once")
+	case !d.hasProse(d.extent(cons[0], 3)):
+		d.c.add(d.r.path, cons[0].line, "### Consequences has no prose")
+	}
+}
+
+// hasProse reports whether nodes hold a paragraph with text outside code, images and raw HTML.
+func (d *doc) hasProse(nodes []ast.Node) bool {
+	for _, n := range nodes {
+		found := false
+		_ = ast.Walk(n, func(c ast.Node, enter bool) (ast.WalkStatus, error) {
+			switch c.(type) {
+			case *ast.Paragraph, *ast.TextBlock:
+				if enter && strings.TrimSpace(d.inlineText(c)) != "" {
+					found = true
+					return ast.WalkStop, nil
+				}
+				return ast.WalkSkipChildren, nil
+			}
+			return ast.WalkContinue, nil
+		})
+		if found {
+			return true
+		}
+	}
+	return false
+}
+
+func (d *doc) inlineText(n ast.Node) string {
+	var s strings.Builder
+	for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+		switch t := c.(type) {
+		case *ast.Text:
+			s.Write(t.Segment.Value(d.src))
+		case *ast.String:
+			s.Write(t.Value)
+		case *ast.CodeSpan, *ast.RawHTML, *ast.Image:
+		default:
+			s.WriteString(d.inlineText(c))
+		}
+	}
+	return s.String()
+}
+
+// codeRanges returns the source ranges of code blocks and code spans.
+func codeRanges(root ast.Node) (code [][2]int) {
+	_ = ast.Walk(root, func(n ast.Node, enter bool) (ast.WalkStatus, error) {
+		switch n.(type) {
+		case *ast.FencedCodeBlock, *ast.CodeBlock:
+			for i := range n.Lines().Len() {
+				seg := n.Lines().At(i)
+				code = append(code, [2]int{seg.Start, seg.Stop})
+			}
+		case *ast.CodeSpan:
+			for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+				if t, ok := c.(*ast.Text); ok {
+					code = append(code, [2]int{t.Segment.Start, t.Segment.Stop})
+				}
+			}
+		}
+		return ast.WalkContinue, nil
+	})
+	return code
+}
+
+// placeholders reports every marker outside code.
+func (d *doc) placeholders(root ast.Node) {
+	code := codeRanges(root)
+	for off := 0; ; {
+		i := strings.Index(string(d.src[off:]), marker)
+		if i < 0 {
+			return
+		}
+		at := off + i
+		off = at + len(marker)
+		inCode := false
+		for _, r := range code {
+			inCode = inCode || at >= r[0] && at < r[1]
+		}
+		if !inCode {
+			d.c.add(d.r.path, d.lineAt(at), "unfinished placeholder %s", marker)
+		}
+	}
+}
+
+// dest decodes a link destination as CommonMark does before it is used.
+func dest(b []byte) string {
+	return string(util.ResolveEntityNames(util.ResolveNumericReferences(util.UnescapePunctuations(b))))
+}
+
+// links checks every link, image and autolink destination and every reference definition.
+func (d *doc) links(root ast.Node) {
+	_ = ast.Walk(root, func(n ast.Node, enter bool) (ast.WalkStatus, error) {
+		if !enter {
+			return ast.WalkContinue, nil
+		}
+		switch t := n.(type) {
+		case *ast.Link:
+			d.c.checkLink(d.r, d.lineOf(n, "]("+string(t.Destination)), dest(t.Destination))
+		case *ast.Image:
+			d.c.checkLink(d.r, d.lineOf(n, "]("+string(t.Destination)), dest(t.Destination))
+		case *ast.AutoLink:
+			d.c.checkLink(d.r, d.lineOf(n, "<"+string(t.Label(d.src))), string(t.URL(d.src)))
+		case *ast.LinkReferenceDefinition:
+			d.c.checkLink(d.r, d.lineAt(t.Lines().At(0).Start), dest(t.Destination))
+		}
+		return ast.WalkContinue, nil
+	})
+}

internal/docs/check.go

@@ -0,0 +1,135 @@
+// Package docs creates and checks the ADR and plan records described in docs/docs-format.md.
+package docs
+
+import (
+	"bytes"
+	"embed"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"unicode/utf8"
+)
+
+//go:embed templates/*.md
+var templates embed.FS
+
+var dirs = []struct{ kind, dir string }{{"adr", "docs/adr"}, {"plan", "docs/plans"}}
+
+// Problem is one violation of the format. Line is 1 for file-level problems.
+type Problem struct {
+	Path string
+	Line int
+	Msg  string
+}
+
+func (p Problem) String() string { return fmt.Sprintf("%s:%d: %s", p.Path, p.Line, p.Msg) }
+
+// Result is the outcome of Check: the number of records read and the sorted problems.
+type Result struct {
+	Records  int
+	Problems []Problem
+}
+
+type record struct {
+	path, kind, stem, date string
+	status                 string
+	lists                  map[string][]item
+	fm                     *fm
+}
+
+type checker struct {
+	root, realRoot string
+	problems       []Problem
+}
+
+func (c *checker) add(path string, line int, format string, args ...any) {
+	c.problems = append(c.problems, Problem{path, line, fmt.Sprintf(format, args...)})
+}
+
+// Check validates every record under root. The error is for I/O failures only.
+func Check(root string) (Result, error) {
+	real, err := filepath.EvalSymlinks(root)
+	if err != nil {
+		return Result{}, err
+	}
+	c := &checker{root: root, realRoot: real}
+	var recs []*record
+	for _, d := range dirs {
+		if st, err := os.Lstat(filepath.Join(root, d.dir)); os.IsNotExist(err) {
+			continue
+		} else if err == nil && !st.IsDir() {
+			c.add(d.dir, 1, "must be a real directory (symlinks are not allowed)")
+			continue
+		} else if r, err := filepath.EvalSymlinks(filepath.Join(root, d.dir)); err == nil && !within(real, r) {
+			c.add(d.dir, 1, "must be inside the repository (a symlinked parent directory is not allowed)")
+			continue
+		}
+		entries, err := os.ReadDir(filepath.Join(root, d.dir))
+		if err != nil {
+			return Result{}, err
+		}
+		for _, e := range entries {
+			name := e.Name()
+			if strings.HasPrefix(name, ".") || name == "README.md" {
+				continue
+			}
+			rel := d.dir + "/" + name
+			if !e.Type().IsRegular() {
+				c.add(rel, 1, "must be a regular file (subdirectories, symlinks and other entries are not allowed)")
+				continue
+			}
+			stem, at, msg := parseName(name)
+			if msg != "" {
+				c.add(rel, 1, "%s", msg)
+				continue
+			}
+			r := &record{path: rel, kind: d.kind, stem: stem, date: at.Format("2006-01-02"), lists: map[string][]item{}}
+			if err := c.record(r); err != nil {
+				return Result{}, err
+			}
+			recs = append(recs, r)
+		}
+	}
+	c.graph(recs)
+	slices.SortFunc(c.problems, func(a, b Problem) int {
+		return strings.Compare(fmt.Sprintf("%s\x00%09d\x00%s", a.Path, a.Line, a.Msg), fmt.Sprintf("%s\x00%09d\x00%s", b.Path, b.Line, b.Msg))
+	})
+	return Result{len(recs), c.problems}, nil
+}
+
+func (c *checker) record(r *record) error {
+	data, err := os.ReadFile(filepath.Join(c.root, filepath.FromSlash(r.path)))
+	if err != nil {
+		return err
+	}
+	if bytes.HasPrefix(data, []byte("\xef\xbb\xbf")) {
+		c.add(r.path, 1, "file must not start with a byte order mark")
+		return nil
+	}
+	if !utf8.Valid(data) {
+		c.add(r.path, 1, "file must be valid UTF-8")
+		return nil
+	}
+	src := strings.ReplaceAll(string(data), "\r\n", "\n")
+	front, body, bodyLine, msg := splitFrontmatter(src)
+	if msg != "" {
+		c.add(r.path, 1, "%s", msg)
+		return nil
+	}
+	m, ok := c.parseFrontmatter(r, front)
+	if !ok {
+		return nil
+	}
+	r.fm = m
+	var title string
+	var titleOK bool
+	if r.kind == "adr" {
+		title, titleOK = c.adr(r, m)
+	} else {
+		c.plan(r, m)
+	}
+	c.body(r, body, bodyLine, title, titleOK)
+	return nil
+}

internal/docs/check_test.go

@@ -0,0 +1,390 @@
+package docs
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+const (
+	aID   = "20261023T204512345Z-use-queue"
+	aPath = "docs/adr/" + aID + ".md"
+	bPath = "docs/adr/20261024T000000000Z-second.md"
+	pPath = "docs/plans/20261023T210000000Z-adopt-queue.md"
+
+	// Line numbers in the expectations below refer to these documents.
+	adrBase = `---
+title: Use Queue
+date: 2026-10-23
+status: proposed
+implementation: not-started
+summary: Run jobs on a queue.
+tags:
+  - jobs
+supersedes: []
+superseded_by: []
+related: []
+tracking: []
+implemented_by: []
+---
+
+# Use Queue
+
+## Context and Problem Statement
+
+Jobs block requests.
+
+## Considered Options
+
+* Queue
+* Inline
+
+## Decision Outcome
+
+Chosen option: Queue.
+
+### Consequences
+
+* One more service.
+`
+	// bBase is a second ADR (dated 2026-10-24) that may supersede or be superseded.
+	bBase = `---
+title: Second
+date: 2026-10-24
+status: accepted
+implementation: not-started
+summary: Second.
+tags:
+  - jobs
+supersedes: []
+superseded_by: []
+related: []
+tracking: []
+implemented_by: []
+---
+
+# Second
+
+## Context and Problem Statement
+
+Why.
+
+## Considered Options
+
+* A
+
+## Decision Outcome
+
+Chosen option: A.
+
+### Consequences
+
+* Some.
+`
+	planBase = `---
+status: draft
+tracking: []
+adrs: []
+completion: []
+---
+
+# Adopt Queue
+
+## Scope
+
+Move the job.
+
+## Steps
+
+1. Do it.
+
+## Validation
+
+It runs.
+`
+)
+
+// sub replaces old with new in s once; a stale expectation fails loudly.
+func sub(s string, pairs ...string) string {
+	for i := 0; i < len(pairs); i += 2 {
+		if !strings.Contains(s, pairs[i]) {
+			panic("fixture does not contain " + pairs[i])
+		}
+		s = strings.Replace(s, pairs[i], pairs[i+1], 1)
+	}
+	return s
+}
+
+func tree(t *testing.T, files, links map[string]string) string {
+	t.Helper()
+	root, outside := t.TempDir(), t.TempDir()
+	if err := os.WriteFile(filepath.Join(outside, "f.md"), []byte("x"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	for p, content := range files {
+		full := filepath.Join(root, p)
+		if strings.HasSuffix(p, "/") {
+			must(t, os.MkdirAll(full, 0o755))
+			continue
+		}
+		must(t, os.MkdirAll(filepath.Dir(full), 0o755))
+		must(t, os.WriteFile(full, []byte(content), 0o644))
+	}
+	for p, target := range links {
+		must(t, os.MkdirAll(filepath.Dir(filepath.Join(root, p)), 0o755))
+		must(t, os.Symlink(strings.Replace(target, "@outside", outside, 1), filepath.Join(root, p)))
+	}
+	return root
+}
+
+func must(t *testing.T, err error) {
+	t.Helper()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+var wantRe = regexp.MustCompile(`^(.*?:\d+): (.*)$`)
+
+// expect requires got and want to pair up one to one. A want is "path:line: message substring"; the path may be a suffix.
+func expect(t *testing.T, got []Problem, want []string) {
+	t.Helper()
+	left := append([]Problem(nil), got...)
+	for _, w := range want {
+		m := wantRe.FindStringSubmatch(w)
+		found := false
+		for i, p := range left {
+			if strings.HasSuffix(fmt.Sprintf("%s:%d", p.Path, p.Line), m[1]) && strings.Contains(p.Msg, m[2]) {
+				left = append(left[:i], left[i+1:]...)
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("missing problem %q in %v", w, got)
+		}
+	}
+	for _, p := range left {
+		t.Errorf("unexpected problem %s", p)
+	}
+}
+
+var support = map[string]string{
+	bPath:            bBase,
+	pPath:            planBase,
+	"docs/spec.txt":  "spec",
+	"docs/sp ace.md": "space",
+}
+
+// withSupport adds the shared targets to a case's files.
+func withSupport(files map[string]string) map[string]string {
+	all := map[string]string{}
+	for k, v := range support {
+		all[k] = v
+	}
+	for k, v := range files {
+		all[k] = v
+	}
+	return all
+}
+
+func TestCheck(t *testing.T) {
+	long := strings.Repeat("a", 81)
+	tests := []struct {
+		name  string
+		files map[string]string
+		links map[string]string
+		want  []string
+	}{
+		// 1. Files and directories
+		{name: "dot entries and README are skipped", files: map[string]string{"docs/adr/.DS_Store": "x", "docs/adr/README.md": "x", "docs/plans/README.md": "x"}},
+		{name: "subdirectory", files: map[string]string{"docs/adr/sub/": ""}, want: []string{"docs/adr/sub:1: regular file"}},
+		{name: "non-md file", files: map[string]string{"docs/plans/notes.txt": "x"}, want: []string{"docs/plans/notes.txt:1: name must be"}},
+		{name: "template-like name", files: map[string]string{"docs/adr/template.md": "x"}, want: []string{"docs/adr/template.md:1: name must be"}},
+		{name: "symlinked record", files: map[string]string{"docs/spec.txt": "x"}, links: map[string]string{"docs/adr/20261023T204512345Z-s.md": "@outside/f.md"}, want: []string{"20261023T204512345Z-s.md:1: regular file"}},
+		{name: "CRLF accepted", files: map[string]string{aPath: strings.ReplaceAll(adrBase, "\n", "\r\n")}},
+		{name: "BOM", files: map[string]string{aPath: "\xef\xbb\xbf" + adrBase}, want: []string{aPath + ":1: byte order mark"}},
+		{name: "invalid UTF-8", files: map[string]string{aPath: adrBase + "\xff\n"}, want: []string{aPath + ":1: UTF-8"}},
+
+		// 2. Names and IDs
+		{name: "invalid timestamp", files: map[string]string{"docs/adr/20261323T204512345Z-x.md": adrBase}, want: []string{"20261323T204512345Z-x.md:1: invalid UTC timestamp"}},
+		{name: "slug double hyphen", files: map[string]string{"docs/adr/20261023T204512345Z-a--b.md": adrBase}, want: []string{"a--b.md:1: slug must be"}},
+		{name: "slug uppercase", files: map[string]string{"docs/adr/20261023T204512345Z-Ab.md": adrBase}, want: []string{"Ab.md:1: slug must be"}},
+		{name: "slug trailing hyphen", files: map[string]string{"docs/adr/20261023T204512345Z-ab-.md": adrBase}, want: []string{"ab-.md:1: slug must be"}},
+		{name: "slug 80 characters", files: map[string]string{"docs/adr/20261023T204512345Z-" + long[:80] + ".md": adrBase}},
+		{name: "slug 81 characters", files: map[string]string{"docs/adr/20261023T204512345Z-" + long + ".md": adrBase}, want: []string{".md:1: longer than 80"}},
+		{name: "duplicate ID across directories", files: map[string]string{"docs/adr/20261023T210000000Z-adopt-queue.md": adrBase, pPath: planBase},
+			want: []string{"docs/adr/20261023T210000000Z-adopt-queue.md:1: duplicate ID", pPath + ":1: duplicate ID"}},
+
+		// 3. Frontmatter
+		{name: "no frontmatter", files: map[string]string{aPath: "# Use Queue\n"}, want: []string{aPath + ":1: --- frontmatter"}},
+		{name: "unterminated frontmatter", files: map[string]string{aPath: "---\ntitle: x\n"}, want: []string{aPath + ":1: not closed"}},
+		{name: "empty frontmatter", files: map[string]string{aPath: "---\n---\n# x\n"}, want: []string{aPath + ":2: empty"}},
+		{name: "frontmatter is a list", files: map[string]string{aPath: "---\n- a\n---\n"}, want: []string{aPath + ":2: mapping"}},
+		{name: "invalid YAML", files: map[string]string{aPath: sub(adrBase, "title: Use Queue", "title: [")}, want: []string{aPath + ":3: invalid YAML"}},
+		{name: "multiple YAML documents", files: map[string]string{aPath: sub(adrBase, "title: Use Queue\n", "title: Use Queue\n...\nx: y\n")}, want: []string{aPath + ":2: single YAML document"}},
+		{name: "anchor and alias", files: map[string]string{aPath: sub(adrBase, "supersedes: []\nsuperseded_by: []", "supersedes: &a []\nsuperseded_by: *a")}, want: []string{aPath + ":9: anchors", aPath + ":10: aliases"}},
+		{name: "explicit tag", files: map[string]string{aPath: sub(adrBase, "summary: Run", "summary: !!str Run")}, want: []string{aPath + ":6: explicit"}},
+		{name: "unknown key", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by: []\nextra: x")}, want: []string{aPath + ":14: unknown key"}},
+		{name: "missing key", files: map[string]string{aPath: sub(adrBase, "related: []\n", "")}, want: []string{aPath + ":1: missing key \"related\""}},
+		{name: "duplicate key", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by: []\nsummary: again")}, want: []string{aPath + ":14: duplicate key"}},
+		{name: "null tilde", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", "summary: ~")}, want: []string{aPath + ":6: must not be null"}},
+		{name: "null empty", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", "summary:")}, want: []string{aPath + ":6: must not be null"}},
+		{name: "null word", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", "summary: Null")}, want: []string{aPath + ":6: must not be null"}},
+		{name: "scalars are literal text", files: map[string]string{aPath: sub(adrBase, "title: Use Queue", "title: 2026", "# Use Queue", "# 2026", "date: 2026-10-23", `date: "2026-10-23"`, "summary: Run jobs on a queue.", `summary: "null"`)}},
+		{name: "null lowercase", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", "summary: null")}, want: []string{aPath + ":6: must not be null"}},
+		{name: "null uppercase", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", "summary: NULL")}, want: []string{aPath + ":6: must not be null"}},
+		{name: "list item is null", files: map[string]string{aPath: sub(adrBase, "related: []", "related:\n  - ~")}, want: []string{aPath + ":12: must not be null"}},
+
+		// 3.1 ADR keys
+		{name: "empty title", files: map[string]string{aPath: sub(adrBase, "title: Use Queue", `title: ""`)}, want: []string{aPath + ":2: title must be a non-empty single line"}},
+		{name: "multi-line summary", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", "summary: |\n  a\n  b")}, want: []string{aPath + ":6: summary must be a non-empty single line"}},
+		{name: "title is a list", files: map[string]string{aPath: sub(adrBase, "title: Use Queue", "title: [a]")}, want: []string{aPath + ":2: title must be a string"}},
+		{name: "invalid date", files: map[string]string{aPath: sub(adrBase, "date: 2026-10-23", "date: 2026-13-40")}, want: []string{aPath + ":3: valid YYYY-MM-DD"}},
+		{name: "date differs from filename", files: map[string]string{aPath: sub(adrBase, "date: 2026-10-23", "date: 2026-10-24")}, want: []string{aPath + ":3: does not match"}},
+		{name: "invalid status", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: done")}, want: []string{aPath + ":4: status must be one of"}},
+		{name: "invalid implementation", files: map[string]string{aPath: sub(adrBase, "implementation: not-started", "implementation: done")}, want: []string{aPath + ":5: implementation must be one of"}},
+		{name: "empty tags", files: map[string]string{aPath: sub(adrBase, "tags:\n  - jobs", "tags: []")}, want: []string{aPath + ":7: tags must not be empty"}},
+		{name: "tags is a string", files: map[string]string{aPath: sub(adrBase, "tags:\n  - jobs", "tags: jobs")}, want: []string{aPath + ":7: tags must be a list"}},
+		{name: "bad tag", files: map[string]string{aPath: sub(adrBase, "  - jobs", "  - Bad_Tag")}, want: []string{aPath + ":8: tag"}},
+		{name: "duplicate tag", files: map[string]string{aPath: sub(adrBase, "  - jobs", "  - jobs\n  - jobs")}, want: []string{aPath + ":9: duplicate tag"}},
+
+		// 3.2 Plan keys
+		{name: "plan has unknown title key", files: map[string]string{pPath: sub(planBase, "status: draft", "status: draft\ntitle: x")}, want: []string{pPath + ":3: unknown key"}},
+		{name: "plan invalid status", files: map[string]string{pPath: sub(planBase, "status: draft", "status: done")}, want: []string{pPath + ":2: status must be one of"}},
+
+		// 3.3 References
+		{name: "related accepts ADR and plan", files: map[string]string{aPath: sub(adrBase, "related: []", "related:\n  - /"+bPath+"\n  - /"+pPath)}},
+		{name: "ADR tracking accepts URL and plan", files: map[string]string{aPath: sub(adrBase, "tracking: []", "tracking:\n  - https://example.com/issues/1\n  - /"+pPath)}},
+		{name: "ADR tracking rejects ADR path", files: map[string]string{aPath: sub(adrBase, "tracking: []", "tracking:\n  - /"+bPath)}, want: []string{aPath + ":13: tracking"}},
+		{name: "plan tracking rejects path", files: map[string]string{pPath: sub(planBase, "tracking: []", "tracking:\n  - /"+aPath)}, want: []string{pPath + ":4: tracking"}},
+		{name: "plan tracking accepts URL", files: map[string]string{pPath: sub(planBase, "tracking: []", "tracking:\n  - https://example.com/issues/1")}},
+		{name: "plan adrs accepts ADR", files: map[string]string{aPath: adrBase, pPath: sub(planBase, "adrs: []", "adrs:\n  - /"+aPath)}},
+		{name: "plan adrs rejects plan", files: map[string]string{pPath: sub(planBase, "adrs: []", "adrs:\n  - /"+pPath)}, want: []string{pPath + ":5: adrs"}},
+		{name: "implemented_by accepts URL and file", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - https://example.com/pr/1\n  - /docs/spec.txt")}},
+		{name: "implemented_by missing file", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - /docs/missing.txt")}, want: []string{aPath + ":14: does not exist"}},
+		{name: "reference to missing ADR", files: map[string]string{aPath: sub(adrBase, "related: []", "related:\n  - /docs/adr/20261023T000000000Z-gone.md")}, want: []string{aPath + ":12: does not exist"}},
+		{name: "duplicate reference", files: map[string]string{aPath: sub(adrBase, "related: []", "related:\n  - /"+bPath+"\n  - /"+bPath)}, want: []string{aPath + ":13: duplicate reference"}},
+		{name: "self reference", files: map[string]string{aPath: sub(adrBase, "related: []", "related:\n  - /"+aPath)}, want: []string{aPath + ":12: itself"}},
+		{name: "bare issue number", files: map[string]string{aPath: sub(adrBase, "tracking: []", "tracking:\n  - \"#123\"")}, want: []string{aPath + ":13: not durable"}},
+		{name: "owner repo issue number", files: map[string]string{aPath: sub(adrBase, "tracking: []", "tracking:\n  - example/repo#123")}, want: []string{aPath + ":13: not durable"}},
+		{name: "this PR placeholder", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - This PR")}, want: []string{aPath + ":14: not durable"}},
+		{name: "fragment in frontmatter", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - /docs/spec.txt#x")}, want: []string{aPath + ":14: fragments"}},
+		{name: "credentials in frontmatter URL", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - https://u:p@example.com/x")}, want: []string{aPath + ":14: credentials"}},
+		{name: "mailto in frontmatter", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - mailto:a@example.com")}, want: []string{aPath + ":14: scheme"}},
+		{name: "anchor in frontmatter", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - \"#anchor\"")}, want: []string{aPath + ":14: relative"}},
+		{name: "symlink escape in frontmatter", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - /docs/out/f.md")}, links: map[string]string{"docs/out": "@outside"}, want: []string{aPath + ":14: outside the repository"}},
+		{name: "percent-encoded self reference", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - /docs/adr/20261023T204512345Z-use%2Dqueue.md")}, want: []string{aPath + ":14: itself"}},
+		{name: "supersedes rejects plan path", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: accepted", "supersedes: []", "supersedes:\n  - /"+pPath)}, want: []string{aPath + ":10: supersedes"}},
+		{name: "relative path in frontmatter", files: map[string]string{aPath: sub(adrBase, "implemented_by: []", "implemented_by:\n  - ../docs/spec.txt")}, want: []string{aPath + ":14: relative"}},
+
+		// 4. Status
+		{name: "superseded needs superseded_by", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: superseded")}, want: []string{aPath + ":4: requires superseded_by"}},
+		{name: "superseded_by needs superseded", files: map[string]string{aPath: sub(adrBase, "superseded_by: []", "superseded_by:\n  - /"+bPath), bPath: sub(bBase, "supersedes: []", "supersedes:\n  - /"+aPath)}, want: []string{aPath + ":10: requires status superseded"}},
+		{name: "rejected needs not-applicable", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: rejected")}, want: []string{aPath + ":5: not-applicable"}},
+		{name: "rejected not-applicable", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: rejected", "implementation: not-started", "implementation: not-applicable")}},
+		{name: "implemented needs implemented_by", files: map[string]string{aPath: sub(adrBase, "implementation: not-started", "implementation: implemented")}, want: []string{aPath + ":5: requires implemented_by"}},
+		{name: "implemented with implemented_by", files: map[string]string{aPath: sub(adrBase, "implementation: not-started", "implementation: implemented", "implemented_by: []", "implemented_by:\n  - https://example.com/pr/1")}},
+		{name: "active plan needs tracking", files: map[string]string{pPath: sub(planBase, "status: draft", "status: active")}, want: []string{pPath + ":2: requires tracking"}},
+		{name: "active plan valid", files: map[string]string{pPath: sub(planBase, "status: draft", "status: active", "tracking: []", "tracking:\n  - https://example.com/issues/1")}},
+		{name: "active plan with completion", files: map[string]string{pPath: sub(planBase, "status: draft", "status: active", "tracking: []", "tracking:\n  - https://example.com/issues/1", "completion: []", "completion:\n  - https://example.com/pr/1")}, want: []string{pPath + ":6: completion must be empty"}},
+		{name: "draft plan with completion", files: map[string]string{pPath: sub(planBase, "completion: []", "completion:\n  - https://example.com/pr/1")}, want: []string{pPath + ":5: completion must be empty"}},
+		{name: "completed plan needs completion", files: map[string]string{pPath: sub(planBase, "status: draft", "status: completed")}, want: []string{pPath + ":2: requires completion"}},
+		{name: "cancelled plan needs completion", files: map[string]string{pPath: sub(planBase, "status: draft", "status: cancelled")}, want: []string{pPath + ":2: requires completion"}},
+		{name: "completed plan valid", files: map[string]string{pPath: sub(planBase, "status: draft", "status: completed", "completion: []", "completion:\n  - https://example.com/pr/1")}},
+
+		// 5. Supersession
+		{name: "supersession valid", files: map[string]string{
+			aPath: sub(adrBase, "status: proposed", "status: superseded", "superseded_by: []", "superseded_by:\n  - /"+bPath),
+			bPath: sub(bBase, "supersedes: []", "supersedes:\n  - /"+aPath)}},
+		{name: "supersedes not reciprocated", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: accepted", "supersedes: []", "supersedes:\n  - /"+bPath)}, want: []string{aPath + ":10: must list this record in superseded_by"}},
+		{name: "superseded_by not reciprocated", files: map[string]string{aPath: sub(adrBase, "status: proposed", "status: superseded", "superseded_by: []", "superseded_by:\n  - /"+bPath)}, want: []string{aPath + ":11: must list this record in supersedes"}},
+		{name: "superseder is proposed", files: map[string]string{
+			aPath: sub(adrBase, "supersedes: []", "supersedes:\n  - /"+bPath),
+			bPath: sub(bBase, "status: accepted", "status: superseded", "superseded_by: []", "superseded_by:\n  - /"+aPath)}, want: []string{aPath + ":9: must be accepted"}},
+		{name: "superseder is deprecated", files: map[string]string{
+			aPath: sub(adrBase, "status: proposed", "status: superseded", "superseded_by: []", "superseded_by:\n  - /"+bPath),
+			bPath: sub(bBase, "status: accepted", "status: deprecated", "supersedes: []", "supersedes:\n  - /"+aPath)}},
+		{name: "superseder is rejected", files: map[string]string{
+			aPath: sub(adrBase, "status: proposed", "status: rejected", "implementation: not-started", "implementation: not-applicable", "supersedes: []", "supersedes:\n  - /"+bPath),
+			bPath: sub(bBase, "status: accepted", "status: superseded", "superseded_by: []", "superseded_by:\n  - /"+aPath)}, want: []string{aPath + ":9: must be accepted"}},
+		{name: "supersession cycle", files: map[string]string{
+			aPath: sub(adrBase, "status: proposed", "status: superseded", "supersedes: []", "supersedes:\n  - /"+bPath, "superseded_by: []", "superseded_by:\n  - /"+bPath),
+			bPath: sub(bBase, "status: accepted", "status: superseded", "supersedes: []", "supersedes:\n  - /"+aPath, "superseded_by: []", "superseded_by:\n  - /"+aPath)}, want: []string{bPath + ":10: cycle"}},
+
+		// 6. Body
+		{name: "no H1", files: map[string]string{aPath: sub(adrBase, "# Use Queue\n\n", "")}, want: []string{aPath + ":15: first heading must be an H1"}},
+		{name: "H1 differs from title", files: map[string]string{aPath: sub(adrBase, "# Use Queue", "# Other")}, want: []string{aPath + ":16: must equal title"}},
+		{name: "two H1s", files: map[string]string{aPath: adrBase + "\n# Again\n"}, want: []string{aPath + ":35: more than one H1"}},
+		{name: "missing required section", files: map[string]string{aPath: sub(adrBase, "## Considered Options\n\n* Queue\n* Inline\n\n", "")}, want: []string{aPath + ":1: missing required section \"Considered Options\""}},
+		{name: "repeated section", files: map[string]string{aPath: adrBase + "\n## Considered Options\n\nMore.\n"}, want: []string{aPath + ":35: appears more than once"}},
+		{name: "heading in code does not count", files: map[string]string{aPath: sub(adrBase, "## Considered Options", "```\n## Considered Options\n```")}, want: []string{aPath + ":1: missing required section \"Considered Options\""}},
+		{name: "section with only a comment", files: map[string]string{aPath: sub(adrBase, "* Queue\n* Inline", "<!-- none -->")}, want: []string{aPath + ":22: has no prose"}},
+		{name: "section with only code", files: map[string]string{aPath: sub(adrBase, "* Queue\n* Inline", "```\nQueue\n```")}, want: []string{aPath + ":22: has no prose"}},
+		{name: "section with only inline code", files: map[string]string{aPath: sub(adrBase, "* Queue\n* Inline", "`Queue`")}, want: []string{aPath + ":22: has no prose"}},
+		{name: "subsection prose counts for the section", files: map[string]string{aPath: sub(adrBase, "Jobs block requests.", "### Detail\n\nJobs block requests.")}},
+		{name: "setext, closing hashes and blockquote", files: map[string]string{aPath: sub(adrBase, "## Context and Problem Statement", "## Context and Problem Statement ##", "## Considered Options\n\n* Queue\n* Inline", "Considered Options\n------\n\n> Queue or inline.")}},
+		{name: "extra sections allowed", files: map[string]string{aPath: adrBase + "\n## More Information\n\nSee above.\n"}},
+		{name: "Consequences as H2", files: map[string]string{aPath: sub(adrBase, "### Consequences", "## Consequences")},
+			want: []string{aPath + ":31: not a ## section", aPath + ":27: must contain a ### Consequences"}},
+		{name: "missing Consequences", files: map[string]string{aPath: sub(adrBase, "### Consequences\n\n* One more service.\n", "")}, want: []string{aPath + ":27: must contain a ### Consequences"}},
+		{name: "repeated Consequences", files: map[string]string{aPath: adrBase + "\n### Consequences\n\nAgain.\n"}, want: []string{aPath + ":35: appears more than once"}},
+		{name: "Consequences without prose", files: map[string]string{aPath: sub(adrBase, "* One more service.", "<!-- later -->")}, want: []string{aPath + ":31: has no prose"}},
+		{name: "Decision Outcome without own prose", files: map[string]string{aPath: sub(adrBase, "Chosen option: Queue.\n\n", "")}, want: []string{aPath + ":27: needs prose before"}},
+		{name: "plan missing section", files: map[string]string{pPath: sub(planBase, "## Steps\n\n1. Do it.\n\n", "")}, want: []string{pPath + ":1: missing required section \"Steps\""}},
+		{name: "plan empty H1", files: map[string]string{pPath: sub(planBase, "# Adopt Queue", "#")}, want: []string{pPath + ":8: H1"}},
+		{name: "empty ADR H1 is on its own line", files: map[string]string{aPath: sub(adrBase, "# Use Queue", "#")}, want: []string{aPath + ":16: must equal title"}},
+		{name: "empty H2 after a paragraph", files: map[string]string{aPath: adrBase + "\nText.\n\n##\n"}},
+		{name: "H1 after an empty H2 after a paragraph", files: map[string]string{aPath: adrBase + "\nText.\n\n##\n#\n"}, want: []string{aPath + ":38: more than one H1"}},
+		{name: "empty H1 after a thematic break", files: map[string]string{aPath: adrBase + "\n***\n#\n"}, want: []string{aPath + ":36: more than one H1"}},
+		{name: "two empty H1s", files: map[string]string{aPath: adrBase + "\n#\n#\n"}, want: []string{aPath + ":35: more than one H1", aPath + ":36: more than one H1"}},
+		{name: "headings inside blockquotes and lists do not count", files: map[string]string{aPath: adrBase + "\n> ## Consequences\n\n* ## Decision Outcome\n"}},
+		{name: "H4 does not end the Decision Outcome prose", files: map[string]string{aPath: sub(adrBase, "Chosen option: Queue.", "#### Detail\n\nChosen.")}},
+		{name: "plan second H1", files: map[string]string{pPath: planBase + "\n# Again\n"}, want: []string{pPath + ":22: more than one H1"}},
+		{name: "plan repeated section", files: map[string]string{pPath: planBase + "\n## Scope\n\nMore.\n"}, want: []string{pPath + ":22: appears more than once"}},
+		{name: "plan section without prose", files: map[string]string{pPath: sub(planBase, "1. Do it.", "<!-- later -->")}, want: []string{pPath + ":14: has no prose"}},
+		{name: "plan Outcome is optional", files: map[string]string{pPath: planBase + "\n## Outcome\n\nDone.\n"}},
+
+		// 6.3 Placeholders
+		{name: "marker in body", files: map[string]string{aPath: sub(adrBase, "Jobs block requests.", "{{docs:todo}}")}, want: []string{aPath + ":20: unfinished placeholder"}},
+		{name: "marker in comment", files: map[string]string{aPath: adrBase + "\n<!-- {{docs:todo}} -->\n"}, want: []string{aPath + ":35: unfinished placeholder"}},
+		{name: "marker in code", files: map[string]string{aPath: adrBase + "\nUse `{{docs:todo}}` as the marker.\n\n```\n{{docs:todo}}\n```\n"}},
+		{name: "TODO and TBD are fine", files: map[string]string{aPath: adrBase + "\nTODO and TBD.\n"}},
+		{name: "marker in frontmatter string", files: map[string]string{aPath: sub(adrBase, "summary: Run jobs on a queue.", `summary: "{{docs:todo}}"`)}, want: []string{aPath + ":6: unfinished placeholder"}},
+		{name: "marker as tag reports only the marker", files: map[string]string{aPath: sub(adrBase, "  - jobs", `  - "{{docs:todo}}"`)}, want: []string{aPath + ":8: unfinished placeholder"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			res, err := Check(tree(t, withSupport(tt.files), tt.links))
+			must(t, err)
+			expect(t, res.Problems, tt.want)
+		})
+	}
+}
+
+func TestCheckSymlinkedDocsDir(t *testing.T) {
+	res, err := Check(tree(t, nil, map[string]string{"docs/plans": "@outside"}))
+	must(t, err)
+	expect(t, res.Problems, []string{"docs/plans:1: real directory"})
+}
+
+func TestCheckSymlinkedDocsParent(t *testing.T) {
+	root := tree(t, nil, map[string]string{"docs": "@outside"})
+	out, err := os.Readlink(filepath.Join(root, "docs"))
+	must(t, err)
+	must(t, os.MkdirAll(filepath.Join(out, "adr"), 0o755))
+	res, err := Check(root)
+	must(t, err)
+	expect(t, res.Problems, []string{"docs/adr:1: inside the repository"})
+}
+
+func TestCheckEmptyRoot(t *testing.T) {
+	res, err := Check(t.TempDir())
+	must(t, err)
+	if res.Records != 0 || len(res.Problems) != 0 {
+		t.Fatalf("got %+v", res)
+	}
+}

internal/docs/frontmatter.go

@@ -0,0 +1,229 @@
+package docs
+
+import (
+	"errors"
+	"io"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"go.yaml.in/yaml/v3"
+)
+
+const marker = "{{docs:todo}}"
+
+var yamlLineRe = regexp.MustCompile(`line (\d+)`)
+
+type field struct{ key, val *yaml.Node }
+
+type item struct {
+	v    string
+	line int
+}
+
+// fm reads the typed fields of one record's frontmatter mapping.
+type fm struct {
+	c *checker
+	r *record
+	f map[string]field
+}
+
+// splitFrontmatter returns the frontmatter text, the body and the file line the body starts on.
+func splitFrontmatter(src string) (front, body string, bodyLine int, msg string) {
+	lines := strings.Split(src, "\n")
+	if lines[0] != "---" {
+		return "", "", 0, "file must start with a --- frontmatter line"
+	}
+	for i := 1; i < len(lines); i++ {
+		if lines[i] == "---" {
+			return strings.Join(lines[1:i], "\n"), strings.Join(lines[i+1:], "\n"), i + 2, ""
+		}
+	}
+	return "", "", 0, "frontmatter is not closed by a --- line"
+}
+
+// parseFrontmatter decodes the mapping and rejects anything but plain keys and values.
+func (c *checker) parseFrontmatter(r *record, front string) (*fm, bool) {
+	report := func(line int, format string, args ...any) { c.add(r.path, line, format, args...) }
+	dec := yaml.NewDecoder(strings.NewReader(front))
+	var doc, extra yaml.Node
+	if err := dec.Decode(&doc); err != nil || len(doc.Content) == 0 {
+		if err == nil || errors.Is(err, io.EOF) {
+			report(2, "frontmatter is empty")
+		} else {
+			line := 2
+			if m := yamlLineRe.FindStringSubmatch(err.Error()); m != nil {
+				n, _ := strconv.Atoi(m[1])
+				line += n - 1
+			}
+			report(line, "invalid YAML: %v", strings.TrimPrefix(err.Error(), "yaml: "))
+		}
+		return nil, false
+	}
+	if err := dec.Decode(&extra); !errors.Is(err, io.EOF) {
+		report(2, "frontmatter must be a single YAML document")
+		return nil, false
+	}
+	root := doc.Content[0]
+	if root.Kind != yaml.MappingNode {
+		report(root.Line+1, "frontmatter must be a mapping")
+		return nil, false
+	}
+	ok := true
+	var walk func(n *yaml.Node)
+	walk = func(n *yaml.Node) {
+		switch {
+		case n.Kind == yaml.AliasNode:
+			report(n.Line+1, "YAML aliases are not allowed")
+			ok = false
+		case n.Anchor != "":
+			report(n.Line+1, "YAML anchors are not allowed")
+			ok = false
+		case n.Style&yaml.TaggedStyle != 0:
+			report(n.Line+1, "explicit YAML tags are not allowed")
+			ok = false
+		}
+		for _, ch := range n.Content {
+			walk(ch)
+		}
+	}
+	walk(root)
+	m := &fm{c: c, r: r, f: map[string]field{}}
+	for i := 0; i+1 < len(root.Content); i += 2 {
+		k, v := root.Content[i], root.Content[i+1]
+		if k.Kind != yaml.ScalarNode {
+			report(k.Line+1, "keys must be plain strings")
+			ok = false
+		} else if _, dup := m.f[k.Value]; dup {
+			report(k.Line+1, "duplicate key %q", k.Value)
+			ok = false
+		} else {
+			m.f[k.Value] = field{k, v}
+		}
+		markers(v, report)
+	}
+	return m, ok
+}
+
+// markers reports an unfinished placeholder in any string value or list item.
+func markers(n *yaml.Node, report func(int, string, ...any)) {
+	if n.Kind == yaml.ScalarNode && strings.Contains(n.Value, marker) {
+		report(n.Line+1, "unfinished placeholder %s", marker)
+	}
+	for _, ch := range n.Content {
+		markers(ch, report)
+	}
+}
+
+// keys reports missing and unknown keys.
+func (m *fm) keys(want ...string) {
+	for _, k := range want {
+		if _, ok := m.f[k]; !ok {
+			m.c.add(m.r.path, 1, "missing key %q", k)
+		}
+	}
+	for k, f := range m.f {
+		if !slices.Contains(want, k) {
+			m.c.add(m.r.path, f.key.Line+1, "unknown key %q", k)
+		}
+	}
+}
+
+func (m *fm) line(key string) int {
+	if f, ok := m.f[key]; ok {
+		return f.key.Line + 1
+	}
+	return 1
+}
+
+func (m *fm) isNull(key string, n *yaml.Node) bool {
+	if n.Kind == yaml.ScalarNode && n.Tag == "!!null" {
+		m.c.add(m.r.path, n.Line+1, "%s must not be null", key)
+		return true
+	}
+	return false
+}
+
+// scalar returns the literal text of a non-null scalar value.
+func (m *fm) scalar(key string) (string, int, bool) {
+	f, ok := m.f[key]
+	if !ok || m.isNull(key, f.val) {
+		return "", 0, false
+	}
+	if f.val.Kind != yaml.ScalarNode {
+		m.c.add(m.r.path, f.key.Line+1, "%s must be a string", key)
+		return "", 0, false
+	}
+	return f.val.Value, f.val.Line + 1, true
+}
+
+// text is a non-empty single-line string.
+func (m *fm) text(key string) (string, bool) {
+	v, line, ok := m.scalar(key)
+	if ok && (strings.TrimSpace(v) == "" || strings.ContainsAny(v, "\r\n")) {
+		m.c.add(m.r.path, line, "%s must be a non-empty single line", key)
+		return v, false
+	}
+	return v, ok
+}
+
+func (m *fm) enum(key string, allowed ...string) (string, bool) {
+	v, line, ok := m.scalar(key)
+	if ok && !slices.Contains(allowed, v) {
+		m.c.add(m.r.path, line, "%s must be one of %s", key, strings.Join(allowed, ", "))
+		return v, false
+	}
+	return v, ok
+}
+
+// list returns the items of a sequence of non-null scalars.
+func (m *fm) list(key string) ([]item, bool) {
+	f, ok := m.f[key]
+	if !ok || m.isNull(key, f.val) {
+		return nil, false
+	}
+	if f.val.Kind != yaml.SequenceNode {
+		m.c.add(m.r.path, f.key.Line+1, "%s must be a list", key)
+		return nil, false
+	}
+	var items []item
+	for _, n := range f.val.Content {
+		if m.isNull(key, n) {
+			continue
+		}
+		if n.Kind != yaml.ScalarNode {
+			m.c.add(m.r.path, n.Line+1, "%s items must be strings", key)
+			continue
+		}
+		items = append(items, item{n.Value, n.Line + 1})
+	}
+	m.r.lists[key] = items
+	return items, true
+}
+
+// tags checks the ADR tags list.
+func (m *fm) tags() {
+	items, ok := m.list("tags")
+	if !ok {
+		return
+	}
+	if len(items) == 0 {
+		m.c.add(m.r.path, m.line("tags"), "tags must not be empty")
+	}
+	seen := map[string]bool{}
+	for _, it := range items {
+		switch {
+		case it.v == marker:
+		case !slugRe.MatchString(it.v):
+			m.c.add(m.r.path, it.line, "tag %q must be lowercase a-z0-9 words joined by single hyphens", it.v)
+		case seen[it.v]:
+			m.c.add(m.r.path, it.line, "duplicate tag %q", it.v)
+		}
+		seen[it.v] = true
+	}
+}
+
+func (m *fm) problemf(key, format string, args ...any) {
+	m.c.add(m.r.path, m.line(key), format, args...)
+}

internal/docs/graph.go

@@ -0,0 +1,71 @@
+package docs
+
+import (
+	"slices"
+	"strings"
+)
+
+// graph checks cross-record rules: unique IDs and supersession.
+func (c *checker) graph(recs []*record) {
+	byStem := map[string][]*record{}
+	byPath := map[string]*record{}
+	for _, r := range recs {
+		byStem[r.stem] = append(byStem[r.stem], r)
+		byPath["/"+r.path] = r
+	}
+	for _, group := range byStem {
+		for _, r := range group {
+			for _, o := range group {
+				if o != r {
+					c.add(r.path, 1, "duplicate ID %s, also used by %s", r.stem, o.path)
+				}
+			}
+		}
+	}
+	adrs := recs[:0:0]
+	for _, r := range recs {
+		if r.kind == "adr" && r.fm != nil {
+			adrs = append(adrs, r)
+		}
+	}
+	for _, r := range adrs {
+		if len(r.lists["supersedes"]) > 0 && !slices.Contains([]string{"accepted", "superseded", "deprecated"}, r.status) {
+			c.add(r.path, r.fm.line("supersedes"), "a record that supersedes another must be accepted, superseded or deprecated, not %s", r.status)
+		}
+		for _, e := range [][2]string{{"supersedes", "superseded_by"}, {"superseded_by", "supersedes"}} {
+			for _, it := range r.lists[e[0]] {
+				if o := byPath[it.v]; o != nil && o.kind == "adr" && !slices.ContainsFunc(o.lists[e[1]], func(x item) bool { return x.v == "/"+r.path }) {
+					c.add(r.path, it.line, "%s lists %s, which must list this record in %s", e[0], it.v, e[1])
+				}
+			}
+		}
+	}
+	// Cycles over supersedes edges: report once, on the first record (in path order) that closes one.
+	const (
+		visiting = 1
+		done     = 2
+	)
+	state := map[*record]int{}
+	var visit func(r *record)
+	visit = func(r *record) {
+		state[r] = visiting
+		for _, it := range r.lists["supersedes"] {
+			o := byPath[it.v]
+			if o == nil || o.kind != "adr" {
+				continue
+			}
+			switch state[o] {
+			case visiting:
+				c.add(r.path, it.line, "supersession cycle through %s", strings.TrimPrefix(it.v, "/"))
+			case 0:
+				visit(o)
+			}
+		}
+		state[r] = done
+	}
+	for _, r := range adrs {
+		if state[r] == 0 {
+			visit(r)
+		}
+	}
+}

internal/docs/id.go

@@ -0,0 +1,131 @@
+package docs
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+)
+
+const (
+	timestampLayout = "20060102T150405.000Z"
+	maxSlug         = 80
+)
+
+var (
+	nameRe = regexp.MustCompile(`^(\d{8}T\d{9}Z)-(.+)\.md$`)
+	slugRe = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
+)
+
+// parseName validates a record filename and returns its stem, UTC timestamp
+// and a problem message (empty when valid).
+func parseName(name string) (stem string, at time.Time, msg string) {
+	m := nameRe.FindStringSubmatch(name)
+	if m == nil {
+		return "", at, "name must be YYYYMMDDTHHMMSSmmmZ-slug.md"
+	}
+	at, err := time.Parse(timestampLayout, m[1][:15]+"."+m[1][15:])
+	if err != nil {
+		return "", at, "name has an invalid UTC timestamp"
+	}
+	switch {
+	case !slugRe.MatchString(m[2]):
+		return "", at, "slug must be lowercase a-z0-9 words joined by single hyphens"
+	case len(m[2]) > maxSlug:
+		return "", at, fmt.Sprintf("slug is longer than %d characters", maxSlug)
+	}
+	return strings.TrimSuffix(name, ".md"), at, ""
+}
+
+// slugify lowercases title and joins its ASCII letter and digit runs with hyphens.
+func slugify(title string) string {
+	var b strings.Builder
+	for _, r := range strings.ToLower(title) {
+		if r >= 'a' && r <= 'z' || r >= '0' && r <= '9' {
+			b.WriteRune(r)
+		} else if b.Len() > 0 && !strings.HasSuffix(b.String(), "-") {
+			b.WriteByte('-')
+		}
+	}
+	s := b.String()
+	return strings.Trim(s[:min(len(s), maxSlug)], "-")
+}
+
+var closingRe = regexp.MustCompile(`(^|[ \t])#+$`)
+
+// New creates a record of the given kind ("adr" or "plan") under root and
+// returns its root-relative slash path. The file is created exclusively; the
+// timestamp advances by 1 ms on a collision.
+func New(root, kind, title string, now time.Time) (string, error) {
+	title = strings.TrimSpace(title)
+	if title == "" || strings.ContainsAny(title, "\r\n") {
+		return "", errors.New("title must be non-empty and a single line")
+	}
+	if closingRe.MatchString(title) {
+		return "", errors.New(`title must not end in a "#" run: it would be read as a closing sequence of the H1`)
+	}
+	slug := slugify(title)
+	if slug == "" {
+		return "", errors.New("title needs at least one ASCII letter or digit for the file name")
+	}
+	var dir string
+	for _, d := range dirs {
+		if d.kind == kind {
+			dir = d.dir
+		}
+	}
+	tmpl, err := templates.ReadFile("templates/" + kind + ".md")
+	if err != nil {
+		return "", fmt.Errorf("unknown record type %q", kind)
+	}
+	quoted, err := json.Marshal(title) // JSON strings are valid YAML double-quoted scalars
+	if err != nil {
+		return "", err
+	}
+	used, err := stems(root)
+	if err != nil {
+		return "", err
+	}
+	if err := os.MkdirAll(filepath.Join(root, dir), 0o755); err != nil {
+		return "", err
+	}
+	at := now.UTC().Truncate(time.Millisecond)
+	for ; ; at = at.Add(time.Millisecond) {
+		stem := strings.Replace(at.Format(timestampLayout), ".", "", 1) + "-" + slug
+		if used[stem] {
+			continue
+		}
+		rel := dir + "/" + stem + ".md"
+		f, err := os.OpenFile(filepath.Join(root, filepath.FromSlash(rel)), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
+		if errors.Is(err, os.ErrExist) {
+			continue
+		}
+		if err != nil {
+			return "", err
+		}
+		content := strings.NewReplacer("@TITLE_YAML@", string(quoted), "@TITLE@", title, "@DATE@", at.Format(time.DateOnly)).Replace(string(tmpl))
+		_, werr := f.WriteString(content)
+		return rel, errors.Join(werr, f.Close())
+	}
+}
+
+// stems returns the IDs of every record-named file in both directories.
+func stems(root string) (map[string]bool, error) {
+	used := map[string]bool{}
+	for _, d := range dirs {
+		entries, err := os.ReadDir(filepath.Join(root, d.dir))
+		if err != nil && !errors.Is(err, os.ErrNotExist) {
+			return nil, err
+		}
+		for _, e := range entries {
+			if stem, _, msg := parseName(e.Name()); msg == "" {
+				used[stem] = true
+			}
+		}
+	}
+	return used, nil
+}

internal/docs/links_test.go

@@ -0,0 +1,130 @@
+package docs
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TestLinkDestinations covers the section 7 rules through one body link.
+func TestLinkDestinations(t *testing.T) {
+	tests := []struct{ dest, want string }{ // want "" means valid
+		{"/docs/spec.txt", ""},
+		{"/docs/spec.txt#frag", ""},
+		{"/docs/sp%20ace.md", ""},
+		{"#anchor", ""},
+		{"mailto:a@example.com", ""},
+		{"https://example.com/a?b=1#c", ""},
+		{`/docs/spec\.txt`, ""},
+		{"/docs/spec.txt", ""},
+		{"/docs/spec.txt", ""},
+		{`/docs\\spec.txt`, "backslash"},
+		{"/docs/SPEC.txt", "does not exist"},
+		{"/Docs/spec.txt", "does not exist"},
+		{"foo.md", "relative"},
+		{"./foo.md", "relative"},
+		{"../docs/spec.txt", "relative"},
+		{"/docs/../docs/spec.txt", `".."`},
+		{"/docs/%2e%2e/docs/spec.txt", `".."`},
+		{`/docs\spec.txt`, "backslash"},
+		{`C:\spec.txt`, "backslash"},
+		{"//example.com/x", "protocol-relative"},
+		{"/docs/spec.txt?x=1", "queries"},
+		{"/docs/%zz", "percent-encoding"},
+		{"/docs/missing.txt", "does not exist"},
+		{"/Users/me/spec.txt", "does not exist"},
+		{"/docs", "not a regular file"},
+		{"/docs/out/f.md", "outside the repository"},
+		{"file:///etc/passwd", "scheme"},
+		{"ftp://example.com/x", "scheme"},
+		{"javascript:alert(1)", "scheme"},
+		{"https://u:p@example.com/x", "credentials"},
+		{"https:///nohost", "host"},
+		{"<>", "empty"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.dest, func(t *testing.T) {
+			dest := tt.dest
+			if strings.ContainsAny(dest, " ") {
+				dest = "<" + dest + ">"
+			}
+			doc := adrBase + "\nSee [x](" + dest + ").\n"
+			res, err := Check(tree(t, withSupport(map[string]string{aPath: doc}), map[string]string{"docs/out": "@outside"}))
+			must(t, err)
+			var want []string
+			if tt.want != "" {
+				want = []string{aPath + ":35: " + tt.want}
+			}
+			expect(t, res.Problems, want)
+		})
+	}
+}
+
+// TestLinkForms covers which Markdown constructs are link destinations.
+func TestLinkForms(t *testing.T) {
+	tests := []struct {
+		name, body string
+		want       []string
+	}{
+		{"image", "![x](foo.md)", []string{":35: relative"}},
+		{"autolink", "<ftp://example.com/x>", []string{":35: scheme"}},
+		{"reference link and definition", "[x][r]\n\n[r]: foo.md", []string{":35: relative", ":37: relative"}},
+		{"duplicate definition is checked", "[a]: /docs/spec.txt\n\n[a]: ../bad.md", []string{":37: relative"}},
+		{"definition in a blockquote", "> [Zed]: ../bad.md", []string{":35: relative"}},
+		{"definition-like line in code", "```\n[a]: x\n```\n\n[a]: ../bad.md", []string{":39: relative"}},
+		{"definition-like paragraph continuation", "Some text\n[a]: ../x.md\n\n[a]: ../bad.md", []string{":36: relative", ":38: relative"}}, // [a] in the text is a reference link
+		{"definition-like line in an HTML comment", "<!--\n[a]: x\n-->\n\n[a]: ../bad.md", []string{":39: relative"}},
+		{"autolink on a later line", "Para one\nline two\n<ftp://example.com/x>", []string{":37: scheme"}},
+		{"image without alt on a later line", "Para one\nline two\n![](foo.md)", []string{":37: relative"}},
+		{"unused definition", "[r]: foo.md", []string{":35: relative"}},
+		{"link in a list", "* [x](foo.md)", []string{":35: relative"}},
+		{"bare URL and raw HTML are not checked", "http://u:p@example.com and @user #123 abc1234\n\n<a href=\"foo.md\">x</a>", nil},
+		{"link in code is not a link", "`[x](foo.md)`\n\n```\n[x](foo.md)\n```", nil},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			res, err := Check(tree(t, withSupport(map[string]string{aPath: adrBase + "\n" + tt.body + "\n"}), nil))
+			must(t, err)
+			var want []string
+			for _, w := range tt.want {
+				want = append(want, aPath+w)
+			}
+			expect(t, res.Problems, want)
+		})
+	}
+}
+
+// TestSpecExamples keeps the minimal examples in docs/docs-format.md valid.
+func TestSpecExamples(t *testing.T) {
+	spec, err := os.ReadFile("../../docs/docs-format.md")
+	must(t, err)
+	root := t.TempDir()
+	parts := strings.Split(string(spec[strings.Index(string(spec), "## 9."):]), "```markdown\n")
+	if len(parts) != 3 {
+		t.Fatalf("expected two examples, got %d", len(parts)-1)
+	}
+	// The path of each example is the backticked name on the line before its fence.
+	heads := strings.Split(string(spec[strings.Index(string(spec), "## 9."):]), "\n")
+	var paths []string
+	for _, l := range heads {
+		if strings.HasPrefix(l, "`docs/") {
+			paths = append(paths, strings.Trim(l, "`:"))
+		}
+	}
+	if len(paths) != 2 {
+		t.Fatalf("expected two example paths, got %v", paths)
+	}
+	for i, part := range parts[1:] {
+		body, _, _ := strings.Cut(part, "```")
+		full := filepath.Join(root, paths[i])
+		must(t, os.MkdirAll(filepath.Dir(full), 0o755))
+		must(t, os.WriteFile(full, []byte(body), 0o644))
+	}
+	res, err := Check(root)
+	must(t, err)
+	expect(t, res.Problems, nil)
+	if res.Records != 2 {
+		t.Fatalf("records = %d", res.Records)
+	}
+}

internal/docs/new_test.go

@@ -0,0 +1,104 @@
+package docs
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+var now = time.Date(2026, 10, 23, 20, 45, 12, 345_000_000, time.UTC)
+
+// TestNewTemplates checks that fresh records fail only on their markers and
+// become valid once those are replaced.
+func TestNewTemplates(t *testing.T) {
+	for _, tt := range []struct {
+		kind, path string
+		markers    int
+	}{
+		{"adr", "docs/adr/20261023T204512345Z-use-x-y.md", 6},
+		{"plan", "docs/plans/20261023T204512345Z-use-x-y.md", 3},
+	} {
+		t.Run(tt.kind, func(t *testing.T) {
+			root := t.TempDir()
+			path, err := New(root, tt.kind, `Use "X" & Y`, now)
+			must(t, err)
+			if path != tt.path {
+				t.Fatalf("path = %s", path)
+			}
+			res, err := Check(root)
+			must(t, err)
+			if len(res.Problems) != tt.markers {
+				t.Fatalf("got %v, want %d marker problems", res.Problems, tt.markers)
+			}
+			for _, p := range res.Problems {
+				if !strings.Contains(p.Msg, marker) {
+					t.Errorf("not a marker problem: %s", p)
+				}
+			}
+			data, err := os.ReadFile(filepath.Join(root, path))
+			must(t, err)
+			must(t, os.WriteFile(filepath.Join(root, path), []byte(strings.ReplaceAll(string(data), marker, "x")), 0o644))
+			res, err = Check(root)
+			must(t, err)
+			expect(t, res.Problems, nil)
+		})
+	}
+}
+
+func TestNewCollisions(t *testing.T) {
+	root := t.TempDir()
+	first, err := New(root, "adr", "Same", now)
+	must(t, err)
+	second, err := New(root, "adr", "Same", now)
+	must(t, err)
+	// The same stem in the other directory also advances the timestamp.
+	third, err := New(root, "plan", "Same", now)
+	must(t, err)
+	want := []string{
+		"docs/adr/20261023T204512345Z-same.md",
+		"docs/adr/20261023T204512346Z-same.md",
+		"docs/plans/20261023T204512347Z-same.md",
+	}
+	for i, got := range []string{first, second, third} {
+		if got != want[i] {
+			t.Errorf("file %d = %s, want %s", i, got, want[i])
+		}
+	}
+	// Advancing across midnight keeps the date equal to the filename.
+	root = t.TempDir()
+	_, err = New(root, "adr", "Edge", time.Date(2026, 10, 23, 23, 59, 59, 999_000_000, time.UTC))
+	must(t, err)
+	got, err := New(root, "adr", "Edge", time.Date(2026, 10, 23, 23, 59, 59, 999_000_000, time.UTC))
+	must(t, err)
+	if got != "docs/adr/20261024T000000000Z-edge.md" {
+		t.Fatalf("got %s", got)
+	}
+	res, err := Check(root)
+	must(t, err)
+	for _, p := range res.Problems {
+		if !strings.Contains(p.Msg, marker) {
+			t.Errorf("unexpected %s", p)
+		}
+	}
+}
+
+func TestNewRejectsBadTitles(t *testing.T) {
+	for _, title := range []string{"", "  ", "a\nb", "!!!", "Drop C #", "#", "C ##"} {
+		if path, err := New(t.TempDir(), "adr", title, now); err == nil {
+			t.Errorf("title %q created %s", title, path)
+		}
+	}
+}
+
+func TestSlugify(t *testing.T) {
+	for in, want := range map[string]string{"Use X, Y & Z!": "use-x-y-z", "  --Hello--  ": "hello", "Ünï": "n"} {
+		if got := slugify(in); got != want {
+			t.Errorf("slugify(%q) = %q, want %q", in, got, want)
+		}
+	}
+	if got := slugify(strings.Repeat("ab ", 40)); len(got) != maxSlug || strings.HasSuffix(got, "-") {
+		t.Errorf("long slug = %q", got)
+	}
+}

internal/docs/plan.go

@@ -0,0 +1,23 @@
+package docs
+
+var planRefs = []refSpec{{"tracking", kURL}, {"adrs", kAdr}, {"completion", kURL | kFile}}
+
+func (c *checker) plan(r *record, m *fm) {
+	m.keys("status", "tracking", "adrs", "completion")
+	status, ok := m.enum("status", "draft", "active", "completed", "cancelled")
+	m.refs(planRefs...)
+	r.status = status
+	if !ok {
+		return
+	}
+	closed := status == "completed" || status == "cancelled"
+	if status == "active" && len(r.lists["tracking"]) == 0 {
+		m.problemf("status", "status active requires tracking")
+	}
+	if closed && len(r.lists["completion"]) == 0 {
+		m.problemf("status", "status %s requires completion", status)
+	}
+	if !closed && len(r.lists["completion"]) > 0 {
+		m.problemf("completion", "completion must be empty while status is %s", status)
+	}
+}

internal/docs/refs.go

@@ -0,0 +1,194 @@
+package docs
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strings"
+)
+
+// kinds is the set of reference forms a frontmatter key accepts.
+type kinds uint8
+
+const (
+	kAdr kinds = 1 << iota
+	kPlan
+	kURL
+	kFile
+)
+
+type refSpec struct {
+	key   string
+	kinds kinds
+}
+
+var (
+	schemeRe   = regexp.MustCompile(`^([A-Za-z][A-Za-z0-9+.-]*):`)
+	durableRe  = regexp.MustCompile(`^([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+)?#\d+$`)
+	idPattern  = `\d{8}T\d{9}Z-[a-z0-9]+(?:-[a-z0-9]+)*`
+	adrPathRe  = regexp.MustCompile(`^/docs/adr/` + idPattern + `\.md$`)
+	planPathRe = regexp.MustCompile(`^/docs/plans/` + idPattern + `\.md$`)
+)
+
+type ref struct {
+	path   string // decoded repo-root path; empty for URLs and anchors
+	remote bool
+}
+
+// parseRef checks the syntax of a reference. body allows #anchors, mailto: and #fragments.
+func parseRef(v string, body bool) (ref, string) {
+	if v == "" {
+		return ref{}, "empty reference"
+	}
+	if strings.Contains(v, `\`) {
+		return ref{}, "backslashes are not allowed"
+	}
+	if body && v[0] == '#' {
+		return ref{}, ""
+	}
+	if m := schemeRe.FindStringSubmatch(v); m != nil {
+		switch strings.ToLower(m[1]) {
+		case "http", "https":
+			u, err := url.Parse(v)
+			switch {
+			case err != nil || u.Hostname() == "":
+				return ref{}, "URL must have a host"
+			case u.User != nil:
+				return ref{}, "URL must not contain credentials"
+			}
+			return ref{remote: true}, ""
+		case "mailto":
+			if body {
+				return ref{}, ""
+			}
+		}
+		return ref{}, fmt.Sprintf("scheme %q is not allowed", m[1])
+	}
+	if v[0] != '/' {
+		return ref{}, "relative paths are not allowed; use a repo-root path starting with /"
+	}
+	if strings.HasPrefix(v, "//") {
+		return ref{}, "protocol-relative references are not allowed"
+	}
+	p, frag, hasFrag := strings.Cut(v, "#")
+	if hasFrag && !body {
+		return ref{}, "fragments are not allowed here (" + frag + ")"
+	}
+	if strings.Contains(p, "?") {
+		return ref{}, "queries are not allowed"
+	}
+	dec, err := url.PathUnescape(p)
+	if err != nil {
+		return ref{}, "invalid percent-encoding"
+	}
+	if slices.Contains(strings.Split(dec, "/"), "..") || strings.Contains(dec, `\`) {
+		return ref{}, `".." segments and backslashes are not allowed`
+	}
+	return ref{path: dec}, ""
+}
+
+// exists reports why a repo-root path is not a regular file inside the repository.
+func (c *checker) exists(p string) string {
+	// Match each component's case exactly, so case-insensitive filesystems agree with Linux.
+	dir := c.root
+	for _, part := range strings.Split(p, "/") {
+		if part == "" || part == "." {
+			continue
+		}
+		entries, err := os.ReadDir(dir)
+		if err != nil || !slices.ContainsFunc(entries, func(e os.DirEntry) bool { return e.Name() == part }) {
+			return "target " + p + " does not exist"
+		}
+		dir = filepath.Join(dir, part)
+	}
+	real, err := filepath.EvalSymlinks(filepath.Join(c.root, filepath.FromSlash(p)))
+	if err != nil {
+		return "target " + p + " does not exist"
+	}
+	if !within(c.realRoot, real) {
+		return "target " + p + " resolves outside the repository"
+	}
+	if st, err := os.Stat(real); err != nil || !st.Mode().IsRegular() {
+		return "target " + p + " is not a regular file"
+	}
+	return ""
+}
+
+// checkLink validates a body link destination.
+func (c *checker) checkLink(r *record, line int, dest string) {
+	ref, msg := parseRef(dest, true)
+	if msg == "" && ref.path != "" {
+		msg = c.exists(ref.path)
+	}
+	if msg != "" {
+		c.add(r.path, line, "link %q: %s", dest, msg)
+	}
+}
+
+// refs validates the reference lists of a record against their specs.
+func (m *fm) refs(specs ...refSpec) {
+	self := "/" + m.r.path
+	for _, spec := range specs {
+		items, ok := m.list(spec.key)
+		if !ok {
+			continue
+		}
+		seen := map[string]bool{}
+		for _, it := range items {
+			if it.v == marker {
+				continue
+			}
+			if msg := m.checkRef(spec, it.v, self); msg != "" {
+				m.c.add(m.r.path, it.line, "%s: %s", spec.key, msg)
+			} else if seen[it.v] {
+				m.c.add(m.r.path, it.line, "%s: duplicate reference %q", spec.key, it.v)
+			}
+			seen[it.v] = true
+		}
+	}
+}
+
+func (m *fm) checkRef(spec refSpec, v, self string) string {
+	if durableRe.MatchString(v) || slices.Contains([]string{"this pr", "this pull request", "this commit"}, strings.ToLower(v)) {
+		return fmt.Sprintf("%q is not durable; use a full URL", v)
+	}
+	r, msg := parseRef(v, false)
+	if msg != "" {
+		return msg
+	}
+	k := spec.kinds
+	switch {
+	case r.remote:
+		if k&kURL == 0 {
+			return "URLs are not accepted here; accepts " + k.String()
+		}
+		return ""
+	case k&kFile == 0 && !(k&kAdr != 0 && adrPathRe.MatchString(v)) && !(k&kPlan != 0 && planPathRe.MatchString(v)):
+		return fmt.Sprintf("%q is not accepted here; accepts %s", v, k)
+	case r.path == self:
+		return "a record must not reference itself"
+	}
+	return m.c.exists(r.path)
+}
+
+func (k kinds) String() string {
+	var s []string
+	for _, e := range []struct {
+		k kinds
+		s string
+	}{{kAdr, "/docs/adr/<id>.md"}, {kPlan, "/docs/plans/<id>.md"}, {kURL, "http(s) URLs"}, {kFile, "repo-root file paths"}} {
+		if k&e.k != 0 {
+			s = append(s, e.s)
+		}
+	}
+	return strings.Join(s, ", ")
+}
+
+// within reports whether the real path p is root or lies under it.
+func within(root, p string) bool {
+	rel, err := filepath.Rel(root, p)
+	return err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator))
+}

internal/docs/templates/adr.md

@@ -0,0 +1,32 @@
+---
+title: @TITLE_YAML@
+date: @DATE@
+status: proposed
+implementation: not-started
+summary: "{{docs:todo}}"
+tags:
+  - "{{docs:todo}}"
+supersedes: []
+superseded_by: []
+related: []
+tracking: []
+implemented_by: []
+---
+
+# @TITLE@
+
+## Context and Problem Statement
+
+{{docs:todo}}
+
+## Considered Options
+
+{{docs:todo}}
+
+## Decision Outcome
+
+{{docs:todo}}
+
+### Consequences
+
+{{docs:todo}}

internal/docs/templates/plan.md

@@ -0,0 +1,20 @@
+---
+status: draft
+tracking: []
+adrs: []
+completion: []
+---
+
+# @TITLE@
+
+## Scope
+
+{{docs:todo}}
+
+## Steps
+
+{{docs:todo}}
+
+## Validation
+
+{{docs:todo}}

lifecycle/example_test.go

@@ -0,0 +1,102 @@
+package lifecycle_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"syscall"
+	"testing"
+	"time"
+
+	"go.auvem.com/corestack/lifecycle"
+)
+
+func TestRealFlow(t *testing.T) {
+	for _, failure := range []bool{false, true} {
+		t.Run(fmt.Sprint(failure), func(t *testing.T) {
+			signals := make(chan os.Signal, 2)
+			app, err := lifecycle.New(lifecycle.Config{Logger: slog.New(slog.NewTextHandler(io.Discard, nil)), Signals: signals, ShutdownTimeout: time.Second})
+			if err != nil {
+				t.Fatal(err)
+			}
+			ready := make(chan struct{}, 3)
+			release := make(chan struct{})
+			t.Cleanup(func() {
+				select {
+				case <-release:
+				default:
+					close(release)
+				}
+			})
+			failed := errors.New("service failed")
+			for _, name := range []string{"daemon", "muxer"} {
+				err = app.Register(lifecycle.Module{Name: name, Setup: func(ctx context.Context) error {
+					if name == "daemon" {
+						return app.Go(ctx, "queue", func(ctx context.Context) error { ready <- struct{}{}; <-ctx.Done(); <-release; return ctx.Err() })
+					}
+					return nil
+				}, Run: func(ctx context.Context) error {
+					ready <- struct{}{}
+					if name == "muxer" && failure {
+						<-release
+						return failed
+					}
+					<-ctx.Done()
+					return ctx.Err()
+				}, Teardown: func(context.Context) error { return nil }})
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			done := make(chan error, 1)
+			go func() { done <- app.Run(context.Background()) }()
+			for range 3 {
+				select {
+				case <-ready:
+				case <-time.After(3 * time.Second):
+					t.Fatal("services did not start")
+				}
+			}
+			if !failure {
+				signals <- syscall.SIGTERM
+			}
+			close(release)
+			select {
+			case err = <-done:
+				if failure && !errors.Is(err, failed) || !failure && err != nil {
+					t.Fatalf("Run: %v", err)
+				}
+			case <-time.After(2 * time.Second):
+				t.Fatal("Run blocked")
+			}
+		})
+	}
+}
+
+func Example() {
+	signals := make(chan os.Signal, 2)
+	app, err := lifecycle.New(lifecycle.Config{Logger: slog.New(slog.NewTextHandler(io.Discard, nil)), Signals: signals})
+	if err != nil {
+		panic(err)
+	}
+	ready := make(chan struct{}, 2)
+	for _, name := range []string{"daemon", "muxer"} {
+		err := app.Register(lifecycle.Module{
+			Name: name,
+			Setup: func(ctx context.Context) error {
+				return app.Go(ctx, name+" worker", func(ctx context.Context) error { <-ctx.Done(); return ctx.Err() })
+			},
+			Run:      func(ctx context.Context) error { ready <- struct{}{}; <-ctx.Done(); return ctx.Err() },
+			Teardown: func(context.Context) error { return nil },
+		})
+		if err != nil {
+			panic(err)
+		}
+	}
+	go func() { <-ready; <-ready; signals <- syscall.SIGTERM }()
+	fmt.Println(app.Run(context.Background()))
+	// Output: <nil>
+}

lifecycle/lifecycle.go

@@ -0,0 +1,349 @@
+// Package lifecycle supervises ordered module setup, concurrent services and
+// explicitly admitted workers within one shutdown budget. It owns cancellation
+// and reverse teardown, not signal subscriptions, process exit or raw goroutines.
+// Callbacks and the injected logger must cooperate: abandonment bounds Run's
+// return, but cannot kill callbacks or reclaim their resources.
+package lifecycle
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"sync"
+	"time"
+)
+
+// Module describes one resource owner. Setup acquires resources; Teardown releases
+// them after successful setup. A failing Setup owns its partial cleanup. Optional
+// Run starts only after all setups succeed. Callbacks must honor cancellation.
+type Module struct {
+	// Name identifies the module in errors.
+	Name string
+	// Setup acquires resources before any service starts.
+	Setup func(context.Context) error
+	// Teardown releases resources after successful Setup.
+	Teardown func(context.Context) error
+	// Run optionally serves until completion or cancellation.
+	Run func(context.Context) error
+}
+
+// Config supplies application policy. Logger is required and must not block.
+// Zero ShutdownTimeout selects 30 seconds; negative values are invalid.
+// The caller owns Signals, its subscription and cleanup, filtering to SIGINT and
+// SIGTERM and buffering at least two signals. Nil or closed disables reception.
+type Config struct {
+	// Logger receives lifecycle diagnostics and must not block.
+	Logger *slog.Logger
+	// Signals is a caller-owned, filtered signal source.
+	Signals <-chan os.Signal
+	// ShutdownTimeout bounds all shutdown work together.
+	ShutdownTimeout time.Duration
+}
+
+// App is a single-use coordinator constructed by New. Do not copy it. Register
+// modules before Run; Go may be called concurrently during setup and running.
+// App stores no context. After abandonment, callers own process exit and must not
+// reuse resources whose callbacks have not returned.
+type App struct {
+	config        Config
+	mu            sync.Mutex
+	modules       []Module
+	used          bool
+	accepting     bool
+	stopping      bool
+	active        int
+	cancel        context.CancelCauseFunc
+	shutdownCause error
+	stoppedAt     time.Time
+	errs          []error
+	wake          chan struct{}
+}
+
+// New validates and captures config without subscribing to signals or starting work.
+func New(config Config) (*App, error) {
+	if config.Logger == nil {
+		return nil, errors.New("lifecycle: logger is required")
+	}
+	if config.ShutdownTimeout < 0 {
+		return nil, errors.New("lifecycle: negative shutdown timeout")
+	}
+	if config.ShutdownTimeout == 0 {
+		config.ShutdownTimeout = 30 * time.Second
+	}
+	return &App{config: config, wake: make(chan struct{}, 1)}, nil
+}
+
+// Register captures a uniquely named module with required setup and teardown.
+// Registration closes permanently when Run begins, including a failed run.
+func (a *App) Register(module Module) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.used {
+		return errors.New("lifecycle: registration is closed")
+	}
+	if module.Name == "" || module.Setup == nil || module.Teardown == nil {
+		return errors.New("lifecycle: module needs name, setup and teardown")
+	}
+	for _, m := range a.modules {
+		if m.Name == module.Name {
+			return fmt.Errorf("lifecycle: duplicate module %q", module.Name)
+		}
+	}
+	a.modules = append(a.modules, module)
+	return nil
+}
+
+// Go immediately launches and tracks fn, or returns an admission error without
+// launching it. ctx must be a callback's lifecycle context or a descendant;
+// ancestry is a caller precondition and cannot generally be checked. Detached
+// contexts forfeit graceful cancellation. Names are diagnostic and may repeat.
+// Callers must handle rejection; raw goroutines are outside App's guarantee.
+func (a *App) Go(ctx context.Context, name string, fn func(context.Context) error) error {
+	if ctx == nil || name == "" || fn == nil {
+		return errors.New("lifecycle: worker needs context, name and function")
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if !a.accepting {
+		return errors.New("lifecycle: worker admission is closed")
+	}
+	a.launchLocked(ctx, "worker", name, fn)
+	return nil
+}
+
+func (a *App) notifyLocked() {
+	select {
+	case a.wake <- struct{}{}:
+	default:
+	}
+}
+
+func (a *App) stopLocked() {
+	if !a.stopping {
+		// invariant: closure and admission share the lock, so every accepted worker is counted.
+		a.accepting = false
+		a.stopping = true
+		a.stoppedAt = time.Now()
+		a.cancel(a.shutdownCause)
+	}
+	a.notifyLocked()
+}
+
+// cancellationOnly recognizes expected cancellation without rebuilding error trees.
+func cancellationOnly(err, cancellation error) bool {
+	if err == nil {
+		return false
+	}
+	if err == cancellation {
+		return true
+	}
+	if many, ok := err.(interface{ Unwrap() []error }); ok {
+		children := many.Unwrap()
+		for _, child := range children {
+			if !cancellationOnly(child, cancellation) {
+				return false
+			}
+		}
+		return len(children) > 0
+	}
+	if one, ok := err.(interface{ Unwrap() error }); ok {
+		return cancellationOnly(one.Unwrap(), cancellation)
+	}
+	return false
+}
+
+func (a *App) recordLocked(ctx context.Context, phase, name string, err error) {
+	if a.stopping && context.Cause(ctx) == a.shutdownCause && cancellationOnly(err, ctx.Err()) {
+		err = nil
+	}
+	if err != nil {
+		a.errs = append(a.errs, fmt.Errorf("%s %q: %w", phase, name, err))
+		a.stopLocked()
+	}
+}
+
+func (a *App) launchLocked(ctx context.Context, phase, name string, fn func(context.Context) error) {
+	a.active++
+	go func() {
+		err := fn(ctx)
+		a.mu.Lock()
+		defer a.mu.Unlock()
+		a.recordLocked(ctx, phase, name, err)
+		a.active--
+		a.notifyLocked()
+	}()
+}
+
+// Run sets up modules in registration order, then runs services concurrently.
+// Every service and admitted worker must finish for normal completion. The first
+// failure, parent cancellation or signal cancels their shared context and closes
+// admission before reverse teardown. A fresh context retains parent values and
+// gives teardown and callback completion one deadline from the shutdown trigger.
+// In-flight setup is awaited within that budget before rollback; abandoned setup
+// is never torn down later. Deadline or second signal abandons outstanding work.
+// Observed failures are joined; expected callback cancellation during established
+// shutdown is omitted only for cancellation-only error trees. Mixed errors remain
+// intact to preserve wrapper types, identity and matching, so may still match
+// cancellation. Initiating failures and every teardown error remain.
+// Cancellation is omitted only when context.Cause proves App caused it; parent
+// propagation and independently canceled descendants are retained conservatively.
+// Run never recovers panics, closes Signals or exits the process.
+func (a *App) Run(parent context.Context) error {
+	if parent == nil {
+		return errors.New("lifecycle: nil run context")
+	}
+	a.mu.Lock()
+	if a.used {
+		a.mu.Unlock()
+		return errors.New("lifecycle: app already run")
+	}
+	ctx, cancel := context.WithCancelCause(parent)
+	a.cancel = cancel
+	a.shutdownCause = errors.New("lifecycle shutdown")
+	a.used = true
+	a.accepting = true
+	modules := a.modules
+	a.mu.Unlock()
+	defer cancel(nil)
+	signals := a.config.Signals
+	signalCount := 0
+	var shutdown context.Context
+	var shutdownCancel context.CancelFunc
+	var setupDone <-chan error
+	completed := 0
+	var teardownDone <-chan error
+	teardownIndex := -1
+	startup := true
+	parentDone := parent.Done()
+	receiveSignal := func(sig os.Signal) error {
+		signalCount++
+		if signalCount == 2 {
+			if shutdownCancel != nil {
+				shutdownCancel()
+			}
+			return fmt.Errorf("second signal %v: %w", sig, context.Canceled)
+		}
+		a.mu.Lock()
+		a.stopLocked()
+		a.mu.Unlock()
+		return nil
+	}
+
+	for {
+		// invariant: queued abandonment is observed before starting another hook.
+		select {
+		case sig, ok := <-signals:
+			if !ok {
+				signals = nil
+			} else if err := receiveSignal(sig); err != nil {
+				return a.result(parent, err)
+			}
+			continue
+		default:
+		}
+
+		a.mu.Lock()
+		if !a.stopping && parent.Err() != nil {
+			a.stopLocked()
+			parentDone = nil
+		}
+		if !a.stopping && startup && setupDone == nil {
+			if completed < len(modules) {
+				m := modules[completed]
+				// invariant: buffered hook results cannot strand a sender after abandonment.
+				result := make(chan error, 1)
+				setupDone = result
+				go func() {
+					err := m.Setup(ctx)
+					a.mu.Lock()
+					a.recordLocked(ctx, "setup", m.Name, err)
+					a.mu.Unlock()
+					result <- err
+				}()
+			} else {
+				startup = false
+				for _, m := range modules {
+					if m.Run != nil {
+						a.launchLocked(ctx, "run", m.Name, m.Run)
+					}
+				}
+			}
+		}
+		if !a.stopping && !startup && a.active == 0 {
+			a.stopLocked()
+		}
+		if a.stopping && shutdown == nil {
+			created, release := context.WithDeadline(context.WithoutCancel(parent), a.stoppedAt.Add(a.config.ShutdownTimeout))
+			shutdown, shutdownCancel = created, release
+			defer release()
+			teardownIndex = completed - 1
+			a.config.Logger.Debug("lifecycle shutdown started")
+		}
+		stopping := a.stopping
+		active := a.active
+		a.mu.Unlock()
+
+		if stopping {
+			if err := shutdown.Err(); err != nil {
+				return a.result(parent, err)
+			}
+			if setupDone == nil && teardownDone == nil {
+				if teardownIndex >= 0 {
+					m := modules[teardownIndex]
+					result := make(chan error, 1)
+					teardownDone = result
+					go func() { result <- m.Teardown(shutdown) }()
+				} else if active == 0 {
+					return a.result(parent, nil)
+				}
+			}
+		}
+		var deadline <-chan struct{}
+		if shutdown != nil {
+			deadline = shutdown.Done()
+		}
+		select {
+		case err := <-setupDone:
+			setupDone = nil
+			if err == nil {
+				completed++
+				if stopping {
+					teardownIndex = completed - 1
+				}
+			}
+		case err := <-teardownDone:
+			teardownDone = nil
+			if err != nil {
+				a.mu.Lock()
+				a.errs = append(a.errs, fmt.Errorf("teardown %q: %w", modules[teardownIndex].Name, err))
+				a.mu.Unlock()
+			}
+			teardownIndex--
+		case <-a.wake:
+		case <-parentDone:
+			a.mu.Lock()
+			a.stopLocked()
+			a.mu.Unlock()
+			parentDone = nil
+		case sig, ok := <-signals:
+			if !ok {
+				signals = nil
+				continue
+			}
+			if err := receiveSignal(sig); err != nil {
+				return a.result(parent, err)
+			}
+		case <-deadline:
+			return a.result(parent, context.DeadlineExceeded)
+		}
+	}
+}
+
+func (a *App) result(parent context.Context, extra error) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	// invariant: every completion and abandonment retains parent cancellation exactly once.
+	return errors.Join(append(a.errs, parent.Err(), extra)...)
+}

lifecycle/lifecycle_test.go

@@ -0,0 +1,676 @@
+package lifecycle
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"reflect"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func newApp(t *testing.T, signals <-chan os.Signal, timeout time.Duration) *App {
+	t.Helper()
+	a, err := New(Config{Logger: slog.New(slog.NewTextHandler(io.Discard, nil)), Signals: signals, ShutdownTimeout: timeout})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return a
+}
+func add(t *testing.T, a *App, m Module) {
+	t.Helper()
+	if m.Setup == nil {
+		m.Setup = func(context.Context) error { return nil }
+	}
+	if m.Teardown == nil {
+		m.Teardown = func(context.Context) error { return nil }
+	}
+	if err := a.Register(m); err != nil {
+		t.Fatal(err)
+	}
+}
+func run(a *App, ctx context.Context) <-chan error {
+	done := make(chan error, 1)
+	go func() { done <- a.Run(ctx) }()
+	return done
+}
+func receive(t *testing.T, done <-chan error) error {
+	t.Helper()
+	select {
+	case err := <-done:
+		return err
+	case <-time.After(3 * time.Second):
+		t.Fatal("Run blocked")
+		return nil
+	}
+}
+func wait(t *testing.T, ch <-chan struct{}) {
+	t.Helper()
+	select {
+	case <-ch:
+	case <-time.After(3 * time.Second):
+		t.Fatal("callback blocked")
+	}
+}
+
+func TestValidation(t *testing.T) {
+	if _, err := New(Config{}); err == nil {
+		t.Fatal("nil logger accepted")
+	}
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	if _, err := New(Config{Logger: logger, ShutdownTimeout: -1}); err == nil {
+		t.Fatal("negative timeout accepted")
+	}
+	a := newApp(t, nil, 0)
+	if a.config.ShutdownTimeout != 30*time.Second {
+		t.Fatal("wrong default")
+	}
+	if a.Register(Module{Name: "bad"}) == nil {
+		t.Fatal("invalid module accepted")
+	}
+	add(t, a, Module{Name: "one"})
+	if a.Register(a.modules[0]) == nil {
+		t.Fatal("duplicate accepted")
+	}
+	if a.Go(context.Background(), "early", func(context.Context) error { return nil }) == nil {
+		t.Fatal("early worker accepted")
+	}
+	if a.Run(nil) == nil {
+		t.Fatal("nil context accepted")
+	}
+	if err := a.Run(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	if a.Run(context.Background()) == nil || a.Register(Module{}) == nil {
+		t.Fatal("reuse accepted")
+	}
+	for _, tc := range []struct {
+		ctx  context.Context
+		name string
+		fn   func(context.Context) error
+	}{{nil, "x", func(context.Context) error { return nil }}, {context.Background(), "", func(context.Context) error { return nil }}, {context.Background(), "x", nil}} {
+		if a.Go(tc.ctx, tc.name, tc.fn) == nil {
+			t.Fatal("invalid worker accepted")
+		}
+	}
+}
+
+func TestOrderRollbackAndJoinedErrors(t *testing.T) {
+	for _, fail := range []bool{false, true} {
+		t.Run(map[bool]string{false: "normal", true: "rollback"}[fail], func(t *testing.T) {
+			a := newApp(t, nil, 0)
+			var order []string
+			setupErr := errors.New("setup failed")
+			first := errors.New("cleanup first")
+			second := errors.New("cleanup second")
+			for _, name := range []string{"one", "two", "three"} {
+				add(t, a, Module{Name: name, Setup: func(context.Context) error {
+					order = append(order, "setup "+name)
+					if fail && name == "three" {
+						return setupErr
+					}
+					return nil
+				}, Teardown: func(context.Context) error {
+					order = append(order, "stop "+name)
+					if name == "one" {
+						return first
+					}
+					if name == "two" {
+						return second
+					}
+					return nil
+				}})
+			}
+			err := a.Run(context.Background())
+			want := []string{"setup one", "setup two", "setup three"}
+			if !fail {
+				want = append(want, "stop three")
+			}
+			want = append(want, "stop two", "stop one")
+			if !reflect.DeepEqual(order, want) {
+				t.Fatalf("order %v", order)
+			}
+			if !errors.Is(err, first) || !errors.Is(err, second) || errors.Is(err, setupErr) != fail {
+				t.Fatalf("errors %v", err)
+			}
+		})
+	}
+}
+
+func TestAllWorkCompletion(t *testing.T) {
+	for _, kind := range []string{"service", "worker"} {
+		t.Run(kind, func(t *testing.T) {
+			a := newApp(t, nil, 0)
+			ready := make(chan struct{})
+			release := make(chan struct{})
+			var once sync.Once
+			defer once.Do(func() { close(release) })
+			fn := func(context.Context) error { close(ready); <-release; return nil }
+			m := Module{Name: "long"}
+			if kind == "service" {
+				m.Run = fn
+			} else {
+				m.Setup = func(ctx context.Context) error { return a.Go(ctx, "long", fn) }
+			}
+			add(t, a, m)
+			add(t, a, Module{Name: "short", Run: func(context.Context) error { return nil }})
+			done := run(a, context.Background())
+			wait(t, ready)
+			select {
+			case err := <-done:
+				t.Fatalf("early completion: %v", err)
+			case <-time.After(10 * time.Millisecond):
+			}
+			once.Do(func() { close(release) })
+			if err := receive(t, done); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestWorkerFailureAndTeardownUnblocks(t *testing.T) {
+	a := newApp(t, nil, time.Second)
+	released := make(chan struct{})
+	ready := make(chan struct{})
+	failure := errors.New("worker failed")
+	add(t, a, Module{Name: "resource", Setup: func(ctx context.Context) error {
+		return a.Go(ctx, "waiting", func(ctx context.Context) error { close(ready); <-ctx.Done(); <-released; return ctx.Err() })
+	}, Teardown: func(ctx context.Context) error {
+		if ctx.Err() != nil {
+			t.Errorf("teardown canceled early: %v", ctx.Err())
+		}
+		close(released)
+		return nil
+	}, Run: func(context.Context) error { <-ready; return failure }})
+	err := a.Run(context.Background())
+	if !errors.Is(err, failure) || errors.Is(err, context.Canceled) {
+		t.Fatalf("errors %v", err)
+	}
+	b := newApp(t, nil, 0)
+	add(t, b, Module{Name: "worker", Setup: func(ctx context.Context) error {
+		return b.Go(ctx, "failing", func(context.Context) error { return failure })
+	}, Run: func(ctx context.Context) error { <-ctx.Done(); return ctx.Err() }})
+	if err = b.Run(context.Background()); !errors.Is(err, failure) {
+		t.Fatalf("worker error %v", err)
+	}
+}
+
+func TestSignalDuringSetup(t *testing.T) {
+	aSignals := make(chan os.Signal, 2)
+	a := newApp(t, aSignals, time.Second)
+	entered := make(chan struct{})
+	rolled := false
+	partialCleaned := false
+	add(t, a, Module{Name: "ready", Teardown: func(context.Context) error { rolled = true; return nil }})
+	add(t, a, Module{Name: "partial", Setup: func(ctx context.Context) error {
+		close(entered)
+		<-ctx.Done()
+		partialCleaned = true
+		return errors.Join(ctx.Err(), nil)
+	}, Teardown: func(context.Context) error { t.Error("failed setup torn down"); return nil }})
+	add(t, a, Module{Name: "never", Setup: func(context.Context) error { t.Error("late setup started"); return nil }})
+	done := run(a, context.Background())
+	wait(t, entered)
+	aSignals <- syscall.SIGINT
+	if err := receive(t, done); err != nil {
+		t.Fatal(err)
+	}
+	if !rolled || !partialCleaned {
+		t.Fatal("cleanup missing")
+	}
+	b := newApp(t, nil, 0)
+	add(t, b, Module{Name: "initiator", Setup: func(context.Context) error { return context.Canceled }})
+	if err := b.Run(context.Background()); !errors.Is(err, context.Canceled) {
+		t.Fatalf("initiator lost: %v", err)
+	}
+}
+
+func TestMixedErrorsAndParentValues(t *testing.T) {
+	type key struct{}
+	parent, cancel := context.WithCancel(context.WithValue(context.Background(), key{}, "value"))
+	defer cancel()
+	a := newApp(t, nil, time.Second)
+	ready := make(chan struct{})
+	independent := errors.New("independent")
+	teardownErr := errors.New("teardown")
+	add(t, a, Module{Name: "mixed", Run: func(ctx context.Context) error {
+		close(ready)
+		<-ctx.Done()
+		return errors.Join(ctx.Err(), independent)
+	}, Teardown: func(ctx context.Context) error {
+		if ctx.Value(key{}) != "value" || ctx.Err() != nil {
+			t.Error("shutdown context lost values or inherited cancellation")
+		}
+		return errors.Join(teardownErr, context.Canceled)
+	}})
+	done := run(a, parent)
+	wait(t, ready)
+	cancel()
+	err := receive(t, done)
+	for _, want := range []error{context.Canceled, independent, teardownErr} {
+		if !errors.Is(err, want) {
+			t.Fatalf("missing %v: %v", want, err)
+		}
+	}
+	if !strings.Contains(err.Error(), "mixed") {
+		t.Fatal("missing diagnostic name")
+	}
+}
+
+func TestBoundedHooksAndWorkers(t *testing.T) {
+	for _, kind := range []string{"setup", "teardown", "worker"} {
+		t.Run(kind, func(t *testing.T) {
+			signals := make(chan os.Signal, 2)
+			a := newApp(t, signals, 30*time.Millisecond)
+			entered := make(chan struct{})
+			release := make(chan struct{})
+			exited := make(chan struct{})
+			defer func() { close(release); wait(t, exited) }()
+			blocked := func(context.Context) error { close(entered); <-release; close(exited); return nil }
+			var torn atomic.Int32
+			m := Module{Name: "blocked", Teardown: func(context.Context) error { torn.Add(1); return nil }}
+			switch kind {
+			case "setup":
+				m.Setup = blocked
+			case "teardown":
+				m.Teardown = blocked
+			case "worker":
+				m.Setup = func(ctx context.Context) error { return a.Go(ctx, "blocked", blocked) }
+			}
+			add(t, a, m)
+			done := run(a, context.Background())
+			wait(t, entered)
+			start := time.Now()
+			signals <- syscall.SIGTERM
+			err := receive(t, done)
+			if !errors.Is(err, context.DeadlineExceeded) {
+				t.Fatalf("deadline missing: %v", err)
+			}
+			if time.Since(start) > time.Second {
+				t.Fatal("shutdown exceeded bound")
+			}
+			if kind == "setup" && torn.Load() != 0 {
+				t.Fatal("abandoned setup torn down")
+			}
+		})
+	}
+}
+
+func TestSecondSignalAndClosedSource(t *testing.T) {
+	for _, trigger := range []string{"signal", "failure"} {
+		t.Run(trigger, func(t *testing.T) {
+			signals := make(chan os.Signal, 2)
+			a := newApp(t, signals, time.Second)
+			entered := make(chan struct{})
+			release := make(chan struct{})
+			exited := make(chan struct{})
+			defer func() { close(release); wait(t, exited) }()
+			failure := errors.New("failed")
+			ready := make(chan struct{})
+			add(t, a, Module{Name: "blocked", Run: func(ctx context.Context) error {
+				close(ready)
+				if trigger == "failure" {
+					return failure
+				}
+				<-ctx.Done()
+				return ctx.Err()
+			}, Teardown: func(context.Context) error { close(entered); <-release; close(exited); return nil }})
+			done := run(a, context.Background())
+			wait(t, ready)
+			if trigger == "signal" {
+				signals <- syscall.SIGINT
+			}
+			wait(t, entered)
+			if trigger == "failure" {
+				signals <- syscall.SIGINT
+			}
+			signals <- syscall.SIGTERM
+			err := receive(t, done)
+			if !errors.Is(err, context.Canceled) || errors.Is(err, failure) != (trigger == "failure") {
+				t.Fatalf("abandonment %v", err)
+			}
+		})
+	}
+	signals := make(chan os.Signal)
+	close(signals)
+	a := newApp(t, signals, 0)
+	if err := a.Run(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestAdmissionRace(t *testing.T) {
+	for range 50 {
+		a := newApp(t, nil, time.Second)
+		parent, cancel := context.WithCancel(context.Background())
+		ready := make(chan context.Context, 1)
+		add(t, a, Module{Name: "service", Run: func(ctx context.Context) error { ready <- ctx; <-ctx.Done(); return ctx.Err() }})
+		done := run(a, parent)
+		ctx := <-ready
+		var accepted, finished atomic.Int32
+		var callers sync.WaitGroup
+		for range 20 {
+			callers.Go(func() {
+				if err := a.Go(ctx, "racer", func(context.Context) error { finished.Add(1); return nil }); err == nil {
+					accepted.Add(1)
+				}
+			})
+		}
+		cancel()
+		callers.Wait()
+		err := receive(t, done)
+		if !errors.Is(err, context.Canceled) {
+			t.Fatalf("parent error %v", err)
+		}
+		if accepted.Load() != finished.Load() {
+			t.Fatal("accepted worker escaped completion")
+		}
+		if a.Go(ctx, "late", func(context.Context) error { t.Error("late launch"); return nil }) == nil {
+			t.Fatal("late admission")
+		}
+	}
+}
+
+func TestIndependentDescendantCancellation(t *testing.T) {
+	for _, mixed := range []bool{false, true} {
+		t.Run(map[bool]string{false: "cancellation-only", true: "mixed"}[mixed], func(t *testing.T) {
+			signals := make(chan os.Signal, 2)
+			a := newApp(t, signals, time.Second)
+			canceled := make(chan struct{})
+			allowReturn := make(chan struct{})
+			other := errors.New("other")
+			add(t, a, Module{Name: "owner", Setup: func(ctx context.Context) error {
+				child, cancel := context.WithCancel(ctx)
+				err := a.Go(child, "independent", func(ctx context.Context) error {
+					cancel()
+					close(canceled)
+					<-allowReturn
+					err := ctx.Err()
+					if mixed {
+						err = errors.Join(err, other)
+					}
+					return fmt.Errorf("worker result: %w", err)
+				})
+				if err != nil {
+					cancel()
+				}
+				return err
+			}, Teardown: func(context.Context) error { close(allowReturn); return nil }})
+			done := run(a, context.Background())
+			wait(t, canceled)
+			signals <- syscall.SIGTERM
+			if err := receive(t, done); !errors.Is(err, context.Canceled) || errors.Is(err, other) != mixed {
+				t.Fatalf("independent cancellation lost: %v", err)
+			}
+		})
+	}
+}
+
+func TestParentCancellationDuringShutdown(t *testing.T) {
+	for _, boundary := range []string{"completion", "deadline", "second-signal"} {
+		t.Run(boundary, func(t *testing.T) {
+			iterations := 1
+			if boundary == "completion" {
+				iterations = 1000
+			}
+			for range iterations {
+				parent, cancel := context.WithCancel(context.Background())
+				signals := make(chan os.Signal, 2)
+				timeout := time.Second
+				if boundary == "deadline" {
+					timeout = 20 * time.Millisecond
+				}
+				a := newApp(t, signals, timeout)
+				exited := make(chan struct{})
+				add(t, a, Module{Name: "last", Teardown: func(ctx context.Context) error {
+					defer close(exited)
+					cancel()
+					switch boundary {
+					case "deadline":
+						<-ctx.Done()
+					case "second-signal":
+						signals <- syscall.SIGINT
+						signals <- syscall.SIGTERM
+						<-ctx.Done()
+					}
+					return nil
+				}})
+				err := a.Run(parent)
+				cancel()
+				wait(t, exited)
+				if !errors.Is(err, context.Canceled) {
+					t.Fatalf("parent cancellation lost: %v", err)
+				}
+				if errors.Is(err, context.DeadlineExceeded) != (boundary == "deadline") {
+					t.Fatalf("unexpected shutdown result: %v", err)
+				}
+				parentErrors := 0
+				for _, child := range err.(interface{ Unwrap() []error }).Unwrap() {
+					if child == context.Canceled {
+						parentErrors++
+					}
+				}
+				if parentErrors != 1 {
+					t.Fatalf("parent error recorded %d times: %v", parentErrors, err)
+				}
+			}
+		})
+	}
+}
+
+func TestSuccessfulInterruptedSetupRollsBack(t *testing.T) {
+	signals := make(chan os.Signal, 2)
+	a := newApp(t, signals, time.Second)
+	entered := make(chan struct{})
+	var order []string
+	for _, name := range []string{"first", "interrupted"} {
+		add(t, a, Module{Name: name, Setup: func(ctx context.Context) error {
+			if name == "interrupted" {
+				close(entered)
+				<-ctx.Done()
+			}
+			return nil
+		}, Teardown: func(context.Context) error { order = append(order, name); return nil }})
+	}
+	done := run(a, context.Background())
+	wait(t, entered)
+	signals <- syscall.SIGINT
+	if err := receive(t, done); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(order, []string{"interrupted", "first"}) {
+		t.Fatalf("rollback %v", order)
+	}
+}
+
+func TestSharedDeadline(t *testing.T) {
+	a := newApp(t, nil, 80*time.Millisecond)
+	var firstDeadline time.Time
+	entered := make(chan struct{})
+	release := make(chan struct{})
+	exited := make(chan struct{})
+	defer func() { close(release); wait(t, exited) }()
+	var skipped atomic.Bool
+	add(t, a, Module{Name: "never", Teardown: func(context.Context) error { skipped.Store(true); return nil }})
+	add(t, a, Module{Name: "blocked", Teardown: func(ctx context.Context) error {
+		deadline, ok := ctx.Deadline()
+		if !ok || !deadline.Equal(firstDeadline) {
+			t.Error("deadline reset between hooks")
+		}
+		close(entered)
+		<-release
+		close(exited)
+		return nil
+	}})
+	add(t, a, Module{Name: "first", Teardown: func(ctx context.Context) error {
+		firstDeadline, _ = ctx.Deadline()
+		time.Sleep(20 * time.Millisecond)
+		return nil
+	}})
+	done := run(a, context.Background())
+	wait(t, entered)
+	if err := receive(t, done); !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("deadline %v", err)
+	}
+	if skipped.Load() {
+		t.Fatal("hook started after abandonment")
+	}
+}
+
+func TestNormalCompletionAdmissionRace(t *testing.T) {
+	for range 50 {
+		a := newApp(t, nil, time.Second)
+		ready := make(chan context.Context, 1)
+		release := make(chan struct{})
+		add(t, a, Module{Name: "service", Run: func(ctx context.Context) error { ready <- ctx; <-release; return nil }})
+		done := run(a, context.Background())
+		ctx := <-ready
+		var accepted, finished atomic.Int32
+		var callers sync.WaitGroup
+		for range 20 {
+			callers.Go(func() {
+				if a.Go(ctx, "racer", func(context.Context) error { finished.Add(1); return nil }) == nil {
+					accepted.Add(1)
+				}
+			})
+		}
+		close(release)
+		callers.Wait()
+		if err := receive(t, done); err != nil {
+			t.Fatal(err)
+		}
+		if accepted.Load() != finished.Load() {
+			t.Fatal("normal completion lost worker")
+		}
+	}
+}
+
+func TestStartupWaitsForSetupDespiteEmptyWorkers(t *testing.T) {
+	a := newApp(t, nil, time.Second)
+	entered := make(chan struct{})
+	release := make(chan struct{})
+	defer func() {
+		select {
+		case <-release:
+		default:
+			close(release)
+		}
+	}()
+	add(t, a, Module{Name: "setup", Setup: func(context.Context) error { close(entered); <-release; return nil }})
+	done := run(a, context.Background())
+	wait(t, entered)
+	if a.Run(context.Background()) == nil {
+		t.Fatal("concurrent Run accepted")
+	}
+	if a.Register(Module{}) == nil {
+		t.Fatal("registration remained open")
+	}
+	select {
+	case err := <-done:
+		t.Fatalf("ended during setup: %v", err)
+	default:
+	}
+	close(release)
+	if err := receive(t, done); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestMixedShutdownErrorPreservesCause(t *testing.T) {
+	signals := make(chan os.Signal, 2)
+	a := newApp(t, signals, time.Second)
+	ready := make(chan struct{})
+	independent := &os.PathError{Op: "read", Path: "queue", Err: io.ErrUnexpectedEOF}
+	add(t, a, Module{Name: "mixed", Run: func(ctx context.Context) error {
+		close(ready)
+		<-ctx.Done()
+		return fmt.Errorf("outer: %w", errors.Join(fmt.Errorf("cancellation: %w", ctx.Err()), independent))
+	}})
+	done := run(a, context.Background())
+	wait(t, ready)
+	signals <- syscall.SIGTERM
+	err := receive(t, done)
+	var pathErr *os.PathError
+	if !errors.As(err, &pathErr) || pathErr != independent || !errors.Is(err, io.ErrUnexpectedEOF) {
+		t.Fatalf("independent cause lost: %v", err)
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("mixed wrapper was reconstructed: %v", err)
+	}
+}
+
+// matchingError exercises wrapper-owned matching independently of its child.
+type matchingError struct {
+	child error
+	match error
+}
+
+func (e *matchingError) Error() string        { return "custom: " + e.child.Error() }
+func (e *matchingError) Unwrap() error        { return e.child }
+func (e *matchingError) Is(target error) bool { return target == e.match }
+
+func TestMixedShutdownErrorPreservesWrapper(t *testing.T) {
+	for _, kind := range []string{"path", "custom"} {
+		t.Run(kind, func(t *testing.T) {
+			signals := make(chan os.Signal, 2)
+			a := newApp(t, signals, time.Second)
+			ready := make(chan struct{})
+			match := errors.New("custom match")
+			var original error
+			add(t, a, Module{Name: "mixed", Run: func(ctx context.Context) error {
+				close(ready)
+				<-ctx.Done()
+				joined := errors.Join(ctx.Err(), io.ErrUnexpectedEOF)
+				if kind == "path" {
+					original = &os.PathError{Op: "read", Path: "queue", Err: joined}
+				} else {
+					original = &matchingError{child: joined, match: match}
+				}
+				return original
+			}})
+			done := run(a, context.Background())
+			wait(t, ready)
+			signals <- syscall.SIGTERM
+			err := receive(t, done)
+			if !errors.Is(err, original) || !errors.Is(err, io.ErrUnexpectedEOF) {
+				t.Fatalf("wrapper identity or inner failure lost: %v", err)
+			}
+			if kind == "path" {
+				var pathErr *os.PathError
+				if !errors.As(err, &pathErr) || pathErr != original {
+					t.Fatalf("typed wrapper lost: %v", err)
+				}
+			} else {
+				var custom *matchingError
+				if !errors.As(err, &custom) || custom != original || !errors.Is(err, match) {
+					t.Fatalf("custom matching lost: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestCancellationOnly(t *testing.T) {
+	for _, err := range []error{
+		context.Canceled,
+		fmt.Errorf("wrapped: %w", context.Canceled),
+		&os.PathError{Op: "read", Path: "queue", Err: errors.Join(context.Canceled, fmt.Errorf("wrapped: %w", context.Canceled))},
+	} {
+		if !cancellationOnly(err, context.Canceled) {
+			t.Errorf("expected cancellation not recognized: %v", err)
+		}
+	}
+	for _, err := range []error{nil, io.ErrUnexpectedEOF, context.DeadlineExceeded, errors.Join(context.Canceled, io.ErrUnexpectedEOF)} {
+		if cancellationOnly(err, context.Canceled) {
+			t.Errorf("independent error classified as cancellation: %v", err)
+		}
+	}
+}