docs: MkDocs scaffold, ADR-0001, README quickstart (refs #32)

Add mkdocs.yml (Material theme + nav), docs/index.md, and the first ADR
(docs/architecture/adr-0001-loose-coupling.md, Nygard template) recording
the loose-coupling stance from CLAUDE.md §8. Rewrite the README quickstart
to be accurate and reach a green local environment in under 10 minutes
(correct clone URL, .NET 10 + container-engine prereqs, `make ci` and the
compose smoke), and document building the docs site. Ignore .venv/ and site/.

Verified: `mkdocs build` succeeds; `make lint/build/unit` green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitea/ISSUE_TEMPLATE/adr-proposal.md

@@ -0,0 +1,24 @@
+---
+name: ADR proposal
+about: Propose a decision that needs recording before coding (CLAUDE.md §14)
+title: "ADR: "
+labels:
+  - type:adr-proposal
+---
+
+**Decision to be made:**
+
+**Context / forces:** <!-- what makes this non-obvious; constraints, trade-offs -->
+
+**Options considered:**
+1.
+2.
+
+**Proposed option + why:**
+
+**Consequences:** <!-- what becomes easier/harder; what we commit to -->
+
+**Coupling rules touched (CLAUDE.md §8):** <!-- none, or which and why -->
+
+> On acceptance, the ADR file (`docs/architecture/adr-NNNN-title.md`, Nygard
+> template) lands in the PR that implements the decision.

.gitea/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,21 @@
+---
+name: Bug
+about: Something behaves incorrectly
+title: ""
+labels:
+  - type:bug
+---
+
+**What happened:**
+
+**What you expected:**
+
+**Steps to reproduce:**
+1.
+2.
+
+**Environment:** <!-- branch/commit, OS, container engine, anything relevant -->
+
+**Logs / evidence:**
+
+**Suspected area:** <!-- e.g. area:bff, area:acl — add the matching area label -->

.gitea/ISSUE_TEMPLATE/slice.md

@@ -0,0 +1,31 @@
+---
+name: Slice (user story)
+about: A backlog slice — independently demoable, encodes the Definition of Done
+title: "S-NN · "
+labels:
+  - type:slice
+---
+
+**Outcome:** <!-- one sentence; user-visible if possible -->
+
+**Acceptance:**
+<!-- Gherkin scenarios or testable assertions -->
+-
+
+**Touches:** <!-- services and folders -->
+
+**Out of scope:** <!-- explicit non-goals -->
+
+## Definition of Done
+
+- [ ] This linked Gitea issue exists and is on the right milestone.
+- [ ] Failing test written and committed first (`test(scope): … (refs #NN)`).
+- [ ] Implementation makes the test pass (`feat(scope): … (refs #NN)`).
+- [ ] Refactor commit follows if structure improved.
+- [ ] Conventional Commit messages referencing this issue.
+- [ ] All Gitea Actions CI jobs green (or `make ci` green while no runner exists).
+- [ ] `docker compose up` from a fresh clone reaches green health checks within 3 minutes.
+- [ ] Docs touched if behaviour, contracts, or operations changed.
+- [ ] ADR added in `docs/architecture/` if a non-obvious decision was made.
+- [ ] Demo note appended to `docs/demo-script.md` if the slice is user-visible.
+- [ ] This issue closed by the merging PR (`closes #NN`).

.gitea/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,23 @@
+<!-- Title: Conventional Commit style, e.g. feat(bff): … (closes #NN) -->
+
+## What & why
+
+<!-- Summary of the change and the slice/bug it addresses. -->
+
+Closes #
+
+## Definition of Done
+
+- [ ] Linked Gitea issue (above).
+- [ ] Failing test committed before the implementation.
+- [ ] Implementation makes the test pass; refactor commit if structure improved.
+- [ ] Conventional Commits referencing the issue (`refs #NN`).
+- [ ] CI green — all Gitea Actions jobs (or `make ci` green while no runner exists).
+- [ ] `docker compose up` from a fresh clone reaches green health checks within 3 minutes.
+- [ ] Docs updated if behaviour, contracts, or operations changed.
+- [ ] ADR added in `docs/architecture/` if a non-obvious decision was made.
+- [ ] Demo note in `docs/demo-script.md` if user-visible.
+
+## Notes for reviewers
+
+<!-- Anything that helps review: trade-offs, follow-ups, known gaps. -->

.gitea/workflows/ci.yaml

@@ -0,0 +1,50 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+# Self-hosted runner — see docs/runbooks/ci.md for the runner setup.
+# `uses:` are absolute, tag-pinned URLs (CLAUDE.md §8.7 / §15).
+
+# Each job calls a `make` target — the same one developers run locally
+# (`make ci`). The Makefile is the single source of truth; see docs/runbooks/ci.md.
+
+jobs:
+  lint:
+    runs-on: respellion-linux
+    steps:
+      - uses: https://github.com/actions/checkout@v4
+      - uses: https://github.com/actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+      - run: make lint
+
+  build:
+    runs-on: respellion-linux
+    steps:
+      - uses: https://github.com/actions/checkout@v4
+      - uses: https://github.com/actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+      - run: make build
+
+  unit:
+    runs-on: respellion-linux
+    steps:
+      - uses: https://github.com/actions/checkout@v4
+      - uses: https://github.com/actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+      - run: make unit
+
+  compose-smoke:
+    runs-on: respellion-linux
+    steps:
+      - uses: https://github.com/actions/checkout@v4
+      - run: make smoke

.gitignore

@@ -22,6 +22,10 @@ node_modules/
 dist/
 .angular/
 
+# Python / MkDocs
+.venv/
+site/
+
 # OS
 .DS_Store
 Thumbs.db

CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project. Generated from Conventional Commits by git-cliff.
+
+## Unreleased
+
+### CI
+- Gitea Actions pipeline + runner runbook (refs #30) (#37)
+
+### Chores
+- Add idempotent Gitea backlog seeder
+- Remove bootstrap scripts from main (#35)
+
+### Documentation
+- Split S-00 into sub-slices (refs #1) (#33)
+
+### Features
+- Placeholder BFF + /health endpoint (closes #28) (#34)
+- Containerize BFF + compose-up smoke (closes #29) (#36)
+

Makefile

@@ -0,0 +1,54 @@
+# Developer + CI entrypoints.
+#
+# These targets are the single source of truth for the checks. The Gitea
+# Actions workflow (.gitea/workflows/ci.yaml) invokes the SAME targets, so
+# `make ci` locally runs exactly what the pipeline runs — no drift. Until a
+# self-hosted runner is registered, `make ci` is the gate (see docs/runbooks/ci.md).
+
+SLN        := services/bff/Bff.slnx
+COMPOSE    := infra/docker-compose.yml
+HEALTH_URL := http://localhost:8080/health
+
+# On a rootless Podman dev box, point Docker CLI/Compose at the Podman socket —
+# but only if that socket exists and DOCKER_HOST isn't already set, so real
+# Docker hosts and CI runners are left untouched.
+PODMAN_SOCK := /run/user/$(shell id -u)/podman/podman.sock
+ifeq ($(wildcard $(PODMAN_SOCK)),$(PODMAN_SOCK))
+ifeq ($(origin DOCKER_HOST),undefined)
+export DOCKER_HOST := unix://$(PODMAN_SOCK)
+endif
+endif
+
+.PHONY: ci lint build unit smoke down changelog help
+
+## ci: run the full pipeline — lint, build, unit, smoke (mirrors Gitea Actions)
+ci: lint build unit smoke
+
+## lint: verify formatting (no changes)
+lint:
+	dotnet format $(SLN) --verify-no-changes
+
+## build: release build
+build:
+	dotnet build $(SLN) -c Release
+
+## unit: run unit tests
+unit:
+	dotnet test $(SLN) -c Release
+
+## smoke: compose up (wait for healthy), curl /health, then tear down
+smoke:
+	docker compose -f $(COMPOSE) up -d --build --wait
+	bash -c 'curl -fsS $(HEALTH_URL); rc=$$?; docker compose -f $(COMPOSE) down --volumes; exit $$rc'
+
+## down: stop and remove the local stack
+down:
+	docker compose -f $(COMPOSE) down --volumes
+
+## changelog: regenerate CHANGELOG.md from Conventional Commits (git-cliff)
+changelog:
+	git-cliff --output CHANGELOG.md
+
+## help: list available targets
+help:
+	@grep -E '^## ' $(MAKEFILE_LIST) | sed 's/^## //'

README.md

@@ -41,31 +41,32 @@ For the architecture rationale, see [docs/PRD.md §3](docs/PRD.md) and [docs/arc
 
 **Prerequisites**
 
-- Docker Engine (or Docker Desktop) with Compose v2
-- ~8 GB free RAM, ~10 GB free disk
-- Bash or PowerShell
+- .NET 10 SDK (for `make lint/build/unit`)
+- A container engine with Compose v2 — Docker, or rootless Podman (see [docs/runbooks/ci.md](docs/runbooks/ci.md) for the Podman + Compose-provider setup)
+- `make`, `curl`, `git`
+- ~4 GB free RAM, ~5 GB free disk (grows as services land)
 
-**Bring the stack up**
+**Clone**
 
 ```bash
-git clone https://gitea.respellion.local/respellion/register-reference.git
-cd register-reference
-cp .env.example .env          # edit if you change ports
-docker compose -f infra/docker-compose.yml up -d
+git clone git@git.labs.respellion.tech:eho/register-referentie.git
+cd register-referentie
 ```
 
-Health checks should be green within ~3 minutes on a developer machine. If something fails, see [docs/runbooks/local-startup.md](docs/runbooks/local-startup.md).
+**Wired today (Iteration 0):** only the placeholder BFF exists so far. Get to green in under 10 minutes — run the full check gate, or just the running service:
 
-> **Wired today (Iteration 0):** only the placeholder BFF is in `infra/docker-compose.yml` so far. Bring it up and smoke-test its health endpoint:
->
-> ```bash
-> docker compose -f infra/docker-compose.yml up -d --build --wait
-> curl http://localhost:8080/health   # -> Healthy
-> ```
->
-> `--wait` exits non-zero unless the container reports healthy, so this doubles as the compose-up smoke test. The remaining services and the URLs below land in later slices.
+```bash
+make ci          # lint + build + unit + container smoke — the CI gate
+```
 
-**Default URLs**
+```bash
+docker compose -f infra/docker-compose.yml up -d --build --wait
+curl http://localhost:8080/health     # -> Healthy
+```
+
+`--wait` exits non-zero unless the container reports healthy, so it doubles as the compose-up smoke test. The remaining services and the URLs below land in later slices.
+
+**Target service URLs** *(most land in later slices)*
 
 | Service | URL |
 |---|---|
@@ -73,7 +74,7 @@ Health checks should be green within ~3 minutes on a developer machine. If somet
 | Openbaar register | http://localhost:4201 |
 | Behandel-portal | http://localhost:4202 |
 | Beheer-portal | http://localhost:4203 |
-| BFF | http://localhost:5000 |
+| BFF | http://localhost:8080 |
 | OpenZaak | http://localhost:8000 |
 | Open Notificaties | http://localhost:8001 |
 | Flowable | http://localhost:8080 |
@@ -82,10 +83,12 @@ Health checks should be green within ~3 minutes on a developer machine. If somet
 
 Test credentials, BSNs, and personas: see [docs/synthetic-data.md](docs/synthetic-data.md).
 
-**Re-seed synthetic data**
+**Build the docs site**
 
 ```bash
-./tools/seed.sh               # or pwsh ./tools/seed.ps1
+python3 -m venv .venv && .venv/bin/pip install mkdocs-material
+.venv/bin/mkdocs serve         # live preview at http://localhost:8000
+.venv/bin/mkdocs build         # static site in ./site
 ```
 
 ---

cliff.toml

@@ -0,0 +1,45 @@
+# git-cliff configuration — generates CHANGELOG.md from Conventional Commits.
+# Run via `make changelog`. See https://git-cliff.org.
+
+[changelog]
+header = """
+# Changelog
+
+All notable changes to this project. Generated from Conventional Commits by git-cliff.\n
+"""
+body = """
+{% if version %}\
+## {{ version }} — {{ timestamp | date(format="%Y-%m-%d") }}
+{% else %}\
+## Unreleased
+{% endif %}\
+{% for group, commits in commits | group_by(attribute="group") %}
+### {{ group | upper_first }}
+{% for commit in commits %}\
+- {{ commit.message | upper_first }}{% if commit.breaking %} **[BREAKING]**{% endif %}
+{% endfor %}\
+{% endfor %}\n
+"""
+trim = true
+
+[git]
+conventional_commits = true
+filter_unconventional = true
+split_commits = false
+protect_breaking_commits = true
+tag_pattern = "v[0-9]*"
+# CalVer tags: YYYY.MM.PATCH
+filter_commits = false
+commit_parsers = [
+  { message = "^feat", group = "Features" },
+  { message = "^fix", group = "Bug Fixes" },
+  { message = "^perf", group = "Performance" },
+  { message = "^refactor", group = "Refactor" },
+  { message = "^docs", group = "Documentation" },
+  { message = "^test", group = "Tests" },
+  { message = "^ci", group = "CI" },
+  { message = "^build", group = "Build" },
+  { message = "^arch", group = "Architecture" },
+  { message = "^chore", group = "Chores" },
+  { message = ".*", group = "Other" },
+]

docs/architecture/adr-0001-loose-coupling.md

@@ -0,0 +1,58 @@
+# ADR-0001: Loose coupling to upstream Common Ground modules
+
+- **Status:** Accepted
+- **Date:** 2026-06-03
+- **Deciders:** Respellion engineering
+- **Template note:** This is the first ADR and doubles as the worked example of
+  the Nygard template. Copy its shape for new ADRs (`adr-NNNN-title.md`).
+
+## Context
+
+This reference application orchestrates several upstream Common Ground modules —
+OpenZaak (ZGW APIs), Open Notificaties (NRC), Objecten/Objecttypen, Flowable,
+Keycloak. Each is an independently developed, independently deployed peer. The
+temptation in a demo is to reach straight into a peer's database or couple to its
+internal schema to move faster. That coupling is exactly what makes Common Ground
+landscapes brittle and un-upgradeable in practice.
+
+We need a stance, recorded up front, on how our services may talk to these peers.
+
+## Decision
+
+**We integrate with upstream modules only through their documented public APIs, and
+we isolate that integration behind explicit anti-corruption boundaries.**
+
+Concretely (mirrors CLAUDE.md §8):
+
+1. The **ACL** is the only code that talks to ZGW APIs; no other service constructs
+   ZGW URLs.
+2. The **Workflow Client** is the only code that talks to Flowable; BPMN models hold
+   no OpenZaak knowledge.
+3. **Portals talk only to the BFF** — never directly to a backend or a peer module.
+4. **No direct database access across services or to any peer.** Each service owns
+   its schema; the Read Projection is a rebuildable derived artefact.
+5. **Idempotency at every event boundary** (the Event Subscriber tolerates duplicate
+   and out-of-order NRC events).
+
+Bending any of these is an ADR-worthy moment (CLAUDE.md §14): stop and open an
+`adr-proposal` issue first.
+
+## Consequences
+
+**Positive**
+
+- Upstream modules can be upgraded or swapped behind their APIs without rippling
+  through our services.
+- Coupling is visible and minimal — anti-corruption code lives in one named place.
+- The architecture teaches the Common Ground pattern by enforcing it.
+
+**Negative / costs**
+
+- More indirection: a translation layer (ACL, Workflow Client) instead of direct
+  calls. Accepted — it's the point.
+- Eventual consistency across aggregates must be designed for, not assumed away.
+
+**Follow-up**
+
+- Each integration slice that touches a boundary references this ADR; new boundary
+  decisions get their own ADR.

docs/gitea-workflow.md

@@ -0,0 +1,52 @@
+# Working with Gitea: issues, milestones, PRs
+
+Gitea is the **system of record** (CLAUDE.md §7). `BACKLOG.md` is a human-readable
+mirror of the active milestone — when they disagree, Gitea wins.
+
+## Issues
+
+- Open issues from the templates in `.gitea/ISSUE_TEMPLATE/`:
+  - **Slice** — a backlog user story (`S-NN · …`), encodes the Definition of Done.
+  - **Bug** — a defect.
+  - **ADR proposal** — a decision to record before coding (CLAUDE.md §14).
+- Every issue gets `type:*` plus the relevant `area:*` label(s), and is assigned to
+  its iteration **milestone** (`Iteration N — …`).
+- Splitting a slice that grew too big: see CLAUDE.md §13 and the "How to split a
+  slice" section of `BACKLOG.md`.
+
+## Branches & commits
+
+- Trunk-based: short-lived branches off `main`, squash-merged. Never push to `main`.
+- Branch name: `<type>/<issue-number>-<slug>`, e.g. `feat/28-bff-health`.
+- Conventional Commits, each referencing its issue: `feat(bff): … (refs #28)`.
+- TDD order: the `test(...)` red commit precedes the `feat(...)` green commit.
+
+## Pull requests
+
+- Open with `tea pr create` (the Gitea CLI) or the web UI; the body uses
+  `.gitea/PULL_REQUEST_TEMPLATE.md` and its DoD checklist.
+- The merging PR closes its issue via `closes #NN` in the squash-commit body.
+  Work that isn't finished (e.g. CI green pending a runner) uses `refs #NN` and the
+  issue stays open.
+- A PR needs a linked issue. Don't open one without it.
+
+## CI gate
+
+Until a self-hosted `respellion-linux` runner is registered, `make ci` is the gate
+(it runs the same checks the workflow does). See [runbooks/ci.md](runbooks/ci.md).
+
+## CLI cheatsheet (`tea`)
+
+```bash
+tea issues list --state open          # backlog
+tea issue create --title "S-NN · …" --labels type:slice,area:bff --milestone "Iteration 1 — Walking Skeleton"
+tea pr create --base main --head <branch> --title "…" --description "… closes #NN"
+tea pr list                           # open PRs
+tea pr merge <n> --style squash       # merge (after review)
+```
+
+## Changelog & releases
+
+`CHANGELOG.md` is generated from commits by `git-cliff` (`make changelog`), refreshed
+on tag. Versioning is **CalVer** `YYYY.MM.PATCH`; releases are published via Gitea
+Releases.

docs/index.md

@@ -0,0 +1,23 @@
+# register-referentie
+
+A reference application demonstrating Respellion's Common Ground architecture
+pattern. Quality and architectural clarity over feature throughput — every commit
+should teach.
+
+## Where to go
+
+- **[Product Requirements](PRD.md)** — what we're building and why.
+- **[ADR-0001: Loose coupling](architecture/adr-0001-loose-coupling.md)** — the
+  non-negotiable integration stance; the template for future ADRs.
+- **[Working in Gitea](gitea-workflow.md)** — issues, milestones, branches, PRs.
+- **[CI runbook](runbooks/ci.md)** — the pipeline and the `make ci` local gate.
+
+## Quickstart
+
+See the repository `README.md`. In short: clone, then either run the checks with
+`make ci`, or bring the BFF up with
+`docker compose -f infra/docker-compose.yml up -d --build --wait` and
+`curl http://localhost:8080/health`.
+
+> This site is built with MkDocs Material (`mkdocs build`). It grows with the
+> backlog; sections appear as their slices land.

docs/runbooks/ci.md

@@ -0,0 +1,104 @@
+# CI runbook — Gitea Actions
+
+> **Status: no runner yet → run CI locally with `make ci`.** The workflow
+> `.gitea/workflows/ci.yaml` is in place, but the pipeline cannot go green until a
+> self-hosted `respellion-linux` runner is registered against the Gitea instance.
+> Until then, **`make ci` is the gate** — it runs the exact same checks locally
+> (the workflow calls the same `make` targets). Issue **#30 (S-00-c)** stays open
+> until CI is verified green on a runner.
+
+## The pipeline
+
+`.gitea/workflows/ci.yaml` runs on every push and pull request to `main`. Each job
+calls a `make` target — the **single source of truth** for the checks, so local
+and CI cannot drift:
+
+| Job | Target | Needs |
+|---|---|---|
+| `lint` | `make lint` → `dotnet format … --verify-no-changes` | .NET 10 SDK |
+| `build` | `make build` → `dotnet build … -c Release` | .NET 10 SDK |
+| `unit` | `make unit` → `dotnet test … -c Release` | .NET 10 SDK |
+| `compose-smoke` | `make smoke` → compose up `--wait` → `curl /health` → `down` | container engine + compose v2 |
+
+All `uses:` references are absolute, tag-pinned URLs (`https://github.com/actions/checkout@v4`,
+`https://github.com/actions/setup-dotnet@v4`) per CLAUDE.md §8.7 and §15 — Gitea
+Actions resolves them from GitHub.
+
+## Running CI locally (`make ci`)
+
+Until the runner exists, run the full pipeline yourself before pushing:
+
+```bash
+make ci          # lint + build + unit + smoke — what the pipeline runs
+make lint        # or a single stage
+make smoke       # compose up --wait, curl /health, tear down
+```
+
+**Prerequisites:** .NET 10 SDK, a container engine with Compose v2, and `curl`.
+
+On a **rootless Podman** box (the default dev setup here), the `smoke` target needs
+the Podman API socket and a Compose provider:
+
+```bash
+systemctl --user enable --now podman.socket            # start the API socket
+ln -sf "$(command -v podman)" ~/.local/bin/docker      # docker -> podman shim
+# install Docker Compose v2 into ~/.local/bin as `docker-compose` (the provider)
+```
+
+The Makefile auto-points `DOCKER_HOST` at `/run/user/$(id -u)/podman/podman.sock`
+when that socket exists and `DOCKER_HOST` is unset, so `make smoke` "just works"
+locally while leaving real Docker hosts / CI runners untouched.
+
+## Runner: `respellion-linux`
+
+The single self-hosted runner label this repo targets is **`respellion-linux`**
+(declared here per §15). It is intended to run **co-located on the Gitea server**
+(`git.labs.respellion.tech` / `46.224.220.37`) so CI is durable and independent of
+any developer machine.
+
+### Host prerequisites
+
+The runner executes jobs in **host mode** (see registration below), so the host
+must have, on `PATH`:
+
+- .NET 10 SDK (or let `setup-dotnet` install it into the runner tool cache)
+- A container engine with Compose v2 — Docker, or Podman with the Docker-compatible
+  socket and the `docker-compose` provider (as configured on the dev box)
+- `curl`
+
+### Install & register `act_runner` (on the Gitea server)
+
+```bash
+# 1. Install the binary (pick the version matching the Gitea release line)
+VER=0.2.11
+curl -fsSL -o /usr/local/bin/act_runner \
+  "https://dl.gitea.com/act_runner/${VER}/act_runner-${VER}-linux-amd64"
+chmod +x /usr/local/bin/act_runner
+
+# 2. Obtain a registration token from the Gitea UI:
+#    Site Administration → Actions → Runners → "Create new Runner"  (instance-level)
+#    (or Repo → Settings → Actions → Runners for a repo-scoped runner)
+
+# 3. Register with the respellion-linux label in HOST execution mode.
+#    The ":host" suffix means jobs run directly on the host shell, so
+#    `docker compose` in compose-smoke uses the host engine (no docker-in-docker).
+act_runner register --no-interactive \
+  --instance https://git.labs.respellion.tech \
+  --token <REGISTRATION_TOKEN> \
+  --name respellion-ci-1 \
+  --labels "respellion-linux:host"
+
+# 4. Run it (foreground to verify, then install as a systemd service)
+act_runner daemon
+```
+
+Verify in the Gitea UI (Actions → Runners) that `respellion-ci-1` shows **Idle**,
+then re-run the `CI` workflow; all four jobs should pass.
+
+## Security note
+
+A self-hosted runner in **host mode** executes workflow code directly on the Gitea
+server host. Anyone who can push a workflow can run code there. This is acceptable
+for a **private lab** instance with trusted contributors. For anything
+internet-facing, switch to container/VM isolation (`--labels "respellion-linux:docker://..."`)
+or a dedicated runner host, and gate workflow runs on approval for outside PRs.

mkdocs.yml

@@ -0,0 +1,41 @@
+site_name: register-referentie
+site_description: Reference application for Respellion's Common Ground architecture pattern
+docs_dir: docs
+
+theme:
+  name: material
+  features:
+    - navigation.sections
+    - navigation.top
+    - content.code.copy
+  palette:
+    - scheme: default
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+    - scheme: slate
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
+
+nav:
+  - Home: index.md
+  - Product Requirements: PRD.md
+  - Architecture:
+      - "ADR-0001: Loose coupling": architecture/adr-0001-loose-coupling.md
+  - Working in Gitea: gitea-workflow.md
+  - Runbooks:
+      - CI: runbooks/ci.md
+
+markdown_extensions:
+  - admonition
+  - toc:
+      permalink: true
+  - pymdownx.superfences
+
+# Many docs referenced by PRD.md land in later slices; don't fail the build on them.
+validation:
+  nav:
+    omitted_files: warn
+  links:
+    not_found: warn