v0.14.8: changelog and README

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
People sign in with their Active Directory account
2026-10-18 11:00:28 +02:00 · 2026-10-18 10:59:50 +02:00 · 2026-10-17 08:56:30 +02:00 · 2026-10-17 00:23:26 +02:00 · 2026-10-16 22:40:09 +02:00 · 2026-10-16 22:06:56 +02:00
89 changed files with 6498 additions and 591 deletions
@@ -34,7 +34,11 @@ jobs:
        run: go vet ./...

      - name: Test with the race detector
-        run: go test -race ./...
+        # Under the job's limit, so a package that hangs panics with the
+        # test it was in and where every goroutine waited, rather than the
+        # job ending at its deadline with nothing said: from 2026-10-15 every
+        # run did, printing nothing after internal/release.
+        run: go test -race -timeout 12m ./...

      - name: Build
        run: go build ./...
@@ -15,6 +15,41 @@ Conventions this codebase keeps, which every item here must keep too:
 - `go test ./...`, `go vet ./...` and `govulncheck ./...` pass. No release is
  cut and nothing is deployed to the PoC cluster without being told to.

+## Open, in order (2026-10-16, after v0.14.7)
+
+What is left, most needed first. The detail is in the item each names.
+
+1. ~~**J1**~~ — done 2026-10-16: a restart no longer refused for room
+   another restart was giving back.
+2. ~~**J5**~~ — done 2026-10-16: an upgrade refits an earlier install's
+   judge by itself.
+3. ~~**I3**~~ — done 2026-10-16: `ctl bench overhead`, figures in the
+   README.
+4. ~~**I4**~~ — done 2026-10-17: several keys for one outside provider.
+5. ~~**Active Directory and Entra ID**~~ — done 2026-10-18: `auth.ldap`
+   sign-in and sync, Entra's 200-group overflow kept from taking roles.
+   Still to do: try it against a real domain controller (a Samba AD DC
+   on Proxmox): LDAPS, nested groups, a disabled user suspended by the
+   sync.
+6. **J2** — a judge the leader adds by itself is sized as init's is. (S)
+7. **J3** — HA setup puts the judges on nodes of their own. (S)
+8. **J8** — a judge budget that fits the machine, measured at install. (S)
+9. **F5** — large imports limited by the embedding engine's slots. (M)
+10. **I1** — answers to similar questions from the cache. (M)
+11. **J4** — the model mirror on more than one machine. (M)
+12. **I2** — the customer's MCP servers behind llmgw. (L)
+13. Smaller leftovers: audit before/after values, a tenant-admin role and
+    forms hidden from viewers (C1); Parquet and a scheduled push for usage
+    export (C4); English errors on Turkish pages (C24); H1 tried on the PoC;
+    licences in video and audio (H5); nginx in front of several control
+    planes (J7).
+
+Not code, the operator's to decide or do: the PoC on v0.14.7 (it runs a
+v0.14.5 dev build; no hurry); where Alertmanager sends (its receiver is
+"none"). Settled 2026-10-16: Apertus 8B is on demand (min 0); the HA test
+VMs 157–159, 165, 166 and the e2e VMs 151, 153–156 (a v0.11 HA test from
+2026-10-03, idle since, holding 10.0.0.160 with VRRP id 51) were removed.
+
 ---

 ## A. Security — do first
@@ -1426,13 +1461,211 @@ console show and add them.
  `on_demand.evict_after_idle` / `min_lifetime` as live settings; an
  upgrade that leaves nodes behind says which; `ctl model serve` serves an
  embedding model for embedding; refreshes wait while a form is filled in.
- Open: llmgw's `/mcp` with picture, 3D, VLM and workflow tools, so a
-  client needs no server of its own (asked by the game team); the shared
-  ComfyUI replica (H3's placement side).
+- Done 2026-10-15: llmgw's `/mcp` with picture, 3D, VLM and workflow tools,
+  so a client needs no server of its own (asked by the game team); the
+  shared ComfyUI replica (H3's placement side).
+- Done 2026-10-16 (v0.14.6, v0.14.7): setup lists every part with what it
+  is and its settings; three machines each run the control plane, with a
+  floating address (VRRP id from the address); a lost store primary costs no
+  request (3 s connect per member, keepalive and TCP_USER_TIMEOUT, Patroni
+  ttl 20, a standby leaves the lease alone a round after the store returns);
+  a new leader waits for its judge within the budget; a judge is asked again
+  on another machine at half its budget; init sizes the judge (2 GB, no
+  prompt cache, two cores, one judge on up to four cores on one machine).
+
+## I. What other gateways do that llmgw does not (written 2026-10-16)
+
+From a comparison with Bifrost (maximhq/bifrost, Apache 2.0, Go), with
+LiteLLM and Portkey in mind. Bifrost routes to 23+ cloud providers and runs
+no model; llmgw runs the models, so most of Bifrost is either in llmgw
+already (keys, budgets, fallbacks, guardrails, tracing, SSO, HA — the last
+three paid in Bifrost) or does not apply. These four are worth taking for
+a site that runs its own models. Left until a customer asks: native
+Azure/Anthropic/Bedrock/Vertex adapters, request hooks a customer plugs in,
+routing by what a request holds. Not taken: a realtime (WebSocket audio)
+API, prompt management, an `npx` install.
+
+### I1. Answers to similar questions, not only the same one (M)
+The answer cache (`internal/router/cache.go`, C17) answers a request whose
+body is the same byte for byte. A help desk asked "how do I reset my
+password" in forty wordings asks the model forty times.
+- Per project, off by default, beside the exact cache: `llmgw keys cache
+  --project P --similar 0.95` (the cosine similarity a question must reach;
+  higher is stricter). The exact cache is asked first.
+- The question embedded by a model the operator names
+  (`router.cache.embedding_model`, an embedding model in the catalog), into a
+  pgvector table per project with the answer, the model and the TTL; the
+  store's halfvec and text index work from F applies. SQLite stores keep the
+  exact cache only.
+- What counts as the question: the last user turn, with the system prompt
+  and the earlier turns hashed and required to match exactly — a similar
+  question in another conversation is not the same question. Tools,
+  `response_format` and the sampling settings also exact.
+- Said: `x-llmgw-cache: similar` with the similarity, and the usage row
+  says so; guardrails judge the request before a hit, as for the exact
+  cache. A project with `no_store` gets neither.
+- Done when: forty rewordings of one question on the PoC cost one model call
+  and 39 lookups, and an eval suite run with the cache on scores within a
+  point of the run with it off.
+
+### I2. MCP gateway: the customer's tool servers behind llmgw (L)
+`/mcp` serves llmgw's own tools. An agent inside a company also wants Jira,
+the file server, a database — each an MCP server, each today configured
+in every client with its own credentials and nobody seeing what was called.
+- Servers registered once, by an administrator: `llmgw ctl mcp add jira
+  --url https://… --header-file /etc/llmgw/secrets/jira` (HTTP transport;
+  stdio servers run on the control plane under their own user, like an
+  engine). Their credentials stay on the control plane, never in a client.
+- `/mcp` lists every server's tools, prefixed by its name (`jira.search`),
+  filtered by what the key may use: an allowlist per org, team, project or
+  key, by server or by tool, in the tenancy tree as model allowlists are.
+- Each call goes to the audit log — who, which tool, the arguments' size,
+  the outcome and how long — and through the guardrails both ways (a tool's
+  answer is prompt input). A per-tool rate limit.
+- Later, if it earns it: Bifrost's "code mode" (the tools as one typed API
+  the model writes code against), which cuts the tokens of a long tool list.
+- Done when: Claude Code given only llmgw's `/mcp` reaches a test MCP server
+  through it, a key without the grant does not see the server's tools, and
+  every call is in `ctl audit`.
+
+### I3. What llmgw adds to a request, measured (S) — done 2026-10-16
+`llmgw ctl bench overhead` (`internal/cli/bench_overhead.go`): an instant
+engine and the gateway in one process, four modes (direct, bare, auth, auth
+and guard patterns) at rising rates. On an Apple M5 the gateway added
+0.05–0.42 ms at p50 and at most 0.49 ms at p99, in the README.
+`TestTheGatewaysOverheadIsMeasured` runs a second of it in CI with no bound
+asserted. Left: the CPU figure is rough with everything in one process; a
+gateway in a process of its own would measure it properly. The original
+item follows.
+
+Bifrost's headline is "11 µs at 5k RPS" (its own figure, and its own pages
+disagree with it). llmgw has none, so any question about its overhead is
+answered with a guess.
+- `llmgw ctl bench --overhead`: the same load through the gateway and straight
+  at a `sim-engine` (`internal/cli/simengine.go`) that answers at once, at
+  rising request rates, with auth, accounting and the guardrails' pattern
+  checks on and off. Reports the added latency at p50/p99 and the gateway's
+  CPU per thousand requests.
+- On the PoC the CPU is oversubscribed (pve1, 28 threads for ~125 vCPUs):
+  report it as a ratio and record the host's load beside it, and repeat on
+  an idle machine before a figure goes into the README.
+- Done when: the README states the overhead, with how it was measured, and
+  CI runs the short version so a change that doubles it is seen.
+
+### I4. Several keys for one outside provider (S) — done 2026-10-17
+`external.api_key_files` (`catalog.ExternalKey`: file, weight), one endpoint
+each in `control.externalEndpoints`, 401 retried on another key and
+`external_key_refused` notified (`router.keyRefused`). With one key a 401 is
+still the client's. `TestAKeyAtItsLimitOrRefusedIsPassedOverForAnother`. The
+original item follows.
+
+An external model has one `api_key_file` (`internal/control/control.go`,
+where external endpoints are made). A provider's limit is per key; one key
+answering 429 makes the whole fallback answer 429.
+- `api_key_files: [a, b, c]`, each with an optional `weight`: one endpoint
+  per key (`external:<model>#<n>`), so the router's scoring, retries and
+  breakers work per key as they already do per replica. A key answering 429
+  or 401 is passed over while its breaker is open; a 401 also notifies
+  (`external_key_refused`).
+- The usage row says which key answered (by its index, never the key).
+- Done when: with two keys and one returning 429, every request is answered
+  by the other, and the console shows the one breaker open.
+
+## J. Found testing HA and single-machine installs (written 2026-10-16)
+
+Three VMs installed as HA from the setup screens, a fourth as a judge node,
+a fifth as a single 4-core, 8 GB machine; machines powered off under load.
+
+### J1. A restart refused for room another restart was giving back (S) — done 2026-10-16
+Not a wait for ever, as first written: on the 4-core VM the judge's restart
+was *refused* ("fits on no node even with this replica stopped") because the
+starter, restarted at the same time to reserve fewer cores, still held its
+old ones. Once refused, nothing tried again, so the judges kept their old
+figures. Two fixes in `internal/control/reconciler`:
+- a restart whose replacement fits once other restarts under way have gone
+  (queued, retiring or draining) waits for them, up to DrainGrace, instead
+  of being refused (`fitsAfterRestarts`, restart.go);
+- a drained replica counts a retiring one that still answers as serving, so
+  one restart after another no longer leaves the first's drained replica,
+  and the room it holds, waiting out its grace (reconciler.go).
+`TestARestartWaitsForRoomAnotherRestartWillGiveBack` is the 4-core case.
+
+### J2. A judge the leader adds is sized as init's is (S)
+When a policy names a judge the catalog lacks, the leader serves it itself
+(`internal/cli/judgekeeper.go` via `knownJudge.serveRequest` in
+`judges_known.go`, through modelserve). That judge reserves 3 GB (the
+weights, an 8192-token KV cache and a fixed gigabyte), no cores, and runs
+with llama.cpp's prompt cache, which grew one to 3.2 GB. init's judge
+(`guardModel` in `internal/cli/serverinit_cluster.go`) reserves 2 GB and
+its cores and runs with `--cache-ram 0`.
+- `modelserve` gives a guard model `--cache-ram 0`, and the keeper's
+  request the same memory and cores rule as `cpuPlan`.
+- Done when: a judge removed from the catalog comes back with the same
+  figures init would have given it.
+
+### J3. HA setup puts the judges on nodes of their own (S)
+Under load on a 4-core control plane that was also a node, 38 of 60
+requests were refused for want of a judgment. With the judges on a node of
+their own (4 cores, 32 GB, two cores each) the same test refused 2.
+- The HA setup offers a judge node or two: machines given like the store's,
+  added as nodes with a label (`llmgw.role: judge`), and the judge's
+  profile selects that label.
+- Done when: the setup installs the judges on the machines given for them,
+  and the load test above refuses no more than it did by hand.
+
+### J4. The model mirror on more than one machine (M)
+In an HA install the mirror stays on the first machine. While it is down,
+models the nodes already have keep serving and new ones wait for it.
+- A second mirror kept in step (each machine of the store, or one more), the
+  control planes and nodes given both, the first that answers used.
+- Done when: with the first machine powered off, a model added then is
+  fetched and served.
+
+### J5. An upgrade corrects an earlier install's judge (S) — done 2026-10-16
+Built in the judge keeper (`internal/cli/judgekeeper.go`, `refit`), on the
+leader: a judge whose entry is exactly what init before v0.14.7 wrote is
+given 2 GB, `--cache-ram 0` and cores by init's rule (`refitCores`: up to
+four for one judge, two each for more), through `modelsvc.SetProfiles`,
+and its ready replicas are restarted (after J1). Its replica count is left
+as it is. One that differs is left alone and said once in the log. The
+original item follows.
+
+v0.14.6 and earlier installed two judges reserving no cores or one, with
+2 or 4 GB and the prompt cache on. On fewer than eight cores every judgment
+missed its 5 s budget and every request was refused. v0.14.7's notes say
+how to fix it by hand (`ctl model resources`, then `ctl restart`).
+- On upgrade, or on `server init` run again, a judge whose profile is still
+  exactly what an earlier init wrote is moved to today's figures and
+  restarted (after J1). One changed by hand is left alone and named.
+- Done when: a v0.14.6 single-machine install upgraded to it judges within
+  budget without anything typed.
+
+### J6. Rate limits per process (note)
+Rate limits are counted in each control plane's memory. A failover starts
+every key's minute afresh. Documented in install.md; worth a shared count in
+the store only if a customer's limits must hold across a failover.
+
+### J7. nginx in front of several control planes (S)
+`deploy/proxy/Caddyfile` sends to whichever control plane answers `/leader`.
+nginx's open-source build has no active health checks, so its `upstream`
+block would send to standbys and to a lost leader alike.
+- nginx.conf: the floating address as its one upstream, and why; or the
+  `max_fails` passive approach with what it costs.
+
+### J8. A judge budget that fits the machine (S)
+A judgment takes 2.3 s on four cores and 4.2 on two, against the 5 s
+default: two cores are close to it, and a busy machine passes it.
+- At install, after the judge is up, time three judgments. If the slowest is
+  more than half the budget, say so in the plan's closing text with the
+  choices (more cores, a GPU judge, a longer `latency_budget`, `fail:
+  open`). The budget itself is not changed without being asked.
+- Done when: an install on a machine too slow for its judge says so before
+  its first refused request.

 ## D. Facts worth knowing before starting

- Admin API: `127.0.0.1:9090`, no auth, `ctlClient` in `internal/cli/ctl.go`.
+- Admin API: `127.0.0.1:9090`, behind the token in
+  `/var/lib/llmgw/admin-token` (A5), `ctlClient` in `internal/cli/ctl.go`.
  Metrics on `:9091` with `/prometheus/targets` beside them.
 - Store: `internal/store`, migrations under `internal/store/migrations/{sqlite,postgres}`;
  the PoC runs PostgreSQL under Patroni.
@@ -18,16 +18,153 @@ is only released once its **exit criterion** is met, not when its code lands.
 | v0.11.0 | — | High availability from setup, the setup and console screens, usage sums and per-tenant alerts | released |
 | v0.12.0 | — | The cluster's settings in the store, in force when changed; the firewall switch; wipe | released |
 | v0.13.0 | — | The whole system stopped and started from one command; Qwen3Guard judges, on a GPU and CPUs together | released |
-| v0.14.0 | — | Knowledge bases: documents from people's own machines, kept apart per tenant, answered from | released (v0.14.1: adapters, the tree over the API, the firewall on every machine; v0.14.2: pictures from ComfyUI; v0.14.3: 3D models as jobs) |
+| v0.14.0 | — | Knowledge bases: documents from people's own machines, kept apart per tenant, answered from | released (v0.14.1: adapters, the tree over the API, the firewall on every machine; v0.14.2: pictures from ComfyUI; v0.14.3: 3D models as jobs; v0.14.4: any ComfyUI workflow as a job, presets, licences; v0.14.5: picture and 3D models that add themselves; v0.14.6: setup that explains every part and lets it be chosen, the gateway on all three HA machines; v0.14.7: the judge sized for its machine; v0.14.8: sign-in with Active Directory, several keys for one outside provider) |
 | v1.0.0 | 5 | What phase 5 has left: precise KV routing proven on vLLM, the block cost picker, defragmentation across NVLink domains, prefill/decode disaggregation | planned |

 Until v1.0.0 the minor version is the breaking one: configuration formats and Go
 APIs change between minors without a deprecation period.

-## Unreleased
+## v0.14.8 — 2026-10-18
+
+Sign-in with an on-premises Active Directory, and Entra ID made safe for
+people in many groups. Also several keys for one outside provider, and a
+measure of what the gateway adds to a request.
+
+**Upgrading.**
+- Migration 0048 adds the `user_directory` table, applied when the control
+  plane starts.
+- Nothing changes until `auth.ldap` is set; docs/install.md, "Active
+  Directory", has an example. It has been tested against a fake directory,
+  not yet against a real domain controller.
+- A judge installed by an earlier `server init` is refitted by the leader
+  by itself (below); the steps given for v0.14.7 are no longer needed.

 ### Added

+- **Sign-in with Active Directory** (`auth.ldap`). People sign in on the gateway's form with their AD username or mail
+  and password, checked against the domain controllers over LDAPS or StartTLS. Groups, nested ones included, give
+  staff roles and places in the tree, as with OIDC. Accounts are tied to the `objectGUID` and made at first sign-in
+  when `create_accounts` is on. Every 15 minutes the leader reads the directory. People disabled or deleted there are
+  suspended and reinstated when they come back; roles and memberships follow their groups. A sync that would suspend
+  more than half the accounts is refused. See docs/install.md, "Active Directory".
+
+- **Several keys for one outside provider.** An external model takes `api_key_files`, each with an optional weight, in
+  place of `api_key_file`. Each key is an endpoint of its own (`external:MODEL#1`, `#2`), so a key answering 429 is
+  passed over while its breaker is open and the request goes to another. A key answering 401 is passed over too, and
+  `external_key_refused` is sent, naming the endpoint, never the key. Usage records which key answered by that name.
+
+- **`llmgw ctl bench overhead`**: what the gateway adds to a request, measured against an engine that answers at
+  once. Gateway and engine run in one process on loopback, so no cluster is needed. The load is sent straight to the
+  engine and through the gateway: bare, with authentication and accounting, and with the guardrails' pattern checks.
+  It reports p50 and p99 latency, what the gateway added, and a rough CPU per thousand requests. On an Apple M5 the
+  gateway added 0.05–0.42 ms at p50 and at most 0.49 ms at p99 (README).
+
+### Fixed
+
+- **Entra ID's groups past 200 no longer take a role away.** For someone in more than 200 groups Entra sends none in
+  the token, only a pointer to Graph. That was read as no groups, so an administrator lost their role at the next
+  sign-in. Their role and memberships are now left as they were, and an error is logged saying what to change in the app
+  registration. docs/install.md has an Entra ID section.
+- **An account made by SCIM or OIDC could not be reinstated.** Setting it active was refused as "never approved".
+- **An upgrade refits the judge an earlier `server init` installed.** Upgrading to v0.14.7 left such a judge as it was:
+  no cores or one, 2 or 4 GB, the prompt cache on. On fewer than eight cores every request was refused until it was
+  fixed by hand. Now the leader finds a judge whose entry is exactly what an earlier init wrote and gives it 2 GB, no
+  prompt cache and cores by today's rule (up to four for one judge, two each for more). It then restarts the judge's
+  replicas onto that. The number of replicas is left as it is. A judge whose entry was changed by hand is left alone,
+  and the log says so once.
+- **A restart is no longer refused for room another restart is giving back.** With every core of a node reserved, two
+  models restarted together, one to need more and one less (as after `ctl model resources` on a judge and a starter),
+  had the first refused: "fits on no node even with this replica stopped", though the second was about to give back
+  its cores. A restart now waits for other restarts under way, up to the drain grace, before it is refused. A drained
+  replica also counts a replica being restarted that still answers as serving, so replicas restarted one after
+  another no longer wait out the five-minute grace each.
+
+## v0.14.7 — 2026-10-16
+
+The judge installed by `server init` sized for what it does. On a machine
+of fewer than eight cores v0.14.6 left every judgment past its budget, so
+`fail: closed` refused every request. A single-machine install of v0.14.7
+on a 4-core VM passed 20 of 20, and on 8 cores 20 of 20 under load.
+
+**Upgrading.**
+- No migration.
+- **Upgrading does not change a judge already in the catalog.** v0.14.6
+  and earlier installed two judges, reserving no cores or one, and 2 or
+  4 GB. To give them what they need:
+  `llmgw ctl model resources qwen3guard-0.6b --memory 2 --cores 2`, then
+  `llmgw ctl restart --model qwen3guard-0.6b`. The two then need four cores
+  on a single machine; below that, a longer `latency_budget` or
+  `fail: open`.
+- On a node whose cores are all reserved, `ctl restart --model` cannot
+  start the new replica beside the old one and waits. Stop the old engine
+  process, and the replica comes back with the new figures.
+
+### Fixed
+
+- **Both judges fit an 8 GB machine again.** v0.14.6 had `server init` reserve 4 GB a judge replica. That figure came
+  from one replica at 3.2 GB after a day of traffic. The growth was llama.cpp's prompt cache, up to 8 GB by default,
+  which a judge never reuses: each text it reads is different. On a 4-core, 8 GB machine the second judge then fitted
+  nowhere ("has 7 GB of memory with 1 free, needs 4"). The judge now runs with `--cache-ram 0`, uses about 1.6 GB and
+  stays there, and reserves 2.
+- **One machine runs one judge, on up to four cores.** A second replica on the same machine shares its cores and is
+  lost with it, so it bought nothing but half the speed of each. `server init` on a single machine now serves one judge
+  on up to four cores (2.3 s a judgment where two on two cores took 4.2). Where there will be other nodes, it serves two
+  on two cores each, as in HA setups. `--judge-replicas` and the setup's Copies still choose.
+- **A judge gets the two cores it needs.** v0.14.6 gave each judge replica one core on machines under eight. A judgment
+  of about 280 tokens takes 8.0 s on one core, 4.2 s on two and 2.3 s on four, against the 5 s budget, so on a 4-core
+  machine every judgment timed out and every request was refused. Where there are two judges, each now reserves two
+  cores (one only below four CPUs), and the one judge of a single machine up to four; the starter has what is left, or
+  shares when nothing is. A judge on two cores stays close to its budget: give it more cores or a GPU, or raise
+  `latency_budget`, where requests must not wait.
+
+## v0.14.6 — 2026-10-16
+
+Setup that says what each part of an install is and lets every one be
+chosen and set; three machines that each run the gateway, so any one can
+be lost; a cluster that loses its store's primary without losing a
+request; one ComfyUI for an environment's models; pictures, 3D and
+workflows as MCP tools; alerts asked for at setup; extended thinking.
+
+**Upgrading.**
+- No migration.
+- **Control planes**: with `control.lease_ttl` unset the lease is now 10 s
+  (was 15). Upgrade the standbys first and the leader last; a mix of
+  versions meanwhile is fine.
+- **The store** (PostgreSQL): each member is dialled for 3 s before the
+  next is tried. A store so far away that connecting takes longer needs
+  `connect_timeout=10` in its address.
+- **Nodes** notice a control plane that died without closing its
+  connection in 8 s (was 15) once they run this release.
+- **Judges installed by an earlier `server init`** keep reserving no cores
+  and 2 GB. To give them their own:
+  `llmgw ctl model resources qwen3guard-0.6b --memory 4 --cores 2`, then
+  `llmgw ctl restart --model qwen3guard-0.6b`.
+- **Patroni** replaces a lost primary within 20 s on a new cluster. On an
+  existing one, run `server init --patroni ...` again from the machine with
+  the authority; it changes only that.
+- **A floating address** keeps VRRP router id 51 until `server add --vip`
+  runs again, which moves it to one of its own; run it for every standby.
+- A request whose judge is not there yet waits up to the policy's
+  `latency_budget` for one before `fail: closed` refuses it.
+
+### Added
+
+- **Setup lets every part be chosen, each with its settings, and says what each is.** `sudo llmgw` on a new machine lists
+  the parts of an install: the control plane, the store, the model mirror, this machine as a node, the starter model,
+  pictures and 3D, the guardrails' judge, the firewall, notifications, limits and keys, on-demand turns, an offline
+  bundle. Beside each is what it will be or what is missing without it. Space turns a part on or off, and Enter opens
+  its settings in a dialog that explains it at more length. The settings are: which starter model (six Qwen sizes, or
+  any GGUF on Hugging Face) and its context; the mirror's directory or another machine's mirror; the judge's
+  categories, copies, wait and what happens when it does not answer; the portal's language; the sign-up form; the
+  default limits; the longest a key lives; the on-demand waits. A plan page then lists what is installed and what is
+  left out, with the same install as a command. Every setting is a `server init` flag too (`--starter`,
+  `--judge-fail`, `--media`, `--max-key-ttl`, ...).
+- **Three machines are high availability for the gateway, not only the store.** With three machines, setup makes the two
+  database machines control planes too, standing by while the first leads, with an optional floating address
+  (keepalived) that follows whichever leads. Any one machine can now be lost. By command: `server init --patroni ...
+  --standbys --vip 10.0.0.160/24`. The mirror's management API answers the three control planes, so a standby that
+  comes to lead can still fetch models.
+
 - **Pictures uploaded to work from**: `/v1/files` takes `purpose=vision` or
  `user_data` besides `batch`, kept as long as job results, so a picture is
  sent once and named by its `file-…` id in the MCP tools and a workflow's
@@ -71,6 +208,42 @@ APIs change between minors without a deprecation period.

 ### Fixed

+- **The judges and the starter model divide a machine's CPUs instead of each taking all of them.** `server init` gave the
+  judge and the starter no cores of their own, so every llama.cpp engine ran on every core: two judges and the starter
+  on a 4-core control plane competed, and under load 38 of 60 requests were refused for want of a judgment. Moved to a
+  node of their own with 2 cores each, the same test refused 2. When this machine is the node, init now gives each judge
+  replica 1 core (2 from 8 cores) and the starter what is left (at most 8); judges bound for other nodes get 2 each. A
+  judge also reserves 4 GB, not 2: it uses about 3.2.
+
+- **A lost store machine stops costing requests most of a minute.** The store's connections try each member for 3 seconds,
+  not until the kernel gives up, and a connection to a machine that is gone is closed within about 10 seconds (TCP
+  keepalive, and `TCP_USER_TIMEOUT` on Linux). Patroni replaces a lost primary within 20 seconds (`ttl` 20, `loop_wait`
+  5, `retry_timeout` 5). Running `server init --patroni` again applies this to an existing cluster. Measured on three
+  VMs with the primary's power cut: about 45 seconds of hanging requests before.
+- **Leadership stays put while the store's primary is replaced.** Replacing a lost primary takes longer than the
+  leadership lease lives, so the lease had lapsed for everyone by the time the store answered again. Whoever asked first
+  took it, as often a standby as the leader. A standby that saw the store out of reach now leaves the lease alone for one
+  round after it returns, so the leader renews it, and a leader that is truly gone is replaced a round later. With that,
+  the default lease is 10 seconds (was 15). A node notices a control plane that died without closing its connection in
+  8 seconds (was 15), so it is on its way to the new leader as that one takes over.
+- **A judge replica that hangs no longer costs the request.** All the tries of a judge request shared the policy's
+  budget, so a replica that hung used it all and the try on another replica had none left: under `fail: closed` the
+  request was refused while a judge stood idle. When the first replica has not answered by half the budget, the same
+  question now goes to a replica on another machine too, and the first answer is taken. The first replica is not cut
+  short, which on a slow machine would refuse answers it was about to give. Replicas on one machine whose CPUs are taken
+  are slow together, so asking both only doubles the work there: measured that way, as many requests failed as before.
+  On such a machine the remedy is room, not a second question: judges on more than one node, more cores, or the judge
+  on a GPU.
+- **A new leader waits for the judge instead of refusing at once.** The moment a control plane takes the lead it knows no
+  judge yet. When every judge fails at once, they are asked again every 250 ms while the policy's `latency_budget` lasts,
+  so `fail: closed` no longer answers every request in those seconds with 503 (about 17 seconds of them in the test). A
+  judge that is slow is not asked again, and an alarm is raised once per request, not once per try.
+
+- Node discovery for Prometheus listed only the control plane asked and the
+  store, so a machine that is both was a control plane to one and a store
+  member to the other — scraped twice — and a standby asked alone lost every
+  node. Every control plane lists all of them alike; deploy/monitoring's
+  prometheus.yml says to scrape and ask each.
 - A model whose weights and context pool did not fit its card was added
  and then failed to make its context on every start, taking the card from
  others each time (Apertus 70B with a 65536-token pool, 8B with 131072, on
@@ -40,7 +40,7 @@ Releases track the roadmap phases; see [CHANGELOG.md](CHANGELOG.md).
 | v0.11.0 | — | High availability from setup, the setup and console screens, usage sums and per-tenant alerts | released |
 | v0.12.0 | — | The cluster's settings in the store, in force when changed; the firewall switch; wipe | released |
 | v0.13.0 | — | The whole system stopped and started from one command; Qwen3Guard judges, on a GPU and CPUs together | released |
-| v0.14.0 | — | Knowledge bases: documents from people's own machines, kept apart per tenant, answered from | released (v0.14.1: adapters, the tree over the API, the firewall on every machine; v0.14.2: pictures from ComfyUI; v0.14.3: 3D models as jobs; v0.14.4: any ComfyUI workflow as a job, presets, licences; v0.14.5: picture and 3D models that add themselves) |
+| v0.14.0 | — | Knowledge bases: documents from people's own machines, kept apart per tenant, answered from | released (v0.14.1: adapters, the tree over the API, the firewall on every machine; v0.14.2: pictures from ComfyUI; v0.14.3: 3D models as jobs; v0.14.4: any ComfyUI workflow as a job, presets, licences; v0.14.5: picture and 3D models that add themselves; v0.14.6: setup that explains every part and lets it be chosen, the gateway on all three HA machines; v0.14.7: the judge sized for its machine; v0.14.8: sign-in with Active Directory, several keys for one outside provider) |
 | v1.0.0 | 5 | What phase 5 has left: precise KV routing proven on vLLM, the block cost picker, defragmentation across NVLink domains, prefill/decode disaggregation | planned |

 As of v0.6.0 a cluster runs unattended: agents report their hardware, the
@@ -50,6 +50,17 @@ budgets and rate limits decide who may use any of it.

 Since v0.11.0 (each release's detail is in [CHANGELOG.md](CHANGELOG.md)):

+- **Setup that explains, and high availability that is whole** (v0.14.6).
+  `sudo llmgw` lists the parts of an install, each with what it is for and
+  what is missing without it, and every one can be turned off or set: the
+  starter model and its context, the mirror's directory, the judge's
+  categories and what it does when it does not answer, limits, the
+  portal's language, pictures and 3D. With three machines each runs the
+  control plane, with a floating address on the leader, and any one can
+  be lost: on three VMs, cutting the store primary's power lost no
+  request. One ComfyUI serves an environment's models, pictures, 3D and
+  workflows are MCP tools, and `/v1/messages` gives a model's reasoning as
+  thinking blocks.
 - **Picture and 3D models that add themselves** (v0.14.5). Where a node's
  card fits flux-schnell or triposr and the catalog makes nothing of that
  kind, the leader adds it on demand, so a new cluster's portal has its
@@ -246,6 +257,33 @@ Add `--json` to any command for machine-readable output.
 says nothing about which of six constraints bit, so it prints every candidate
 considered and the reason it was rejected.

+## What llmgw adds to a request
+
+Measured with `llmgw ctl bench overhead`. It starts an engine that answers
+at once and a gateway in front of it, in one process on loopback. It sends
+the same load straight to the engine and through the gateway, and reports
+what the gateway added. Run on an Apple M5 (10 CPUs, load about 2) on
+2026-10-16, 10 s a step, 72,000 requests with none failed:
+
+| Through the gateway | added at p50 | added at p99 |
+|---|---|---|
+| bare | 0.06–0.24 ms | 0.10–0.33 ms |
+| with authentication and usage accounting | 0.05–0.32 ms | 0.09–0.37 ms |
+| with the guardrails' pattern checks as well | 0.10–0.42 ms | 0.15–0.49 ms |
+
+The range is across 100 to 2,000 requests a second. The overhead was
+*lowest* at 2,000, most likely because a busier processor keeps its cores
+awake. The guardrails' judge model is not in these figures: a judgment
+takes seconds on CPUs (see [install.md](docs/install.md)) and is a model's
+time, not the gateway's.
+
+The command also prints the gateway's CPU per thousand requests. Gateway,
+engine and load share one process there, so that figure is rough (0.04 to
+0.65 s per thousand in the run above); the latency is the one to quote.
+Figures from a VM on a busy host move with the host: run it where you will
+deploy, and keep the load it prints beside the result. CI runs a one-second
+version on every change (`TestTheGatewaysOverheadIsMeasured`).
+
 ## Running the router

 ```sh
@@ -1,4 +1,4 @@
-# Two control planes
+# More than one control plane

 llmgw handles the hard half of this itself: only one control plane places work,
 and agents find whichever one is leading. What it does not do is move client
@@ -37,7 +37,7 @@ nothing in front of the two had moved.
 So something has to. The options, in the order most people should consider
 them:

-**A load balancer you already run.** Health-check `/ready` on each control
+**A load balancer you already run.** Health-check `/leader` on each control
 plane and send traffic to whichever answers. This is the right answer if you
 have one, and it needs nothing else from this directory.

@@ -50,25 +50,50 @@ in whatever your resolvers actually honour rather than what you set, which on
 a bad day is minutes. Fine for a cluster people use interactively, wrong for
 one an agent is driving.

-## Check `/ready`, not `/health`
+## Check `/leader`, not `/health`

 This is the one thing to get right, and the obvious choice is the wrong one.

-`/health` says the process is up. It says nothing about whether it can serve,
+`/health` says the process is up. It says nothing about whether it leads,
 and a standby is exactly that case: alive, answering, and holding no endpoints
 at all — its reconciler placed nothing and it has no agent streams to adopt
-from. A load balancer checking `/health` would send it half the traffic, and
-half the traffic would be a 503.
+from. A standby passes client requests on to the leader, so traffic sent to
+one still works — until the leader is the machine that was lost, and there
+is nobody to pass them to.
+
+`/leader` is 200 on the control plane that leads and 503 on a standby. It is
+what keepalived follows for the floating address, and what a load balancer
+should send traffic by: to the one machine that answers 200.
+
+`/ready` is narrower: 200 only when this process has somewhere to send a
+request, so 503 on a standby and also on a leader with no model running yet.
+Checking it takes the portal and the admin pages away with the models — on a
+new cluster with no node yet, nobody can sign in to add one. Use it to stop
+sending inference only, if your load balancer can tell the paths apart.

-`/ready` says this process has somewhere to send a request. It is 503 on a
-standby, 503 on a leader whose replicas have all failed, and 200 when there is
-something to serve — which is the question a load balancer is actually asking.
 Both are open, because a load balancer has no key.

-During a failover neither passes for about the length of the lease handover:
+During a failover nothing passes for about the length of the lease handover:
 three seconds when the leader is stopped cleanly, up to the lease TTL when it
-is not. That gap is real and there is no way to have it both ways — traffic
-cannot go to a control plane that has nothing to route to.
+is not. A proxy that waits that long for a healthy machine rather than
+failing at once (Caddy's `lb_try_duration`) hides it from clients.
+
+**Caddy**, in front of three control planes — the end of
+[deploy/proxy/Caddyfile](../proxy/Caddyfile) has it with the rest of the
+settings:
+
+```
+reverse_proxy 10.0.0.157:8080 10.0.0.158:8080 10.0.0.159:8080 {
+	lb_policy first
+	health_uri /leader
+	health_interval 2s
+	lb_try_duration 15s
+	flush_interval -1
+}
+```
+
+With a floating address the address already follows the leader: give Caddy
+that one address instead.

 Not the admin port, for a different reason: it serves pprof, and pprof can
 dump the process heap, where API keys sit in plaintext.
@@ -41,7 +41,9 @@ vrrp_instance llmgw {
    # MASTER on the machine you would rather serve; BACKUP on the other.
    state MASTER
    interface eth0
-    # Any number both machines agree on and nothing else on the segment uses.
+    # Any number both machines agree on and nothing else on the segment uses:
+    # another cluster's keepalived with the same one reads as an invalid
+    # password. `llmgw server add --vip` derives one from the address.
    virtual_router_id 51
    # The higher one wins while both are healthy. The weight above is enough
    # to invert this when the preferred machine's gateway is not answering.
@@ -21,11 +21,18 @@ scrape_configs:
  # The control plane's dedicated metrics port. Not its admin listener: that one
  # is loopback because it also serves pprof, and pprof can dump the heap where
  # API keys sit in plaintext.
+  #
+  # Every control plane, one line each: the leader moves on restarts and the
+  # router's metrics are the leading one's, so scraping one alone leaves gaps
+  # — and alerts on them — whenever another leads.
  - job_name: llmgw
    static_configs:
      - targets: ['10.0.0.140:9091']
        labels:
-          instance: control-plane
+          instance: control-plane-140
+      # - targets: ['10.0.0.150:9091']
+      #   labels:
+      #     instance: control-plane-150

  # Every machine of the cluster, for its node exporter: network and disk
  # traffic, filesystems, CPU time. The control plane lists them — nodes,
@@ -33,10 +40,15 @@ scrape_configs:
  # nothing edited here, and each carries its llmgw id as the node label.
  # `llmgw node add` installs the exporter; on a machine added before that,
  # apt-get install prometheus-node-exporter.
+  # Asked of every control plane too: a standby lists only the control
+  # planes and the store, and they label every machine alike, so the same
+  # target from two of them is scraped once.
  - job_name: nodes
    http_sd_configs:
      - url: http://10.0.0.140:9091/prometheus/targets
        refresh_interval: 1m
+      # - url: http://10.0.0.150:9091/prometheus/targets
+      #   refresh_interval: 1m

  - job_name: prometheus
    static_configs:
@@ -14,6 +14,7 @@ llm.example.com {
 		max_size 32MB
 	}

+	# One control plane. With more than one, see the end of this file.
 	reverse_proxy 127.0.0.1:8080 {
 		# Tokens are written the moment they are generated. Without this a
 		# streamed reply can arrive in bursts, and a client measuring time to
@@ -39,3 +40,36 @@ llm.example.com {
 	# Access log to stderr, which under systemd is the journal.
 	log
 }
+
+# More than one control plane (server init --standbys, server add): one of
+# them leads, the others stand by. Name them all and send to the one that
+# leads — /leader is 200 there and 503 on a standby. Not /ready: that is 503
+# on a leader with no model running yet, and would take the portal away with
+# it. A standby would pass a request on to the leader anyway, but not while
+# there is none, and the hop is for nothing.
+#
+# With a floating address (--vip) the address already follows the leader:
+# give reverse_proxy that one address instead, and keep the rest as above.
+#
+# llm.example.com {
+# 	request_body {
+# 		max_size 32MB
+# 	}
+# 	reverse_proxy 10.0.0.157:8080 10.0.0.158:8080 10.0.0.159:8080 {
+# 		# The first that is healthy: the leader, whichever it is.
+# 		lb_policy first
+# 		health_uri /leader
+# 		health_interval 2s
+# 		health_timeout 2s
+# 		# While leadership moves — a few seconds when a leader is lost —
+# 		# none is healthy; a request waits that long for one rather than
+# 		# failing at once.
+# 		lb_try_duration 15s
+# 		lb_try_interval 250ms
+# 		flush_interval -1
+# 		transport http {
+# 			response_header_timeout 15m
+# 		}
+# 	}
+# 	log
+# }
@@ -9054,6 +9054,13 @@
            "type": "string",
            "description": "APIKeyFile holds the provider's key, on the control plane. A file rather than the key itself, so the key is in neither the catalog, the store nor the audit log; empty for a provider that asks for none."
          },
+          "api_key_files": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/catalog.ExternalKey"
+            },
+            "description": "APIKeyFiles are several keys for the provider, in place of APIKeyFile: one endpoint each (external:MODEL#1, #2…), so a key that answers 429 or 401 is passed over while its breaker is open and the request goes to another. A provider's limits are per key."
+          },
          "peer": {
            "type": "string",
            "description": "Peer names the federated llmgw cluster this model is offered by, for a model that federation added (`llmgw ctl federation add`) rather than one written by hand. Such a model is named PEER/MODEL, comes and goes with the peer's own list, and is sent only while the peer is up."
@@ -9072,6 +9079,20 @@
          }
        }
      },
+      "catalog.ExternalKey": {
+        "type": "object",
+        "description": "ExternalKey is one of a provider's keys.",
+        "properties": {
+          "file": {
+            "type": "string",
+            "description": "File holds the key, on the control plane, as APIKeyFile does."
+          },
+          "weight": {
+            "type": "number",
+            "description": "Weight is its share of the requests against the others'; zero is 1."
+          }
+        }
+      },
      "catalog.GPUNeed": {
        "type": "object",
        "description": "GPUNeed is what card a profile needs.",
@@ -89,13 +89,36 @@ CGO_ENABLED=0 go build -o llmgw ./cmd/llmgw

 **The short way is the screens.** On the machine that will be the control
 plane, run `sudo llmgw` with nothing after it. With nothing installed it asks
-whether this is one machine or three for high availability; for three, it asks
-for the other two — address, user, and an ssh key, the ssh agent, or a
-password, and the sudo password if sudo asks for one; or, for a machine
-nothing may log into, a join code to run there with `sudo llmgw join <code>`,
-which dials out to this one on port 7444 — checks all three before
-installing anything (system, room, clock, ports, internet, whether they reach
-one another), shows the plan, and installs. Passwords are held in memory for
+whether this is one machine or three for high availability, then lists what
+an install is made of, each part with what it is for and what is missing
+without it:
+
+| Part | | Its settings (Enter) |
+|---|---|---|
+| Control plane | always | the administrator, other names for the certificate, the portal's language, the sign-up form |
+| Store | always | SQLite or PostgreSQL on this machine; with three machines, PostgreSQL under Patroni on the other two |
+| Control plane on all three | three machines, on | a floating address for whichever leads |
+| Model mirror | on | here, and in which directory, or on another machine |
+| This machine as a node | on for one machine | |
+| Starter model | on for one machine | which: Qwen2.5 0.5B, 1.5B or 3B, Qwen3 4B, 8B or 14B, or any GGUF on Hugging Face; its context |
+| Pictures and 3D | off | |
+| Guardrails' judge | on | refuse or serve flagged when it does not answer; copies; how long it is waited for; what it refuses |
+| Firewall | on | |
+| Notifications | off | the webhooks |
+| Limits and keys | always | requests and tokens a minute; the longest a key lives |
+| Taking turns on a card | always | how long an on-demand model goes unused, and is safe after loading |
+| Offline bundle | off | the bundle and its sha256 |
+
+Space turns a part on or off; Enter opens its settings, which say more. What
+cannot go together is said before anything is done — a starter model with no
+mirror to fetch it into — and closing the message opens the setting that is
+wrong. For three machines it then asks for the other two — address, user, and
+an ssh key, the ssh agent, or a password, and the sudo password if sudo asks
+for one; or, for a machine nothing may log into, a join code to run there
+with `sudo llmgw join <code>`, which dials out to this one on port 7444 —
+checks all three before installing anything (system, room, clock, ports,
+internet, whether they reach one another). Last it shows the plan, part by
+part, what is left out and what that costs, and installs. Passwords are held in memory for
 the run only; a sudo password lets the user sudo without one until the install
 finishes, and is then taken back. At the end it shows the administrator's
 password and the command that does the same from a script.
@@ -129,15 +152,24 @@ That is the whole step. In order, it:
   `nvidia-smi` finds any, on CPU otherwise — and waits for it to install its
   engine
 9. closes llmgw's internal ports to everything but the cluster's networks
-10. fetches Qwen3Guard-Gen 0.6B, the guardrails' judge, and runs two
-    replicas on the CPUs of nodes with room — this one, or the first that
-    join ([guardrails.md](guardrails.md#a-judge-model) has one on a GPU too)
+10. fetches Qwen3Guard-Gen 0.6B, the guardrails' judge, and runs it on
+    CPUs: one replica on up to four cores when this machine is the only
+    node, two on two cores each on the nodes of a larger cluster ([guardrails.md](guardrails.md#a-judge-model) has one on a GPU too)
 11. fetches Qwen2.5 0.5B into the mirror and serves it on this node, so the
    first thing anyone opens `/chat` to find is a model that answers. A
    machine without room for it is told so within two minutes, and why.

 `--no-mirror` and `--no-node` leave out 7 and 8, `--no-firewall` 9,
-`--no-guard-model` 10 and `--no-model` 11. An NVIDIA card with no working
+`--no-guard-model` 10 and `--no-model` 11. Every setting the screens ask for
+is a flag too, and the plan shows the command with them: `--starter qwen3-8b`
+(or `hf:<owner>/<repo>/<file>.gguf`) and `--starter-context`, `--mirror-dir`,
+`--judge-fail open`, `--judge-categories`, `--judge-replicas`,
+`--judge-budget`, `--language tr`, `--signup-open`, `--default-rpm`,
+`--default-tpm`, `--max-key-ttl`, `--media` (pictures and 3D: ComfyUI on the
+nodes, and `presets.auto`), `--evict-after-idle` and `--min-lifetime`. They
+go into `server.yaml` as init writes it, and become the cluster's first
+settings when it starts; a `server.yaml` already there is never overwritten,
+so run again they change nothing — the settings page does. An NVIDIA card with no working
 driver is reported rather than silently ignored; install the driver and run
 init again to serve on it.

@@ -155,15 +187,19 @@ demonstration one:
 | Requests | every key limited (60 a minute, 200 000 tokens a minute) and priced, so budgets bind |
 | Guardrails | the `baseline` policy on every request: secrets in prompts and answers refused, card numbers masked, injection attempts recorded, and the judge refusing violence, crime, weapons, child abuse, privacy violations, hate, self-harm and sexual content, in prompts and answers |

-The judge runs as two replicas, each on a CPU — about half a second for a
-short text on any CPU with AVX2 — and reads a streamed answer every 600
-characters. The policy fails **closed**: a request the judge cannot read
-within 5 seconds is refused with 503 rather than served unjudged, and
-`judge_unavailable` goes to the notification webhooks. Two replicas are what
-make that bearable; on one small machine, or a VM without AVX2 (see
+The judge runs on CPUs. A judgment of about 280 tokens took 2.3 s on four
+cores, 4.2 s on two and 8.0 s on one (a 4-core VM). It also reads a
+streamed answer every 600 characters. The policy fails **closed**: a request
+the judge cannot read within 5 seconds is refused with 503 rather than
+served unjudged, and `judge_unavailable` goes to the notification webhooks.
+So a judge gets cores of its own: on one machine one replica on up to four,
+and on a larger cluster two replicas of two cores each, spread over its nodes
+so that losing one leaves the other. On a machine of fewer than four cores,
+a busy one, or a VM without AVX2 (see
 [step 6](#6-setting-the-nodes-cpu-model-if-it-is-a-vm)), the judge is the
-first thing to fail, so `fail: open` — serve it, recorded as flagged — or
-`--no-guard-model` is the choice there. Defamation, specialized advice,
+first thing to fail. The choices there are a longer `latency_budget`,
+`fail: open` (serve the request, recorded as flagged), the judge on a GPU,
+or `--no-guard-model`. Defamation, specialized advice,
 intellectual property and elections are left out of what it refuses: they
 catch too much ordinary work. [guardrails.md](guardrails.md) has the rest.

@@ -1287,6 +1323,26 @@ catalog, and a key rotated in the file is used within seconds. A model whose key
 file cannot be read is not offered. Everything else applies as to any model:
 prices and budgets, rate limits, usage records, and key allowlists.

+A provider's limits are per key. With several keys, one answering 429 need not
+hold up the model: give them all, each with an optional weight (its share
+against the others'), in place of `api_key_file`:
+
+```yaml
+  external:
+    url: https://api.openai.com
+    model: gpt-4o-mini
+    api_key_files:
+      - {file: /etc/llmgw/secrets/openai-1.key, weight: 2}
+      - {file: /etc/llmgw/secrets/openai-2.key}
+```
+
+Each key is an endpoint of its own, `external:cloud-mini#1`, `#2`. A key that
+answers 429 is passed over while its breaker is open, and the request goes to
+another. One that answers 401 (revoked, expired, mistyped) is passed over too,
+and `external_key_refused` goes to the notification webhooks, naming the
+endpoint and never the key. The usage records say which key answered by the
+same name. A key whose file cannot be read is left out, and the others stay.
+
 **Its prompts leave the cluster.** Decide who may send them: a key or project
 whose allowlist leaves the external model out cannot reach it, as a fallback or
 by name. The cluster page and `ctl models` mark it `external`.
@@ -2319,6 +2375,33 @@ Without authentication, `threads.store` and `threads.retain_hours` in
 `server.yaml` keep both conversations and notes in one shared pool. That is for
 one trusted machine only; see [development.md](development.md).

+## Three machines, each a control plane
+
+The screens' three machines are high availability for the gateway as well as
+the store: the two database machines are made control planes too, standing
+by while the first leads — what `server add`, below, does for one machine.
+By command, `--standbys` with `--patroni`, and `--vip` for the floating
+address:
+
+```
+sudo --preserve-env=SSH_AUTH_SOCK llmgw server init --admin you@example.com \
+    --patroni ubuntu@10.0.0.6 --patroni ubuntu@10.0.0.7 \
+    --standbys --vip 10.0.0.160/24 --no-node --no-model
+```
+
+| Machine | Runs |
+|---|---|
+| the first | control plane, leading at first; model mirror; etcd |
+| the other two | control plane, standing by; PostgreSQL under Patroni; etcd |
+
+etcd votes on all three and PostgreSQL is on two, so any one machine can be
+lost: a standby leads within seconds, Patroni promotes the standby database
+if it was the primary, and the floating address follows whichever leads. The
+mirror's management API answers the three control planes' addresses, not
+only its own machine's, so a standby that comes to lead can still fetch and
+add models. The mirror itself stays on the first machine: while it is down,
+models the nodes already have keep serving, and new ones wait for it.
+
 ## Two control planes

 Once the store is replicated (`server init --patroni`, above), one command on
@@ -2335,8 +2418,12 @@ and lets it into the store; it starts there as a standby. Every node is told
 of it within half a minute and fails over to it without being touched.
 `--vip` keeps a floating address on whichever control plane leads, with
 keepalived on both: that is the address to give clients, or a proxy in front.
-Without it, put a load balancer in front that checks `/ready` — not
-`/health`, which is 200 on a standby that would refuse every request.
+Without it, put a proxy in front that sends to whichever answers `/leader`
+with 200 — not `/health`, which is 200 on a standby too, and not `/ready`,
+which is 503 on a leader with no model yet and would take the portal away
+with it. The end of [deploy/proxy/Caddyfile](../deploy/proxy/Caddyfile) has
+Caddy doing that for three control planes, and
+[deploy/ha/](../deploy/ha/README.md#check-leader-not-health) why.

 - **What a failover costs.** Measured on the reference cluster, stopping the
  leader: the standby led within five seconds, every node had moved to it
@@ -2454,6 +2541,82 @@ and point it at `https://<gateway>/scim/v2` with that token as the bearer.
  join and leave them. Membership in a group is removed when someone leaves
  it.

+### Entra ID
+
+Entra ID is an OpenID Connect provider like the others, with two things to
+set in the app registration:
+
+1. **Redirect URI:** under Authentication, add a Web platform with
+   `https://<gateway>/login/oidc/callback`. The issuer is
+   `https://login.microsoftonline.com/<tenant-id>/v2.0`.
+2. **Groups in the token:** under Token configuration, add a groups claim.
+   Choose **Groups assigned to the application**, and assign the groups you
+   map in `roles` and `memberships` to the enterprise application. Entra
+   sends groups by object id unless you choose to emit names
+   (`sAMAccountName` for groups synced from AD), so write them the same way
+   in the mapping.
+
+Entra leaves the groups out of the token for someone in more than 200 of
+them and sends a pointer to Graph instead. llmgw then keeps that person's
+role and memberships as they were, rather than reading it as no groups, and
+logs an error saying so. "Groups assigned to the application" avoids this.
+So does SCIM below, which Entra also speaks: in the enterprise application
+under Provisioning, set the tenant URL to `https://<gateway>/scim/v2` and
+the secret token to the contents of `auth.scim.token_file`.
+
+## Active Directory
+
+With an on-premises Active Directory, people sign in on the gateway's own
+form with their AD username (`ada`, `CORP\ada`, `ada@corp.example`) and
+password. The gateway checks them with the domain controllers over LDAPS:
+
+```yaml
+auth:
+  enabled: true
+  ldap:
+    urls: [ldaps://dc1.corp.example, ldaps://dc2.corp.example]   # tried in order
+    ca_file: /etc/llmgw/corp-ca.pem         # the domain's CA, when not in the system's
+    bind_dn: CN=svc-llmgw,OU=Service,DC=corp,DC=example
+    bind_password_file: /etc/llmgw/secrets/ldap-bind   # root-only
+    base_dn: OU=Staff,DC=corp,DC=example    # where people are
+    user_filter: (memberOf:1.2.840.113556.1.4.1941:=CN=llmgw-users,OU=Groups,DC=corp,DC=example)
+    label: Acme                             # "Sign in with your Acme account"
+    create_accounts: true
+    roles:                                  # by group CN or full DN; nested groups count
+      admin: [llmgw-admins]
+      operator: [llmgw-ops]
+    memberships:
+      ml-engineers: "team:Acme/ml"
+    sync_interval: 15m                      # negative turns the sync off
+```
+
+- **Service account:** an ordinary domain user is enough: it only reads.
+  It finds the person and reads their groups. The person's password is
+  checked by binding as them, and is never stored.
+- **Encryption:** `ldaps://`, or `ldap://` with `start_tls: true`.
+  Plaintext LDAP is refused, since passwords would cross the network.
+- **Who may sign in:** enabled user objects under `base_dn` that match
+  `user_filter`. The example admits members of `llmgw-users`, nested groups
+  included.
+- **Accounts:** an account is tied to the person's `objectGUID`, so a changed
+  mail or name is still the same account. An account that already exists
+  with the person's mail is taken over. Without `create_accounts`, only
+  people who already have an account can sign in. Local accounts, such as
+  the administrator `server init` made, keep signing in with their own
+  password.
+- **Sync:** every `sync_interval` the leader reads the directory.
+  - Someone disabled or deleted in AD is suspended and their sessions
+    end.
+  - When they are enabled again they are reinstated. An account an
+    administrator suspended by hand stays suspended.
+  - Roles follow groups, and memberships the directory gave are taken away
+    when the person leaves the group.
+  - A sync that would suspend more than half of the directory's accounts is
+    refused and logged, rather than locking everyone out over a wrong
+    `base_dn` or filter.
+- **Passwords:** a person's password is changed in AD. The gateway sends no
+  reset link for these accounts.
+
 ## Secrets in Vault

 Every setting that names a file holding a secret — the store's `@address`,
@@ -37,6 +37,7 @@ rather than repeated.
 | `default_tpm` | `int` | [Auth](#auth) |
 | `signup_open` | `bool` | [Auth](#auth) |
 | `oidc` | `OIDC` | [Auth](#auth) |
+| `ldap` | `LDAP` | [Auth](#auth) |
 | `scim` | `SCIM` | [Auth](#auth) |
 | `max_key_ttl` | `time.Duration` | [Auth](#auth) |
 | `personal` | `Personal` | [Auth](#auth) |
@@ -105,10 +106,13 @@ rather than repeated.
 | `url` | `string` | [External](#external) |
 | `model` | `string` | [External](#external) |
 | `api_key_file` | `string` | [External](#external) |
+| `api_key_files` | `[]ExternalKey` | [External](#external) |
 | `peer` | `string` | [External](#external) |
 | `api` | `string` | [External](#external) |
 | `workflow` | `string` | [External](#external) |
 | `output` | `string` | [External](#external) |
+| `file` | `string` | [ExternalKey](#externalkey) |
+| `weight` | `float64` | [ExternalKey](#externalkey) |
 | `budgets` | `[]FacilityBudget` | [Facility](#facility) |
 | `margin` | `float64` | [Facility](#facility) |
 | `gpu_watts` | `float64` | [Facility](#facility) |
@@ -144,6 +148,20 @@ rather than repeated.
 | `tokenize_timeout` | `time.Duration` | [KVIndex](#kvindex) |
 | `min_blocks` | `int` | [KVIndex](#kvindex) |
 | `max_blocks` | `int` | [KVIndex](#kvindex) |
+| `urls` | `[]string` | [LDAP](#ldap) |
+| `start_tls` | `bool` | [LDAP](#ldap) |
+| `ca_file` | `string` | [LDAP](#ldap) |
+| `bind_dn` | `string` | [LDAP](#ldap) |
+| `bind_password_file` | `string` | [LDAP](#ldap) |
+| `base_dn` | `string` | [LDAP](#ldap) |
+| `group_base_dn` | `string` | [LDAP](#ldap) |
+| `user_filter` | `string` | [LDAP](#ldap) |
+| `label` | `string` | [LDAP](#ldap) |
+| `create_accounts` | `bool` | [LDAP](#ldap) |
+| `roles` | `map[string][]string` | [LDAP](#ldap) |
+| `memberships` | `map[string]string` | [LDAP](#ldap) |
+| `sync_interval` | `time.Duration` | [LDAP](#ldap) |
+| `timeout` | `time.Duration` | [LDAP](#ldap) |
 | `contact` | `string` | [Landing](#landing) |
 | `notice` | `string` | [Landing](#landing) |
 | `language` | `string` | [Landing](#landing) |
@@ -616,6 +634,15 @@ OIDC is sign-in through an identity provider.

 Takes a [OIDC](#oidc) block.

+### `ldap`
+
+`LDAP`
+
+LDAP is sign-in against a directory, Active Directory above all, and
+the accounts kept in step with it.
+
+Takes a [LDAP](#ldap) block.
+
 ### `scim`

 `SCIM`
@@ -948,7 +975,7 @@ work stands without being renewed.
 Only meaningful with a shared store, where a second control plane can
 see the claim. Long enough to survive a slow query or a brief network
 stall, short enough that a standby takes over before anyone has finished
-reading the alert. Zero takes the default.
+reading the alert. Zero takes the default, 10s.

 ## CustomNode

@@ -1103,6 +1130,15 @@ APIKeyFile holds the provider's key, on the control plane. A file
 rather than the key itself, so the key is in neither the catalog, the
 store nor the audit log; empty for a provider that asks for none.

+### `api_key_files`
+
+`[]ExternalKey`
+
+APIKeyFiles are several keys for the provider, in place of
+APIKeyFile: one endpoint each (external:MODEL#1, #2…), so a key that
+answers 429 or 401 is passed over while its breaker is open and the
+request goes to another. A provider's limits are per key.
+
 ### `peer`

 `string`
@@ -1135,6 +1171,20 @@ plane.

 Output is what it makes: pictures, or meshes (see ComfyUI.Output).

+## ExternalKey
+
+### `file`
+
+`string`
+
+File holds the key, on the control plane, as APIKeyFile does.
+
+### `weight`
+
+`float64`
+
+Weight is its share of the requests against the others'; zero is 1.
+
 ## Facility

 ### `budgets`
@@ -1401,6 +1451,106 @@ MaxBlocks bounds how many of a prompt's blocks are hashed and looked
 up. Beyond it a longer match still helps, but the difference no longer
 decides anything. Zero takes 4096.

+## LDAP
+
+### `urls`
+
+`[]string`
+
+URLs are the directory's servers, tried in turn: ldaps:// (636), or
+ldap:// (389) with StartTLS.
+
+### `start_tls`
+
+`bool`
+
+StartTLS upgrades an ldap:// connection before anything is sent. A
+password never crosses a connection without TLS: ldap:// without it
+is refused.
+
+### `ca_file`
+
+`string`
+
+CAFile is the authority the servers' certificates are checked against,
+when it is not the system's: an AD Certificate Services root.
+
+### `bind_dn`
+
+`string`
+
+BindDN and the file holding its password: a service account that may
+read users and groups. Nothing is written to the directory.
+
+### `bind_password_file`
+
+`string`
+
+### `base_dn`
+
+`string`
+
+BaseDN is where people are searched for, subtree included.
+
+### `group_base_dn`
+
+`string`
+
+GroupBaseDN is where their groups are; empty is BaseDN's domain root.
+
+### `user_filter`
+
+`string`
+
+UserFilter narrows who may sign in, ANDed with the login match: a
+group (memberOf=...) or an OU's people only. Empty is every enabled
+user object.
+
+### `label`
+
+`string`
+
+Label is what the form says to sign in with: "Sign in with your
+<label> account". Empty is "Active Directory".
+
+### `create_accounts`
+
+`bool`
+
+CreateAccounts makes an account, active, for a person the directory
+vouches for and the gateway does not know. Off, only existing accounts
+sign in this way.
+
+### `roles`
+
+`map[string][]string`
+
+Roles maps a staff role (viewer, operator, billing, admin) to the
+groups that give it, by name (CN) or whole DN. Set at every sign-in
+and sync: someone taken out of the group loses the role.
+
+### `memberships`
+
+`map[string]string`
+
+Memberships maps a group, by CN or DN, to a place in the tree —
+org:NAME, team:ORG/TEAM, project:ORG/TEAM/PROJECT — joined at sign-in
+and kept by the sync, which also takes away a place whose group the
+person has left.
+
+### `sync_interval`
+
+`time.Duration`
+
+SyncInterval is how often the leader reads the directory. Zero is
+15m; negative turns the sync off, leaving only sign-in.
+
+### `timeout`
+
+`time.Duration`
+
+Timeout bounds each round trip to a server. Zero is 10s.
+
 ## Landing

 ### `contact`
@@ -12,6 +12,7 @@ require (
 	github.com/charmbracelet/x/ansi v0.11.6
 	github.com/coreos/go-oidc/v3 v3.21.0
 	github.com/go-jose/go-jose/v4 v4.1.4
+	github.com/go-ldap/ldap/v3 v3.4.15
 	github.com/go-zeromq/zmq4 v0.17.0
 	github.com/jackc/pgx/v5 v5.11.0
 	github.com/knadh/koanf/parsers/yaml v1.1.1
@@ -35,6 +36,7 @@ require (
 	golang.org/x/net v0.59.0
 	golang.org/x/oauth2 v0.37.0
 	golang.org/x/sync v0.23.0
+	golang.org/x/sys v0.48.0
 	golang.org/x/term v0.46.0
 	golang.org/x/text v0.42.0
 	google.golang.org/protobuf v1.36.12
@@ -44,6 +46,7 @@ require (
 require (
 	filippo.io/edwards25519 v1.2.0 // indirect
 	filippo.io/hpke v0.4.0 // indirect
+	github.com/Azure/go-ntlmssp v0.1.1 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
@@ -56,6 +59,7 @@ require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-asn1-ber/asn1-ber v1.5.8 // indirect
 	github.com/go-logr/logr v1.4.4 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
@@ -88,7 +92,6 @@ require (
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 // indirect
 	go.opentelemetry.io/otel/metric v1.46.0 // indirect
 	go.opentelemetry.io/proto/otlp v1.11.0 // indirect
-	golang.org/x/sys v0.48.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect
 	google.golang.org/grpc v1.83.1 // indirect
@@ -8,8 +8,12 @@ filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
 filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
 filippo.io/hpke v0.4.0 h1:p575VVQ6ted4pL+it6M00V/f2qTZITO0zgmdKCkd5+A=
 filippo.io/hpke v0.4.0/go.mod h1:EmAN849/P3qdeK+PCMkDpDm83vRHM5cDipBJ8xbQLVY=
+github.com/Azure/go-ntlmssp v0.1.1 h1:l+FM/EEMb0U9QZE7mKNEDw5Mu3mFiaa2GKOoTSsNDPw=
+github.com/Azure/go-ntlmssp v0.1.1/go.mod h1:NYqdhxd/8aAct/s4qSYZEerdPuH1liG2/X9DiVTbhpk=
 github.com/NVIDIA/go-nvml v0.13.4-0 h1:o3jp9u2x1R9ShFE3v+Aesp55XOSIQFMJz/VGNUcJaNE=
 github.com/NVIDIA/go-nvml v0.13.4-0/go.mod h1:id63qwpoDWpFXwnwM6psDCSqW4BmNu6mWpr4YeQtPGo=
+github.com/alexbrainman/sspi v0.0.0-20250919150558-7d374ff0d59e h1:4dAU9FXIyQktpoUAgOJK3OTFc/xug0PCXYCqU0FgDKI=
+github.com/alexbrainman/sspi v0.0.0-20250919150558-7d374ff0d59e/go.mod h1:cEWa1LVoE5KvSD9ONXsZrj0z6KqySlCCNKHlLzbqAt4=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
@@ -46,8 +50,12 @@ github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-asn1-ber/asn1-ber v1.5.8 h1:H9AZkK22UOmfX8J84ubyaZxKJZ3FMHVwn8swoMML7iQ=
+github.com/go-asn1-ber/asn1-ber v1.5.8/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
 github.com/go-jose/go-jose/v4 v4.1.4 h1:moDMcTHmvE6Groj34emNPLs/qtYXRVcd6S7NHbHz3kA=
 github.com/go-jose/go-jose/v4 v4.1.4/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
+github.com/go-ldap/ldap/v3 v3.4.15 h1:eRB4f4Ecn1POL1mO86+uUDlecmyWsdiJwh60bAUS4UY=
+github.com/go-ldap/ldap/v3 v3.4.15/go.mod h1:jeD0c98EdZQCKKKKe4kTWs5aCf6y+j8KuYsYLznZSQk=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8=
 github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
@@ -69,6 +77,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 h1:/Tnpcb2E0Pz/tN9s3bfEY2Q8ePCEX9iuS+cneUwncnw=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0/go.mod h1:zOBXOsUaBSjKgmH4OGzV1esUpR3oUSCPYVd2cUBjKYY=
+github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8=
+github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -81,6 +91,18 @@ github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
 github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
 github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/jcmturner/aescts/v2 v2.0.0 h1:9YKLH6ey7H4eDBXW8khjYslgyqG2xZikXP0EQFKrle8=
+github.com/jcmturner/aescts/v2 v2.0.0/go.mod h1:AiaICIRyfYg35RUkr8yESTqvSy7csK90qZ5xfvvsoNs=
+github.com/jcmturner/dnsutils/v2 v2.0.0 h1:lltnkeZGL0wILNvrNiVCR6Ro5PGU/SeBvVO/8c/iPbo=
+github.com/jcmturner/dnsutils/v2 v2.0.0/go.mod h1:b0TnjGOvI/n42bZa+hmXL+kFJZsFT7G4t3HTlQ184QM=
+github.com/jcmturner/gofork v1.7.6 h1:QH0l3hzAU1tfT3rZCnW5zXl+orbkNMMRGJfdJjHVETg=
+github.com/jcmturner/gofork v1.7.6/go.mod h1:1622LH6i/EZqLloHfE7IeZ0uEJwMSUyQ/nDd82IeqRo=
+github.com/jcmturner/goidentity/v6 v6.0.1 h1:VKnZd2oEIMorCTsFBnJWbExfNN7yZr3EhJAxwOkZg6o=
+github.com/jcmturner/goidentity/v6 v6.0.1/go.mod h1:X1YW3bgtvwAXju7V3LCIMpY0Gbxyjn/mY9zx4tFonSg=
+github.com/jcmturner/gokrb5/v8 v8.4.4 h1:x1Sv4HaTpepFkXbt2IkL29DXRf8sOfZXo8eRKh687T8=
+github.com/jcmturner/gokrb5/v8 v8.4.4/go.mod h1:1btQEpgT6k+unzCwX1KdWMEwPPkkgBtP+F6aCACiMrs=
+github.com/jcmturner/rpc/v2 v2.0.3 h1:7FXXj8Ti1IaVFpSAziCZWNzbNuZmnvw/i6CqLNdWfZY=
+github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc=
 github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk=
 github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
 github.com/knadh/koanf/maps v0.1.2 h1:RBfmAW5CnZT+PJ1CVc1QSJKf4Xu9kxfQgYVQSu8hpbo=
@@ -0,0 +1,63 @@
+package account
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/store"
+)
+
+type fakeDirectory struct {
+	asked []string
+	u     store.User
+	err   error
+}
+
+func (f *fakeDirectory) SignIn(_ context.Context, login, _ string) (store.User, error) {
+	f.asked = append(f.asked, login)
+	return f.u, f.err
+}
+
+// With a directory, a name the store has no password for is the
+// directory's to check; an account with a password here — the
+// administrator init made — is still checked here, so a directory that is
+// down locks nobody out.
+func TestPasswordsKeptElsewhereAreTheDirectorysToCheck(t *testing.T) {
+	svc, st := newService(t)
+	ctx := t.Context()
+	hash, _ := HashPassword("local-secret")
+	admin := store.User{ID: "usr-admin", Email: "admin@example.com", Name: "a", PasswordHash: hash,
+		State: store.UserActive, CreatedAt: time.Now()}
+	ada := store.User{ID: "usr-ada", Email: "ada@corp.example", Name: "Ada", PasswordHash: "!ldap",
+		State: store.UserActive, CreatedAt: time.Now()}
+	for _, u := range []store.User{admin, ada} {
+		if err := st.CreateUser(ctx, u); err != nil {
+			t.Fatal(err)
+		}
+	}
+	dir := &fakeDirectory{u: ada}
+	svc.SetDirectory(dir)
+
+	if _, _, err := svc.SignIn(ctx, "admin@example.com", "local-secret"); err != nil || len(dir.asked) != 0 {
+		t.Fatalf("the local administrator: %v, directory asked %v", err, dir.asked)
+	}
+	// A name, not an address, and an account kept by the directory.
+	for _, login := range []string{`CORP\ada`, "ada@corp.example"} {
+		if tok, _, err := svc.SignIn(ctx, login, "ad-secret"); err != nil || tok == "" {
+			t.Errorf("%s: %v", login, err)
+		}
+	}
+	if len(dir.asked) != 2 || dir.asked[0] != `CORP\ada` {
+		t.Errorf("the directory was asked %v", dir.asked)
+	}
+	dir.err = ErrBadCredentials
+	if _, _, err := svc.SignIn(ctx, "ada", "wrong"); !errors.Is(err, ErrBadCredentials) {
+		t.Errorf("a password the directory refused: %v", err)
+	}
+	// A reset link would give a directory's account a password here.
+	if _, _, err := svc.RequestReset(ctx, st, "ada@corp.example"); !errors.Is(err, ErrNoReset) {
+		t.Errorf("a directory's account was sent a reset link: %v", err)
+	}
+}
@@ -80,8 +80,26 @@ type Service struct {

 	mu       sync.Mutex
 	attempts map[string]*attemptWindow
+
+	// dir checks the passwords of accounts this store keeps none for.
+	dir Directory
 }

+// Directory checks a password against an outside directory — Active
+// Directory over LDAP — and answers the account to sign in: made or kept in
+// step with the directory. Its errors are this package's ErrBadCredentials
+// and ErrSuspended for the person's own, and anything else for the
+// directory's.
+type Directory interface {
+	SignIn(ctx context.Context, login, password string) (store.User, error)
+}
+
+// SetDirectory has passwords for accounts with none here, and names that are
+// not addresses, checked by the directory. An account with a password here
+// — the administrator init made — is still checked here, so a directory that
+// is down locks nobody out.
+func (s *Service) SetDirectory(d Directory) { s.dir = d }
+
 type attemptWindow struct {
 	count int
 	since time.Time
@@ -137,6 +155,7 @@ func (s *Service) SignUp(ctx context.Context, email, name, password string) erro
 // SignIn checks a password and opens a session, returning the session token and
 // the CSRF token that must accompany the forms in it.
 func (s *Service) SignIn(ctx context.Context, email, password string) (token, csrf string, err error) {
+	login := strings.TrimSpace(email)
 	email = store.NormalizeEmail(email)
 	// Counted per address and the client trying it, so somebody guessing
 	// from elsewhere cannot lock the owner out of their own account; and per
@@ -151,6 +170,15 @@ func (s *Service) SignIn(ctx context.Context, email, password string) (token, cs
 	}

 	u, err := s.store.UserByEmail(ctx, email)
+	// No password kept here — the directory's, or nobody's — and a
+	// directory to ask: it decides.
+	if s.dir != nil && (errors.Is(err, store.ErrNotFound) || (err == nil && strings.HasPrefix(u.PasswordHash, "!"))) {
+		if u, err = s.dir.SignIn(ctx, login, password); err != nil {
+			return "", "", err
+		}
+		s.clearAttempts(byClient)
+		return s.open(ctx, u)
+	}
 	if errors.Is(err, store.ErrNotFound) {
 		// Verify anyway, against a hash that cannot match. Returning early here
 		// would let a stopwatch enumerate every account on the system.
@@ -180,7 +208,11 @@ func (s *Service) SignIn(ctx context.Context, email, password string) (token, cs
 	case store.UserSuspended:
 		return "", "", ErrSuspended
 	}
+	return s.open(ctx, u)
+}

+// open makes a session for a person whose password was right.
+func (s *Service) open(ctx context.Context, u store.User) (token, csrf string, err error) {
 	if token, err = store.NewSessionToken(); err != nil {
 		return "", "", err
 	}
@@ -402,7 +434,10 @@ func (s *Service) RequestReset(ctx context.Context, rs ResetStore, email string)
 		return "", store.User{}, ErrTooManyTries
 	}
 	u, err := rs.UserByEmail(ctx, email)
-	if err != nil || u.PasswordHash == "" || u.State != store.UserActive {
+	// An account whose password is kept elsewhere — "!oidc", "!scim",
+	// "!ldap" — gets no link: setting one here would give it a second way
+	// in that its directory knows nothing of, and outlives its leaving.
+	if err != nil || u.PasswordHash == "" || strings.HasPrefix(u.PasswordHash, "!") || u.State != store.UserActive {
 		return "", store.User{}, ErrNoReset
 	}
 	token, err := rs.CreatePasswordReset(ctx, u.ID, ResetLinkTTL)
@@ -1417,11 +1417,14 @@ func Client(cfg tlsconf.Config, timeout time.Duration) (*http.Client, error) {
 // off — is never closed: nothing sends the FIN, and the agent's heartbeats sit
 // in the socket's buffer until the kernel gives up retransmitting, fifteen
 // minutes later. Found by switching off a leader: the standby took over in 14
-// seconds and the node stayed with the dead one. An HTTP/2 ping after ten
-// quiet seconds, given five to answer, finds it in a quarter of a minute.
+// seconds and the node stayed with the dead one. An HTTP/2 ping after five
+// quiet seconds, given three to answer, finds it in eight: by the time the
+// standby leads, as it does within the lease's ten seconds, the node is on
+// its way to it. At fifteen, with the lease at fifteen too, the new leader
+// went without its nodes, and so its judges, for half a minute.
 const (
-	streamIdle = 10 * time.Second
-	streamPing = 5 * time.Second
+	streamIdle = 5 * time.Second
+	streamPing = 3 * time.Second
 )

 // localizeSpec fills in what only this node knows.
@@ -150,6 +150,7 @@ func newBenchCmd(client func() *ctlClient, asJSON *bool) *cobra.Command {
 	f.DurationVar(&cfg.SLO.TPOTp99, "tpot-p99", cfg.SLO.TPOTp99, "per-output-token target")
 	f.BoolVar(&save, "save", false,
 		"record the capacity against the model and profile, so the number outlives this terminal")
+	cmd.AddCommand(newBenchOverheadCmd(asJSON))
 	return cmd
 }

@@ -0,0 +1,421 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"slices"
+	"sort"
+	"strings"
+	"sync"
+	"syscall"
+	"text/tabwriter"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/config"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/guard"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/router"
+	storepkg "gitea.mynodes.xyz/ilker/llmgw/internal/store"
+)
+
+// What llmgw adds to a request, measured: the same load straight at an
+// engine that answers at once, and through the gateway in front of it —
+// bare, with authentication and usage accounting, and with the guardrails'
+// pattern checks besides. The engine's own time is the same on both paths,
+// so what differs is the gateway's.
+//
+// Everything runs in this process, on loopback: no cluster, no GPU, and the
+// numbers are this machine's. On a machine shared with other work (a VM on
+// an oversubscribed host) they move with it; compare modes run together,
+// not figures from different runs.
+
+// overheadMode is one way a request reaches the engine.
+type overheadMode struct {
+	name        string
+	gateway     bool
+	auth, guard bool
+}
+
+var overheadModes = []overheadMode{
+	{name: "direct"},
+	{name: "gateway", gateway: true},
+	{name: "gateway+auth", gateway: true, auth: true},
+	{name: "gateway+auth+guard", gateway: true, auth: true, guard: true},
+}
+
+// overheadStep is one mode at one request rate.
+type overheadStep struct {
+	Mode     string        `json:"mode"`
+	Rate     int           `json:"rate"`
+	Sent     int           `json:"sent"`
+	Failed   int           `json:"failed"`
+	P50      time.Duration `json:"p50"`
+	P99      time.Duration `json:"p99"`
+	AddedP50 time.Duration `json:"added_p50"`
+	AddedP99 time.Duration `json:"added_p99"`
+	// CPUPer1k is the process's CPU time per thousand requests beyond what
+	// the direct mode spent at the same rate: the gateway's.
+	CPUPer1k time.Duration `json:"cpu_per_1k"`
+	cpu      time.Duration
+}
+
+func newBenchOverheadCmd(asJSON *bool) *cobra.Command {
+	var (
+		rates []int
+		each  time.Duration
+	)
+	cmd := &cobra.Command{
+		Use:   "overhead",
+		Short: "Measure what the gateway adds to a request, against an engine that answers at once",
+		Long: "Runs an engine that answers at once and a gateway in front of it, in this\n" +
+			"process on loopback, and sends the same load at each rate straight to the\n" +
+			"engine and through the gateway: bare, with authentication and usage\n" +
+			"accounting, and with the guardrails' pattern checks too. Reports each\n" +
+			"request's latency at p50 and p99, what the gateway added to it, and the\n" +
+			"gateway's CPU time per thousand requests.\n\n" +
+			"Needs no cluster. The figures are this machine's: on one shared with other\n" +
+			"work they move with it, so compare the modes of one run, and note the\n" +
+			"machine's load beside any figure you keep.",
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			steps, err := runOverhead(cmd.Context(), rates, each)
+			if err != nil {
+				return err
+			}
+			if *asJSON {
+				return json.NewEncoder(cmd.OutOrStdout()).Encode(steps)
+			}
+			printOverhead(cmd.OutOrStdout(), steps)
+			return nil
+		},
+	}
+	f := cmd.Flags()
+	f.IntSliceVar(&rates, "rates", []int{100, 500, 1000, 2000}, "requests a second to send, one step each")
+	f.DurationVar(&each, "each", 3*time.Second, "how long each step sends for")
+	return cmd
+}
+
+func printOverhead(w io.Writer, steps []overheadStep) {
+	tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(tw, "MODE\tRATE/S\tSENT\tFAILED\tP50\tP99\t+P50\t+P99\tCPU/1K REQ")
+	for _, s := range steps {
+		added := func(d time.Duration) string {
+			if s.Mode == "direct" {
+				return "-"
+			}
+			return msOf(d)
+		}
+		cpu := "-"
+		if s.Mode != "direct" {
+			cpu = msOf(s.CPUPer1k)
+		}
+		fmt.Fprintf(tw, "%s\t%d\t%d\t%d\t%s\t%s\t%s\t%s\t%s\n", s.Mode, s.Rate, s.Sent, s.Failed,
+			msOf(s.P50), msOf(s.P99), added(s.AddedP50), added(s.AddedP99), cpu)
+	}
+	_ = tw.Flush()
+	fmt.Fprintf(w, "\n%d CPUs, %s. Loopback, in one process: the figures are this machine's.\n",
+		runtime.NumCPU(), loadAverage())
+}
+
+func msOf(d time.Duration) string { return fmt.Sprintf("%.2fms", float64(d)/float64(time.Millisecond)) }
+
+// loadAverage is the machine's, where it can be read, to keep beside the
+// figures.
+func loadAverage() string {
+	if b, err := os.ReadFile("/proc/loadavg"); err == nil {
+		if f := strings.Fields(string(b)); len(f) >= 3 {
+			return "load " + strings.Join(f[:3], " ")
+		}
+	}
+	// macOS: "{ 1.23 1.10 0.98 }".
+	if b, err := exec.Command("sysctl", "-n", "vm.loadavg").Output(); err == nil {
+		if f := strings.Fields(strings.Trim(strings.TrimSpace(string(b)), "{}")); len(f) >= 3 {
+			return "load " + strings.Join(f[:3], " ")
+		}
+	}
+	return "load not read"
+}
+
+// runOverhead measures every mode at every rate.
+func runOverhead(ctx context.Context, rates []int, each time.Duration) ([]overheadStep, error) {
+	engine, err := instantEngine()
+	if err != nil {
+		return nil, err
+	}
+	defer engine.Close()
+	dir, err := os.MkdirTemp("", "llmgw-overhead-")
+	if err != nil {
+		return nil, err
+	}
+	defer os.RemoveAll(dir)
+
+	type target struct {
+		url, key string
+		stop     func()
+	}
+	targets := map[string]target{}
+	defer func() {
+		for _, t := range targets {
+			if t.stop != nil {
+				t.stop()
+			}
+		}
+	}()
+	for _, m := range overheadModes {
+		if !m.gateway {
+			targets[m.name] = target{url: engine.URL}
+			continue
+		}
+		url, key, stop, err := overheadGateway(ctx, engine.URL, filepath.Join(dir, m.name+".db"), m)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", m.name, err)
+		}
+		targets[m.name] = target{url: url, key: key, stop: stop}
+	}
+
+	client := &http.Client{Transport: &http.Transport{MaxIdleConns: 1024, MaxIdleConnsPerHost: 1024}, Timeout: 30 * time.Second}
+	var out []overheadStep
+	for _, rate := range rates {
+		var direct overheadStep
+		for _, m := range overheadModes {
+			t := targets[m.name]
+			s := loadStep(ctx, client, t.url, t.key, rate, each)
+			s.Mode = m.name
+			if m.name == "direct" {
+				direct = s
+			} else {
+				s.AddedP50, s.AddedP99 = max(0, s.P50-direct.P50), max(0, s.P99-direct.P99)
+				if s.Sent > 0 {
+					s.CPUPer1k = max(0, s.cpu-direct.cpu) * 1000 / time.Duration(s.Sent)
+				}
+			}
+			out = append(out, s)
+		}
+	}
+	return out, nil
+}
+
+// loadStep sends rate requests a second for d, each in its own goroutine,
+// and measures each one's latency and the process's CPU meanwhile.
+func loadStep(ctx context.Context, client *http.Client, url, key string, rate int, d time.Duration) overheadStep {
+	s := overheadStep{Rate: rate}
+	body := []byte(`{"model":"bench","max_tokens":8,"messages":[{"role":"user","content":"What is the capital of France?"}]}`)
+	var (
+		mu    sync.Mutex
+		lat   []time.Duration
+		wg    sync.WaitGroup
+		total = int(float64(rate) * d.Seconds())
+	)
+	interval := time.Second / time.Duration(max(rate, 1))
+	cpu0 := processCPU()
+	start := time.Now()
+	for i := range total {
+		if ctx.Err() != nil {
+			break
+		}
+		if wait := time.Until(start.Add(time.Duration(i) * interval)); wait > 0 {
+			time.Sleep(wait)
+		}
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url+"/v1/chat/completions", bytes.NewReader(body))
+			req.Header.Set("Content-Type", "application/json")
+			if key != "" {
+				req.Header.Set("Authorization", "Bearer "+key)
+			}
+			t := time.Now()
+			resp, err := client.Do(req)
+			ok := err == nil && resp.StatusCode == http.StatusOK
+			if resp != nil {
+				_, _ = io.Copy(io.Discard, resp.Body)
+				resp.Body.Close()
+			}
+			el := time.Since(t)
+			mu.Lock()
+			s.Sent++
+			if ok {
+				lat = append(lat, el)
+			} else {
+				s.Failed++
+			}
+			mu.Unlock()
+		}()
+	}
+	wg.Wait()
+	s.cpu = processCPU() - cpu0
+	s.P50, s.P99 = percentile(lat, 0.50), percentile(lat, 0.99)
+	return s
+}
+
+func percentile(ds []time.Duration, p float64) time.Duration {
+	if len(ds) == 0 {
+		return 0
+	}
+	ds = slices.Clone(ds)
+	sort.Slice(ds, func(i, j int) bool { return ds[i] < ds[j] })
+	i := int(p * float64(len(ds)-1))
+	return ds[i]
+}
+
+// processCPU is the CPU time this process has used, user and system.
+func processCPU() time.Duration {
+	var ru syscall.Rusage
+	if err := syscall.Getrusage(syscall.RUSAGE_SELF, &ru); err != nil {
+		return 0
+	}
+	return time.Duration(ru.Utime.Nano() + ru.Stime.Nano())
+}
+
+// instantEngine is an OpenAI-compatible engine that answers at once, with
+// the metrics the router scrapes.
+func instantEngine() (*httpServer, error) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /metrics", func(w http.ResponseWriter, _ *http.Request) {
+		fmt.Fprint(w, "# TYPE vllm:num_requests_running gauge\nvllm:num_requests_running 0\n"+
+			"# TYPE vllm:num_requests_waiting gauge\nvllm:num_requests_waiting 0\n"+
+			"# TYPE vllm:kv_cache_usage_perc gauge\nvllm:kv_cache_usage_perc 0.1\n")
+	})
+	mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) })
+	mux.HandleFunc("POST /v1/chat/completions", func(w http.ResponseWriter, r *http.Request) {
+		_, _ = io.Copy(io.Discard, r.Body)
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprint(w, `{"id":"b","object":"chat.completion","model":"bench","choices":[{"index":0,"message":{"role":"assistant","content":"Paris."},"finish_reason":"stop"}],"usage":{"prompt_tokens":14,"completion_tokens":2,"total_tokens":16}}`)
+	})
+	return serveLoopback(mux)
+}
+
+// httpServer is a handler served on a loopback port.
+type httpServer struct {
+	URL string
+	srv *http.Server
+}
+
+func (s *httpServer) Close() { _ = s.srv.Close() }
+
+func serveLoopback(h http.Handler) (*httpServer, error) {
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return nil, err
+	}
+	srv := &http.Server{Handler: h, ReadHeaderTimeout: 10 * time.Second}
+	go func() { _ = srv.Serve(ln) }()
+	return &httpServer{URL: "http://" + ln.Addr().String(), srv: srv}, nil
+}
+
+// overheadGateway starts a gateway in front of the engine as the mode asks,
+// and returns its address and, with auth, a key.
+func overheadGateway(ctx context.Context, engineURL, storePath string, m overheadMode) (string, string, func(), error) {
+	cfg := config.Default()
+	cfg.Listen = "127.0.0.1:0"
+	cfg.Router.ScrapeInterval = 200 * time.Millisecond
+	cfg.Endpoints = []config.Endpoint{{ID: "bench", URL: engineURL, Models: []string{"bench"}}}
+	key := ""
+	if m.auth {
+		var err error
+		if key, err = overheadKey(ctx, storePath); err != nil {
+			return "", "", nil, err
+		}
+		cfg.Auth.Enabled, cfg.Auth.Store = true, storePath
+		// Limits would measure themselves refusing: off.
+		cfg.Auth.DefaultRPM, cfg.Auth.DefaultTPM = 0, 0
+	}
+	rt, err := router.New(cfg, slog.New(slog.DiscardHandler))
+	if err != nil {
+		return "", "", nil, err
+	}
+	if m.guard {
+		g, err := baselineGuard()
+		if err != nil {
+			return "", "", nil, err
+		}
+		rt.SetGuard(g)
+	}
+	rctx, cancel := context.WithCancel(ctx)
+	rt.Start(rctx)
+	srv, err := serveLoopback(rt.Handler())
+	if err != nil {
+		cancel()
+		return "", "", nil, err
+	}
+	stop := func() { srv.Close(); cancel(); rt.Stop() }
+	// Ready once a request goes through: the endpoint is scraped first.
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		body := `{"model":"bench","messages":[{"role":"user","content":"hi"}]}`
+		req, _ := http.NewRequestWithContext(ctx, http.MethodPost, srv.URL+"/v1/chat/completions", strings.NewReader(body))
+		req.Header.Set("Content-Type", "application/json")
+		if key != "" {
+			req.Header.Set("Authorization", "Bearer "+key)
+		}
+		resp, err := http.DefaultClient.Do(req)
+		if err == nil {
+			_, _ = io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			if resp.StatusCode == http.StatusOK {
+				return srv.URL, key, stop, nil
+			}
+		}
+		if time.Now().After(deadline) {
+			stop()
+			status := "no answer"
+			if err == nil {
+				status = resp.Status
+			}
+			return "", "", nil, fmt.Errorf("the gateway did not serve within 10s (%s)", status)
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+// overheadKey makes a store with one project and a key in it.
+func overheadKey(ctx context.Context, path string) (string, error) {
+	st, err := storepkg.Open(ctx, path)
+	if err != nil {
+		return "", err
+	}
+	defer st.Close()
+	org, err := st.CreateOrg(ctx, "bench")
+	if err != nil {
+		return "", err
+	}
+	team, err := st.CreateTeam(ctx, org, "bench")
+	if err != nil {
+		return "", err
+	}
+	project, err := st.CreateProject(ctx, team, "bench")
+	if err != nil {
+		return "", err
+	}
+	secret, k, err := storepkg.NewKey("key-bench", "bench", project)
+	if err != nil {
+		return "", err
+	}
+	k.CreatedAt = time.Now()
+	return secret, st.CreateKey(ctx, k)
+}
+
+// baselineGuard is the policy init installs, without its judge: the pattern
+// checks every request passes.
+func baselineGuard() (guard.Guard, error) {
+	m, err := config.Parse([]byte(guardSection(false)))
+	if err != nil {
+		return nil, err
+	}
+	cfg, err := config.FromMap(m)
+	if err != nil {
+		return nil, err
+	}
+	return guard.NewGate(cfg.Guard, nil, slog.New(slog.DiscardHandler))
+}
@@ -0,0 +1,33 @@
+package cli
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+)
+
+// The short version, so CI sees the gateway's overhead on every change: every
+// mode answers every request, and what the gateway adds is measured, not
+// guessed. No bound is asserted on it, as CI's machines vary; the table is
+// in the test's log.
+func TestTheGatewaysOverheadIsMeasured(t *testing.T) {
+	steps, err := runOverhead(t.Context(), []int{50}, time.Second)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != len(overheadModes) {
+		t.Fatalf("%d steps for %d modes", len(steps), len(overheadModes))
+	}
+	for _, s := range steps {
+		if s.Sent == 0 || s.Failed > 0 || s.P50 <= 0 || s.P99 < s.P50 {
+			t.Errorf("%s: sent %d failed %d p50 %s p99 %s", s.Mode, s.Sent, s.Failed, s.P50, s.P99)
+		}
+	}
+	var b bytes.Buffer
+	printOverhead(&b, steps)
+	if !strings.Contains(b.String(), "gateway+auth+guard") {
+		t.Errorf("table:\n%s", b.String())
+	}
+	t.Logf("\n%s", b.String())
+}
@@ -32,6 +32,19 @@ type judgeKeeper struct {
 	// tried is when each judge was last asked for, so one that cannot be
 	// fetched is not asked for again on every look.
 	tried map[string]time.Time
+
+	// What refitting an earlier install's judge needs: the catalog to change
+	// its profile in, the replicas to restart, and the nodes' CPUs. Any nil
+	// leaves judges as they are.
+	profiles interface {
+		SetProfiles(ctx context.Context, name string, profiles []catalog.Profile, by string) (catalog.Model, error)
+	}
+	restart  func(ids ...string) error
+	replicas func(model string) []string
+	nodeCPUs func() []int
+	// looked is each judge already refitted or found changed by hand, so
+	// each is said once.
+	looked map[string]bool
 }

 // judgeRetry is how long a judge whose serving failed waits before it is
@@ -69,6 +82,7 @@ func (k *judgeKeeper) check() {
 	have := map[string]bool{}
 	for _, m := range k.models() {
 		have[m.Name] = true
+		k.refit(m)
 	}
 	busy := map[string]bool{}
 	for _, j := range k.serve.Jobs() {
@@ -114,3 +128,88 @@ func (k *judgeKeeper) check() {
 			"judge", name, "repo", kj.Repo, "file", kj.File, "job", job.ID)
 	}
 }
+
+// refit moves a judge an earlier `server init` installed to what init
+// installs now, and restarts its replicas onto it. Those judges reserved no
+// cores or one, 2 or 4 GB, and ran llama.cpp's prompt cache: on fewer than
+// eight cores every judgment missed its 5 s budget and fail: closed refused
+// every request, until fixed by hand. A judge whose profile differs in any
+// other way was set by somebody, and is left as it is, said once.
+func (k *judgeKeeper) refit(m catalog.Model) {
+	if k.profiles == nil || k.restart == nil || k.replicas == nil || m.Name != defaultJudge || !m.IsGuard() {
+		return
+	}
+	if k.looked == nil {
+		k.looked = map[string]bool{}
+	}
+	if k.looked[m.Name] {
+		return
+	}
+	k.looked[m.Name] = true
+	if !earlierInitJudge(m) {
+		if len(m.Profiles) != 1 || !slices.Contains(m.Profiles[0].Args, "--cache-ram") {
+			k.log.Info("the judge's profile is not one init wrote; left as it is",
+				"judge", m.Name, "see", "llmgw ctl model resources "+m.Name)
+		}
+		return
+	}
+	var cpus []int
+	if k.nodeCPUs != nil {
+		cpus = k.nodeCPUs()
+	}
+	p := m.Profiles[0]
+	p.MinMemoryGB = judgeMemoryGB
+	p.CPUCores = refitCores(m.Scaling.Min, cpus)
+	p.Args = []string{"--ctx-size", "8192", "--cache-ram", "0"}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	if _, err := k.profiles.SetProfiles(ctx, m.Name, []catalog.Profile{p}, "llmgw (the judge an earlier init installed)"); err != nil {
+		k.log.Warn("could not refit the judge an earlier init installed", "judge", m.Name, "err", err)
+		k.looked[m.Name] = false
+		return
+	}
+	ids := k.replicas(m.Name)
+	if len(ids) > 0 {
+		if err := k.restart(ids...); err != nil {
+			k.log.Warn("refitted the judge, but could not restart it", "judge", m.Name, "err", err)
+		}
+	}
+	k.log.Info("refitted the judge an earlier init installed", "judge", m.Name,
+		"memory_gb", p.MinMemoryGB, "cpu_cores", p.CPUCores, "replicas_restarted", len(ids))
+}
+
+// earlierInitJudge is whether a judge's entry is exactly what `server init`
+// before v0.14.7 wrote: one llama.cpp profile on CPUs, an 8192 context and
+// no other args, 2 or 4 GB, none to two cores.
+func earlierInitJudge(m catalog.Model) bool {
+	if len(m.Profiles) != 1 {
+		return false
+	}
+	p := m.Profiles[0]
+	return p.Name == "cpu" && p.Engine == "llamacpp" && p.GPUClass == "" && p.GPU == nil &&
+		len(p.NodeSelector) == 0 && slices.Equal(p.Args, []string{"--ctx-size", "8192"}) &&
+		(p.MinMemoryGB == 2 || p.MinMemoryGB == 4) && p.CPUCores >= 0 && p.CPUCores <= 2
+}
+
+// refitCores is a judge replica's cores by init's rule: up to four for the
+// one judge of a cluster, two each where there are more, fewer where the
+// smallest node cannot hold them all.
+func refitCores(replicas int, cpus []int) int {
+	smallest := 0
+	for _, c := range cpus {
+		if c > 0 && (smallest == 0 || c < smallest) {
+			smallest = c
+		}
+	}
+	if replicas <= 1 {
+		if smallest == 0 {
+			return judgeCores
+		}
+		return min(smallest, judgeCoresAlone)
+	}
+	cores := judgeCores
+	if len(cpus) == 1 && smallest > 0 && replicas*cores > smallest {
+		cores = max(1, smallest/replicas)
+	}
+	return cores
+}
@@ -1,6 +1,7 @@
 package cli

 import (
+	"context"
 	"errors"
 	"log/slog"
 	"slices"
@@ -124,3 +125,81 @@ func TestCategoriesFollowTheJudges(t *testing.T) {
 		t.Errorf("no categories (every one counts) became %v", got)
 	}
 }
+
+type fakeProfiles struct {
+	set map[string][]catalog.Profile
+}
+
+func (f *fakeProfiles) SetProfiles(_ context.Context, name string, ps []catalog.Profile, _ string) (catalog.Model, error) {
+	if f.set == nil {
+		f.set = map[string][]catalog.Profile{}
+	}
+	f.set[name] = ps
+	return catalog.Model{Name: name, Profiles: ps}, nil
+}
+
+// A judge that v0.14.6 or earlier's init installed is moved to today's
+// figures, once, and its replicas restarted onto them; one somebody changed
+// is left alone.
+func TestAnEarlierInstallsJudgeIsRefittedOnce(t *testing.T) {
+	lib := guard.Config{Policies: map[string]guard.Policy{
+		"baseline": {Judge: &guard.JudgePolicy{Model: "qwen3guard-0.6b", Input: "block"}},
+	}}
+	earlier := guardModel("http://10.0.0.5:8081/qwen3guard-0.6b/guard/g.gguf", 2, 1)
+	earlier.Profiles[0].MinMemoryGB, earlier.Profiles[0].Args = 4, []string{"--ctx-size", "8192"}
+	inCatalog := []catalog.Model{earlier}
+	fp := &fakeProfiles{}
+	var restarted []string
+	k := &judgeKeeper{
+		library:  func() guard.Config { return lib },
+		models:   func() []catalog.Model { return inCatalog },
+		serve:    &fakeServe{},
+		log:      slog.New(slog.DiscardHandler),
+		profiles: fp,
+		restart:  func(ids ...string) error { restarted = append(restarted, ids...); return nil },
+		replicas: func(string) []string { return []string{"j-1", "j-2"} },
+		nodeCPUs: func() []int { return []int{4} },
+	}
+	k.check()
+	got := fp.set["qwen3guard-0.6b"]
+	if len(got) != 1 || got[0].MinMemoryGB != 2 || got[0].CPUCores != 2 || !slices.Contains(got[0].Args, "--cache-ram") {
+		t.Fatalf("refitted to %+v", got)
+	}
+	if !slices.Equal(restarted, []string{"j-1", "j-2"}) {
+		t.Errorf("restarted %v", restarted)
+	}
+	k.check()
+	if len(restarted) != 2 {
+		t.Error("refitted twice")
+	}
+
+	// Changed by somebody: an extra arg. Left as it is.
+	mine := guardModel("http://x/g.gguf", 2, 3)
+	mine.Profiles[0].Args = []string{"--ctx-size", "16384"}
+	inCatalog = []catalog.Model{mine}
+	fp.set, k.looked = nil, nil
+	k.check()
+	if fp.set != nil {
+		t.Errorf("a judge set by hand was changed: %+v", fp.set)
+	}
+}
+
+func TestAJudgeIsRefittedToTheCoresInitWouldGive(t *testing.T) {
+	for _, c := range []struct {
+		replicas int
+		cpus     []int
+		want     int
+	}{
+		{1, []int{4}, 4},
+		{1, []int{2}, 2},
+		{1, []int{16}, 4},
+		{2, []int{4}, 2},
+		{2, []int{2}, 1},
+		{2, []int{4, 32}, 2},
+		{2, nil, 2},
+	} {
+		if got := refitCores(c.replicas, c.cpus); got != c.want {
+			t.Errorf("%d judges on %v: %d cores, want %d", c.replicas, c.cpus, got, c.want)
+		}
+	}
+}
@@ -593,6 +593,25 @@ func newServerCmd() *cobra.Command {
 							},
 							gpus: func() []adminapi.ClassUse { return adminAPI.Summary().GPUs },
 							log:  log,
+							// An earlier install's judge, moved to today's figures.
+							profiles: catalogSvc,
+							restart:  admin.Reconciler().Restart,
+							replicas: func(model string) []string {
+								var ids []string
+								for _, r := range admin.Reconciler().ReadyReplicas() {
+									if r.Model == model {
+										ids = append(ids, r.ID)
+									}
+								}
+								return ids
+							},
+							nodeCPUs: func() []int {
+								var out []int
+								for _, n := range admin.Nodes() {
+									out = append(out, n.CPUCount)
+								}
+								return out
+							},
 						}
 						go keeper.run(ctx, 30*time.Second)
 					}
@@ -9,6 +9,7 @@ import (
 	"encoding/pem"
 	"errors"
 	"fmt"
+	"hash/fnv"
 	"io"
 	"net"
 	"os"
@@ -44,6 +45,11 @@ type serverAdd struct {
 	// addr is the machine's address as given; ip what the others reach it at.
 	addr, ip, name string
 	out            io.Writer
+	// priority is its keepalived priority, under this machine's 110; 0 is
+	// 100. Two standbys get two, so which takes the address is not a tie.
+	priority int
+	// quiet leaves out the closing sentence, for init, which says its own.
+	quiet bool
 }

 func newServerAddCmd() *cobra.Command {
@@ -148,7 +154,9 @@ func (sa *serverAdd) run(ctx context.Context) error {
 			return fmt.Errorf("%s: %w", s.name, err)
 		}
 	}
-	fmt.Fprintf(sa.out, "\n%s is a control plane of this cluster, standing by while this one leads.\n", sa.name)
+	if !sa.quiet {
+		fmt.Fprintf(sa.out, "\n%s is a control plane of this cluster, standing by while this one leads.\n", sa.name)
+	}
 	return nil
 }

@@ -511,18 +519,31 @@ func (sa *serverAdd) floating(ctx context.Context) error {
 		return err
 	}
 	here := pgha.Local{}
+	priority := sa.priority
+	if priority <= 0 {
+		priority = 100
+	}
 	for _, m := range []struct {
 		r        onboard.Remote
 		name     string
 		priority int
-	}{{here, "this machine", 110}, {sa.remote, sa.name, 100}} {
+	}{{here, "this machine", 110}, {sa.remote, sa.name, priority}} {
+		// The interface on the address's network, by its route: not the
+		// route to the address, which is lo on the machine holding it
+		// already, as a run after the first finds it.
 		out, err := m.r.Run(ctx, fmt.Sprintf(`set -e
 command -v keepalived >/dev/null 2>&1 || { sudo DEBIAN_FRONTEND=noninteractive apt-get -qq update >/dev/null; sudo DEBIAN_FRONTEND=noninteractive apt-get -qq install -y keepalived >/dev/null; }
-ip -o route get %s | awk '{for(i=1;i<=NF;i++) if($i=="dev") {print $(i+1); exit}}'`, vip), nil)
+dev() { awk '{for(i=1;i<=NF;i++) if($i=="dev") {print $(i+1); exit}}'; }
+d=$(ip -o -4 route show %s | dev)
+[ -n "$d" ] && [ "$d" != lo ] || d=$(ip -o route get %s | dev)
+echo "$d"`, nw.String(), vip), nil)
 		if err != nil {
 			return fmt.Errorf("on %s: %v: %s", m.name, err, strings.TrimSpace(string(out)))
 		}
 		iface := strings.TrimSpace(string(out))
+		if iface == "" || iface == "lo" {
+			return fmt.Errorf("on %s: no interface on %s's network", m.name, sa.vip)
+		}
 		conf := keepalivedConf(iface, vip.String(), prefix, m.priority, pass)
 		if out, err := m.r.Run(ctx, `set -e
 sudo install -d -m 0755 /etc/keepalived
@@ -560,6 +581,17 @@ func vrrpPassword(etcDir string) (string, error) {
 	return pass, nil
 }

+// vrrpRouterID is the VRRP router id for a floating address: from the
+// address, so two clusters on one network, each with its own address, do
+// not answer each other's adverts — with one id for all, each logged the
+// other's as an invalid password, and dropped its own address's
+// announcements with them.
+func vrrpRouterID(vip string) int {
+	h := fnv.New32a()
+	_, _ = h.Write([]byte(vip))
+	return int(h.Sum32()%255) + 1
+}
+
 func keepalivedConf(iface, vip string, prefix, priority int, pass string) string {
 	return fmt.Sprintf(`# llmgw: the gateway's floating address, on whichever control plane leads.
 vrrp_script llmgw_leader {
@@ -572,7 +604,7 @@ vrrp_script llmgw_leader {
 vrrp_instance llmgw {
  state BACKUP
  interface %s
-  virtual_router_id 51
+  virtual_router_id %d
  priority %d
  advert_int 1
  authentication {
@@ -586,7 +618,7 @@ vrrp_instance llmgw {
    llmgw_leader
  }
 }
-`, iface, priority, pass, vip, prefix)
+`, iface, vrrpRouterID(vip), priority, pass, vip, prefix)
 }

 // clientCapable says a control plane's certificate can also present itself
@@ -95,9 +95,34 @@ type serverInit struct {
 	// bundle is an offline bundle to install from, and bundleSHA its
 	// manifest's sha256: the cluster is then set up offline.
 	bundle, bundleSHA string
-	// mirrorPath is the mirror's directory here; "" is /srv/models. A seam
-	// for tests.
+	// mirrorPath is the mirror's directory here; "" is /srv/models.
 	mirrorPath string
+
+	// What setup lets a person choose besides the parts: zero is the
+	// default (serverinit_choices.go).
+	starter    starterSpec
+	starterCtx int
+	judge      judgeSpec
+	// language is the portal's for a browser that asks for neither of its
+	// own; "" leaves it English.
+	language               string
+	signupOpen             bool
+	defaultRPM, defaultTPM int
+	maxKeyTTL              time.Duration
+	// media has the nodes install ComfyUI and the leader add a picture model
+	// and a 3D model once a card fits one.
+	media bool
+	// evictAfterIdle and minLifetime are on_demand's; zero leaves its own.
+	evictAfterIdle, minLifetime time.Duration
+	// standbys makes each machine of the replicated store a control plane
+	// too, standing by while this one leads: three machines, each able to
+	// take over. vip is a floating address, as 10.0.0.160/24, kept on
+	// whichever leads.
+	standbys bool
+	vip      string
+	// cpus is this machine's CPU count for dividing it between init's
+	// models; zero asks the machine. A seam for tests.
+	cpus int
 	// pgSetup prepares PostgreSQL and returns the store address; a seam for
 	// tests. Nil does it for real.
 	pgSetup func(context.Context) (string, error)
@@ -122,7 +147,10 @@ func newDefaultServerInit() serverInit {

 func newServerInitCmd() *cobra.Command {
 	in := newDefaultServerInit()
-	var plain bool
+	var (
+		plain              bool
+		starter, judgeCats string
+	)
 	cmd := &cobra.Command{
 		Use:   "init",
 		Short: "Set this machine up as a control plane and start it",
@@ -158,6 +186,9 @@ func newServerInitCmd() *cobra.Command {
 			if os.Geteuid() != 0 {
 				return errors.New("init creates a user, writes /etc and starts a service: run it as root")
 			}
+			if err := in.readChoices(starter, judgeCats); err != nil {
+				return err
+			}
 			in.out = cmd.OutOrStdout()
 			if !plain && isTerminal(in.out) {
 				return in.runInitTUI(cmd.Context(), in.out)
@@ -191,6 +222,34 @@ func newServerInitCmd() *cobra.Command {
 	f.StringArrayVar(&in.patroni, "patroni", nil,
 		"user@host of a machine to keep the store on, replicated under Patroni; give two or more. "+
 			"Installs PostgreSQL, Patroni and etcd there over ssh, and moves the existing store in")
+
+	// What server.yaml is written with; each is in it only when init writes
+	// it, never into one already there.
+	f.StringVar(&in.mirrorPath, "mirror-dir", mirrorDir, "the directory the mirror on this machine keeps model files in")
+	f.StringVar(&starter, "starter", starterName,
+		"the starter model: "+strings.Join(starterNames(), ", ")+", or hf:<owner>/<repo>/<file>.gguf")
+	f.IntVar(&in.starterCtx, "starter-context", defaultContext, "the context, in tokens, a client may use of the starter model")
+	f.StringVar(&in.judge.Fail, "judge-fail", "closed",
+		"a request no judge read in time: closed refuses it, open serves it flagged")
+	f.StringVar(&judgeCats, "judge-categories", strings.Join(defaultJudgeCategories, ","),
+		"what the judge refuses, comma-separated, of: "+strings.Join(judgeCategories, ", "))
+	f.IntVar(&in.judge.Replicas, "judge-replicas", 2, "how many copies of the judge run, each on CPUs")
+	f.DurationVar(&in.judge.Budget, "judge-budget", 5*time.Second, "how long a request waits for the judge")
+	f.StringVar(&in.language, "language", "", "the portal's language for a browser that asks for neither: en or tr")
+	f.BoolVar(&in.signupOpen, "signup-open", false, "let anyone ask for an account on the portal, to be approved by an administrator")
+	f.IntVar(&in.defaultRPM, "default-rpm", defaultRPM, "requests a minute a key may make when nothing gives it a limit")
+	f.IntVar(&in.defaultTPM, "default-tpm", defaultTPM, "tokens a minute a key may use when nothing gives it a limit")
+	f.DurationVar(&in.maxKeyTTL, "max-key-ttl", defaultMaxKeyTTL, "the longest an API key lives")
+	f.BoolVar(&in.media, "media", false,
+		"pictures and 3D: the nodes install ComfyUI, and a picture model and a 3D model are added once a card fits one")
+	f.DurationVar(&in.evictAfterIdle, "evict-after-idle", 0,
+		"how long a model loaded on demand goes unasked-for before another may have its card (0: 2m)")
+	f.DurationVar(&in.minLifetime, "min-lifetime", 0,
+		"how long a model just loaded on demand is safe from that (0: 5m)")
+	f.BoolVar(&in.standbys, "standbys", false,
+		"with --patroni, make each of those machines a control plane too, standing by while this one leads")
+	f.StringVar(&in.vip, "vip", "",
+		"with --standbys, a floating address for whichever control plane leads, as 10.0.0.160/24 (keepalived on each)")
 	return cmd
 }

@@ -274,6 +333,11 @@ func (in *serverInit) run(ctx context.Context) error {
 			return fmt.Errorf("starter model: %w", err)
 		}
 	}
+	if in.standbys {
+		if err := in.ensureStandbys(ctx); err != nil {
+			return fmt.Errorf("standby control planes: %w", err)
+		}
+	}
 	in.nextSteps()
 	return nil
 }
@@ -310,29 +374,45 @@ func (in *serverInit) configJudgesWith(model string) bool {
 }

 // guardSection is server.yaml's guard: the baseline every request passes,
-// with the judge model when there is one.
+// with the judge model, as init sets it up unless told otherwise, when there
+// is one.
 func guardSection(judge bool) string {
-	j := `      # A judge model reads what patterns cannot: violence, weapons, abuse,
+	if !judge {
+		return guardSectionFor(nil)
+	}
+	j := (&serverInit{}).judgeFor()
+	return guardSectionFor(&j)
+}
+
+// guardSectionFor is server.yaml's guard with this judge, or none.
+func guardSectionFor(j *judgeSpec) string {
+	fail := "closed"
+	jb := `      # A judge model reads what patterns cannot: violence, weapons, abuse,
      # self-harm. Installed by init; --no-guard-model leaves it out.
      # judge: {model: ` + guardModelName + `, input: block, output: block, ...}
 `
-	if judge {
-		j = `      # A judge model reads what patterns cannot: violence, crime, sexual
-      # content, self-harm, jailbreaks. Two replicas run on CPUs, about two
+	if j != nil {
+		fail = j.Fail
+		copies := map[int]string{1: "One replica runs", 2: "Two replicas run", 3: "Three replicas run"}[j.Replicas]
+		if copies == "" {
+			copies = fmt.Sprintf("%d replicas run", j.Replicas)
+		}
+		jb = `      # A judge model reads what patterns cannot: violence, crime, sexual
+      # content, self-harm, jailbreaks. ` + copies + ` on CPUs, about two
      # seconds for a short text; an answer is read every 600 characters as
      # it streams. With fail: closed, a request no judge can read within
      # latency_budget is refused (503); open serves it, flagged, unjudged.
      # PII is the patterns' (above), and copyright, unethical acts and
-      # politically sensitive topics are left out: they refuse too much
-      # ordinary work. Controversial counts as safe; controversial: unsafe
-      # makes it count. With a GPU: llmgw ctl guard judge enable --gpu, then
-      # llmgw ctl guard judge use ` + defaultGPUJudge + ` ` + guardModelName + `.
+      # politically sensitive topics are left out unless chosen: they refuse
+      # too much ordinary work. Controversial counts as safe; controversial:
+      # unsafe makes it count. With a GPU: llmgw ctl guard judge enable --gpu,
+      # then llmgw ctl guard judge use ` + defaultGPUJudge + ` ` + guardModelName + `.
      judge:
        models: [` + guardModelName + `]
        input: block
        output: block
-        categories: [Violent, Non-violent Illegal Acts, Sexual Content or Sexual Acts, Suicide & Self-Harm, Jailbreak]
-        latency_budget: 5s
+        categories: [` + strings.Join(j.Categories, ", ") + `]
+        latency_budget: ` + durationYAML(j.Budget) + `
 `
 	}
 	return `# Guardrails (docs/guardrails.md). The baseline applies to every request;
@@ -342,13 +422,13 @@ guard:
  default: [baseline]
  policies:
    baseline:
-      fail: closed
+      fail: ` + fail + `
      input:
        pii: {secret: block, card: redact}
        injection: flag
      output:
        pii: {secret: block, card: redact}
-` + j
+` + jb
 }

 func (in *serverInit) done(format string, a ...any) {
@@ -527,6 +607,10 @@ func (in *serverInit) certHosts() []string {
 	for _, h := range in.hosts {
 		add(h)
 	}
+	// The floating address is this machine's whenever it leads.
+	if ip, _, err := net.ParseCIDR(in.vip); err == nil {
+		add(ip.String())
+	}
 	if name, err := os.Hostname(); err == nil {
 		add(name)
 	}
@@ -565,8 +649,13 @@ func (in *serverInit) ensureConfig(context.Context) error {
 		if contact == "" {
 			contact = "platform@example.com"
 		}
-		body := fmt.Sprintf(serverConfigTemplate, in.etcDir, in.etcDir, in.etcDir,
-			in.storeAddress(), contact, guardSection(in.judgeWanted()))
+		var judge *judgeSpec
+		if in.judgeWanted() {
+			j := in.judgeFor()
+			judge = &j
+		}
+		body := in.tuneConfig(fmt.Sprintf(serverConfigTemplate, in.etcDir, in.etcDir, in.etcDir,
+			in.storeAddress(), contact, guardSectionFor(judge)))
 		if err := os.WriteFile(path, []byte(body), 0o640); err != nil {
 			return err
 		}
@@ -0,0 +1,411 @@
+package cli
+
+import (
+	"fmt"
+	"math"
+	"net"
+	"path"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/agent/provision"
+)
+
+// What a first install lets a person choose beyond which parts it has: which
+// starter model, how the judge decides, what the portal speaks, the limits a
+// key starts with, and whether pictures and 3D come by themselves. Each zero
+// value is what init did before it could be chosen, so `llmgw server init`
+// with no flags installs what it always did.
+//
+// All of it is written into server.yaml when init writes it, and the cluster's
+// keys among it become the cluster's first settings when the control plane
+// first starts. A server.yaml already there is never overwritten, so a second
+// run changes none of it: the settings page and `llmgw ctl config` do.
+
+// starterSpec is a model init can fetch and serve so there is something to ask.
+type starterSpec struct {
+	Name, Alias, Source string
+	// SizeGB is the weights' size, for the memory a node needs; 0 is not known.
+	SizeGB float64
+	About  string
+}
+
+// starterChoices are the starters offered, smallest first: the first is the
+// default. Each is a single GGUF file, Q4_K_M.
+var starterChoices = []starterSpec{
+	{starterName, starterAlias, starterSource, 0.5, "answers at once on any CPU; fast, not clever"},
+	{"qwen2.5-1.5b-instruct", "qwen-1.5b", "hf:Qwen/Qwen2.5-1.5B-Instruct-GGUF/qwen2.5-1.5b-instruct-q4_k_m.gguf", 1.1,
+		"still quick on a CPU, and noticeably better"},
+	{"qwen2.5-3b-instruct", "qwen-3b", "hf:Qwen/Qwen2.5-3B-Instruct-GGUF/qwen2.5-3b-instruct-q4_k_m.gguf", 2.1,
+		"slow on a CPU, quick on any GPU"},
+	{"qwen3-4b", "", "hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf", 2.5,
+		"thinks before it answers; a GPU is worth having"},
+	{"qwen3-8b", "", "hf:Qwen/Qwen3-8B-GGUF/Qwen3-8B-Q4_K_M.gguf", 5.0,
+		"a real assistant; a GPU with 8 GB or more"},
+	{"qwen3-14b", "", "hf:Qwen/Qwen3-14B-GGUF/Qwen3-14B-Q4_K_M.gguf", 9.0,
+		"better still; a GPU with 16 GB or more"},
+}
+
+// starterFrom reads --starter: a name from starterChoices, or the hf: source
+// of any GGUF file, named after the file.
+func starterFrom(s string) (starterSpec, error) {
+	s = strings.TrimSpace(s)
+	for _, c := range starterChoices {
+		if s == c.Name || (c.Alias != "" && s == c.Alias) {
+			return c, nil
+		}
+	}
+	if rest, ok := strings.CutPrefix(s, "hf:"); ok && strings.Count(rest, "/") >= 2 && strings.HasSuffix(strings.ToLower(rest), ".gguf") {
+		name := strings.ToLower(strings.TrimSuffix(path.Base(rest), path.Ext(rest)))
+		return starterSpec{Name: name, Source: s, About: "chosen at install"}, nil
+	}
+	var names []string
+	for _, c := range starterChoices {
+		names = append(names, c.Name)
+	}
+	return starterSpec{}, fmt.Errorf("starter %q: one of %s, or hf:<owner>/<repo>/<file>.gguf", s, strings.Join(names, ", "))
+}
+
+func starterNames() []string {
+	var out []string
+	for _, c := range starterChoices {
+		out = append(out, c.Name)
+	}
+	return out
+}
+
+// readChoices takes the flags that are not read straight into init: the
+// starter by its name, the judge's categories by commas. Then it checks them
+// all.
+func (in *serverInit) readChoices(starter, categories string) error {
+	if strings.TrimSpace(starter) != "" {
+		s, err := starterFrom(starter)
+		if err != nil {
+			return err
+		}
+		in.starter = s
+	}
+	in.judge.Categories = nil
+	for _, c := range strings.Split(categories, ",") {
+		if c = strings.TrimSpace(c); c != "" {
+			in.judge.Categories = append(in.judge.Categories, c)
+		}
+	}
+	return in.checkChoices()
+}
+
+// checkChoices says what among the choices cannot be installed.
+func (in *serverInit) checkChoices() error {
+	switch in.language {
+	case "", "en", "tr":
+	default:
+		return fmt.Errorf("language %q: en or tr", in.language)
+	}
+	switch in.judge.Fail {
+	case "", "closed", "open":
+	default:
+		return fmt.Errorf("judge fail %q: closed or open", in.judge.Fail)
+	}
+	for _, c := range in.judge.Categories {
+		if !slices.Contains(judgeCategories, c) {
+			return fmt.Errorf("judge category %q: one of %s", c, strings.Join(judgeCategories, ", "))
+		}
+	}
+	switch {
+	case in.judge.Replicas < 0 || in.judge.Replicas > 8:
+		return fmt.Errorf("judge replicas %d: from 1 to 8", in.judge.Replicas)
+	case in.judge.Budget < 0 || in.judge.Budget > time.Minute:
+		return fmt.Errorf("judge budget %s: at most a minute", in.judge.Budget)
+	case in.starterCtx < 0 || in.starterCtx > 262144:
+		return fmt.Errorf("starter context %d: at most 262144 tokens", in.starterCtx)
+	case in.starterCtx > 0 && in.starterCtx < 512:
+		return fmt.Errorf("starter context %d: at least 512 tokens", in.starterCtx)
+	case in.defaultRPM < 0 || in.defaultTPM < 0:
+		return fmt.Errorf("default limits cannot be negative")
+	case in.maxKeyTTL < 0 || (in.maxKeyTTL > 0 && in.maxKeyTTL < time.Hour):
+		return fmt.Errorf("max key ttl %s: an hour at least", in.maxKeyTTL)
+	case in.evictAfterIdle < 0 || in.minLifetime < 0:
+		return fmt.Errorf("on-demand times cannot be negative")
+	case in.vip != "" && !in.standbys:
+		return fmt.Errorf("a floating address moves between control planes: it needs the standbys")
+	}
+	if in.vip != "" {
+		ip, _, err := net.ParseCIDR(in.vip)
+		if err != nil || ip.To4() == nil {
+			return fmt.Errorf("floating address %q: an IPv4 address with its prefix, as 10.0.0.160/24", in.vip)
+		}
+	}
+	return nil
+}
+
+// starterModelSpec is the starter this install serves.
+func (in *serverInit) starterModelSpec() starterSpec {
+	if in.starter.Source == "" {
+		return starterChoices[0]
+	}
+	return in.starter
+}
+
+// minMemoryGB is what a node needs free for the starter: its weights and
+// room for its context, never less than the 2 GB it always asked.
+func (s starterSpec) minMemoryGB() int {
+	return max(2, int(math.Ceil(s.SizeGB+1.5)))
+}
+
+// defaultContext is the context a client may use of the starter.
+const defaultContext = 4096
+
+// starterContext is the context a client may use of the starter.
+func (in *serverInit) starterContext() int {
+	if in.starterCtx > 0 {
+		return in.starterCtx
+	}
+	return defaultContext
+}
+
+// judgeSpec is how the guardrails' judge decides.
+type judgeSpec struct {
+	// Fail is what is done with a request no judge read in time: closed
+	// refuses it, open serves it flagged.
+	Fail       string
+	Categories []string
+	Replicas   int
+	Budget     time.Duration
+}
+
+// judgeCategories are the ones a judge can be asked about, as Qwen3Guard
+// names them; defaultJudgeCategories those it is asked about unless told.
+var (
+	judgeCategories = []string{"Violent", "Non-violent Illegal Acts", "Sexual Content or Sexual Acts",
+		"Suicide & Self-Harm", "Jailbreak", "PII", "Unethical Acts", "Politically Sensitive Topics", "Copyright Violation"}
+	defaultJudgeCategories = judgeCategories[:5]
+)
+
+// judgeFor is the judge as this install sets it up, the defaults filled in.
+func (in *serverInit) judgeFor() judgeSpec {
+	j := in.judge
+	if j.Fail == "" {
+		j.Fail = "closed"
+	}
+	if len(j.Categories) == 0 {
+		j.Categories = defaultJudgeCategories
+	}
+	if j.Replicas <= 0 {
+		j.Replicas = 2
+		if in.singleMachine() {
+			j.Replicas = 1
+		}
+	}
+	if j.Budget <= 0 {
+		j.Budget = 5 * time.Second
+	}
+	return j
+}
+
+// singleMachine is an install where this machine is the only node there
+// will be, as far as init knows: a second judge replica there shares the
+// same cores and is lost with the same machine, so it buys nothing but
+// half the speed of each.
+func (in *serverInit) singleMachine() bool {
+	return !in.noNode && !in.standbys && len(in.patroni) == 0 && len(in.patroniNodes) == 0
+}
+
+// The configuration's limits, as init writes them unless told otherwise.
+const (
+	defaultRPM       = 60
+	defaultTPM       = 200000
+	defaultMaxKeyTTL = 2160 * time.Hour
+)
+
+// tuneConfig writes this install's choices into the server.yaml template:
+// the lines the template has, changed, and the blocks it has not, added.
+// Unchosen, the template comes back as it was.
+func (in *serverInit) tuneConfig(body string) string {
+	set := func(old, now string) {
+		if old != now {
+			body = strings.Replace(body, old, now, 1)
+		}
+	}
+	if in.signupOpen {
+		set("  signup_open: false", "  signup_open: true")
+	}
+	if in.defaultRPM > 0 {
+		set("  default_rpm: 60", "  default_rpm: "+strconv.Itoa(in.defaultRPM))
+	}
+	if in.defaultTPM > 0 {
+		set("  default_tpm: 200000", "  default_tpm: "+strconv.Itoa(in.defaultTPM))
+	}
+	if in.maxKeyTTL > 0 && in.maxKeyTTL != defaultMaxKeyTTL {
+		set("  max_key_ttl: 2160h   # 90 days", fmt.Sprintf("  max_key_ttl: %s   # %s", durationYAML(in.maxKeyTTL), days(in.maxKeyTTL)))
+	}
+	if in.language != "" {
+		set("  # language: tr", "  language: "+in.language)
+	}
+	var extra []string
+	if in.media {
+		extra = append(extra, "# Pictures and 3D, chosen at install: the nodes install ComfyUI, and the\n"+
+			"# leader adds a picture model and a 3D model by itself once a card fits\n"+
+			"# one ('llmgw ctl model presets auto off' stops it).\n"+
+			"engines:\n  comfyui: "+provision.ComfyUIVersion()+"\npresets:\n  auto: true\n")
+	}
+	if in.evictAfterIdle > 0 || in.minLifetime > 0 {
+		b := "# How models that load when asked for take turns on a card, chosen at\n# install.\non_demand:\n"
+		if in.evictAfterIdle > 0 {
+			b += "  evict_after_idle: " + durationYAML(in.evictAfterIdle) + "\n"
+		}
+		if in.minLifetime > 0 {
+			b += "  min_lifetime: " + durationYAML(in.minLifetime) + "\n"
+		}
+		extra = append(extra, b)
+	}
+	if len(extra) > 0 {
+		body += "\n" + strings.Join(extra, "\n")
+	}
+	return body
+}
+
+// durationYAML is a duration as a person writes it: 2h, 90m, 1m30s.
+func durationYAML(d time.Duration) string {
+	switch {
+	case d == 0:
+		return "0s"
+	case d%time.Hour == 0:
+		return fmt.Sprintf("%dh", d/time.Hour)
+	case d%time.Minute == 0:
+		return fmt.Sprintf("%dm", d/time.Minute)
+	}
+	return d.String()
+}
+
+func days(d time.Duration) string {
+	n := int(d.Hours() / 24)
+	if n == 1 {
+		return "1 day"
+	}
+	return fmt.Sprintf("%d days", n)
+}
+
+// initFlags is this install as `llmgw server init`'s flags, for doing it
+// again from a script; what is left at its default is left out.
+func (in *serverInit) initFlags() []string {
+	var out []string
+	add := func(flag string, v ...string) {
+		if len(v) == 0 {
+			out = append(out, flag)
+			return
+		}
+		out = append(out, flag+" "+shellWord(v[0]))
+	}
+	if in.admin != "" {
+		add("--admin", in.admin)
+	}
+	for _, h := range in.hosts {
+		add("--host", h)
+	}
+	if in.language != "" {
+		add("--language", in.language)
+	}
+	if in.signupOpen {
+		add("--signup-open")
+	}
+	if in.defaultRPM > 0 && in.defaultRPM != defaultRPM {
+		add("--default-rpm", strconv.Itoa(in.defaultRPM))
+	}
+	if in.defaultTPM > 0 && in.defaultTPM != defaultTPM {
+		add("--default-tpm", strconv.Itoa(in.defaultTPM))
+	}
+	if in.maxKeyTTL > 0 && in.maxKeyTTL != defaultMaxKeyTTL {
+		add("--max-key-ttl", durationYAML(in.maxKeyTTL))
+	}
+	if in.postgres {
+		add("--postgres")
+	}
+	for _, t := range in.patroni {
+		add("--patroni", t)
+	}
+	switch {
+	case in.mirrorURL != "":
+		add("--mirror", in.mirrorURL)
+	case in.noMirror:
+		add("--no-mirror")
+	case in.mirrorPath != "" && in.mirrorPath != mirrorDir:
+		add("--mirror-dir", in.mirrorPath)
+	}
+	if in.bundle != "" {
+		add("--bundle", in.bundle)
+		add("--bundle-sha256", in.bundleSHA)
+	}
+	if in.noNode {
+		add("--no-node")
+	}
+	if in.noModel {
+		add("--no-model")
+	} else {
+		if s := in.starterModelSpec(); s.Name != starterName {
+			v := s.Name
+			if !slices.ContainsFunc(starterChoices, func(c starterSpec) bool { return c.Name == s.Name }) {
+				v = s.Source
+			}
+			add("--starter", v)
+		}
+		if in.starterCtx > 0 && in.starterCtx != defaultContext {
+			add("--starter-context", strconv.Itoa(in.starterCtx))
+		}
+	}
+	if in.noGuardModel {
+		add("--no-guard-model")
+	} else {
+		// Against the defaults for an install of the same shape: one judge
+		// on one machine, two otherwise.
+		shape := serverInit{noNode: in.noNode, standbys: in.standbys, patroni: in.patroni, patroniNodes: in.patroniNodes}
+		j, d := in.judgeFor(), shape.judgeFor()
+		if j.Fail != d.Fail {
+			add("--judge-fail", j.Fail)
+		}
+		if !slices.Equal(j.Categories, d.Categories) {
+			add("--judge-categories", strings.Join(j.Categories, ","))
+		}
+		if j.Replicas != d.Replicas {
+			add("--judge-replicas", strconv.Itoa(j.Replicas))
+		}
+		if j.Budget != d.Budget {
+			add("--judge-budget", durationYAML(j.Budget))
+		}
+	}
+	if in.noFirewall {
+		add("--no-firewall")
+	}
+	if in.standbys {
+		add("--standbys")
+	}
+	if in.vip != "" {
+		add("--vip", in.vip)
+	}
+	for _, w := range in.webhooks {
+		for _, s := range strings.Split(w, ",") {
+			if s = strings.TrimSpace(s); s != "" {
+				add("--webhook", s)
+			}
+		}
+	}
+	if in.media {
+		add("--media")
+	}
+	if in.evictAfterIdle > 0 {
+		add("--evict-after-idle", durationYAML(in.evictAfterIdle))
+	}
+	if in.minLifetime > 0 {
+		add("--min-lifetime", durationYAML(in.minLifetime))
+	}
+	return out
+}
+
+// shellWord quotes a word for a shell when it needs it.
+func shellWord(s string) string {
+	if s != "" && !strings.ContainsAny(s, " \t\n'\"\\$`&;|<>(){}*?[]#~!") {
+		return s
+	}
+	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
+}
@@ -0,0 +1,241 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/config"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/pgha"
+)
+
+func TestEveryChoiceIsInTheConfigurationWrittenAndItLoads(t *testing.T) {
+	in := &serverInit{
+		language: "tr", signupOpen: true, defaultRPM: 120, defaultTPM: 50000, maxKeyTTL: 30 * 24 * time.Hour,
+		media: true, evictAfterIdle: time.Minute, minLifetime: 90 * time.Second,
+		judge: judgeSpec{Fail: "open", Categories: []string{"Violent", "PII"}, Replicas: 3, Budget: 3 * time.Second},
+	}
+	j := in.judgeFor()
+	body := in.tuneConfig(fmt.Sprintf(serverConfigTemplate, "/etc/llmgw", "/etc/llmgw", "/etc/llmgw",
+		"/var/lib/llmgw/llmgw.db", "ops@example.com", guardSectionFor(&j)))
+	path := filepath.Join(t.TempDir(), "server.yaml")
+	if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	cfg, err := config.Load(path)
+	if err != nil {
+		t.Fatalf("%v\n%s", err, body)
+	}
+	if err := cfg.Validate(); err != nil {
+		t.Fatal(err)
+	}
+	switch {
+	case cfg.Landing.Language != "tr" || !cfg.Auth.SignupOpen:
+		t.Errorf("language %q signup %v", cfg.Landing.Language, cfg.Auth.SignupOpen)
+	case cfg.Auth.DefaultRPM != 120 || cfg.Auth.DefaultTPM != 50000 || cfg.Auth.MaxKeyTTL != 30*24*time.Hour:
+		t.Errorf("limits %d %d %s", cfg.Auth.DefaultRPM, cfg.Auth.DefaultTPM, cfg.Auth.MaxKeyTTL)
+	case !cfg.Presets.Auto || cfg.Engines["comfyui"] == "":
+		t.Errorf("pictures and 3D: presets %v comfyui %q", cfg.Presets.Auto, cfg.Engines["comfyui"])
+	case cfg.OnDemand.EvictAfterIdle != time.Minute || cfg.OnDemand.MinLifetime != 90*time.Second:
+		t.Errorf("on demand %+v", cfg.OnDemand)
+	}
+	base := cfg.Guard.Policies["baseline"]
+	if base.Fail != "open" || base.Judge == nil || !slices.Equal(base.Judge.Categories, []string{"Violent", "PII"}) ||
+		base.Judge.LatencyBudget != 3*time.Second {
+		t.Errorf("the judge as written: fail %q %+v", base.Fail, base.Judge)
+	}
+	if !strings.Contains(body, "Three replicas run on CPUs") {
+		t.Error("the comment says another number of judges than run")
+	}
+}
+
+func TestNothingChosenIsTheTemplateAsItWas(t *testing.T) {
+	body := fmt.Sprintf(serverConfigTemplate, "/e", "/e", "/e", "/s.db", "a@b", guardSection(true))
+	if got := (&serverInit{}).tuneConfig(body); got != body {
+		t.Error("an install with nothing chosen writes another configuration than before")
+	}
+	// Each line tuneConfig changes is in the template, or a choice would be
+	// lost without a word.
+	for _, line := range []string{"  signup_open: false", "  default_rpm: 60", "  default_tpm: 200000",
+		"  max_key_ttl: 2160h   # 90 days", "  # language: tr"} {
+		if !strings.Contains(serverConfigTemplate, line) {
+			t.Errorf("the template has no %q", line)
+		}
+	}
+}
+
+func TestAStarterIsChosenByNameOrByItsFile(t *testing.T) {
+	s, err := starterFrom("qwen3-8b")
+	if err != nil || s.SizeGB != 5.0 || !strings.HasPrefix(s.Source, "hf:Qwen/Qwen3-8B-GGUF/") {
+		t.Errorf("by name: %+v %v", s, err)
+	}
+	s, err = starterFrom("hf:bartowski/Phi-4-GGUF/Phi-4-Q4_K_M.gguf")
+	if err != nil || s.Name != "phi-4-q4_k_m" {
+		t.Errorf("by file: %+v %v", s, err)
+	}
+	if _, err := starterFrom("gpt-5"); err == nil {
+		t.Error("a model nobody offers was taken")
+	}
+	m := starterModel(s, 8192, 0, "http://x/p.gguf", []string{"6000-24g"}, true)
+	if m.Name != "phi-4-q4_k_m" || m.ContextLength != 8192 || len(m.Aliases) != 0 ||
+		!slices.Equal(m.Profiles[0].Args, []string{"--ctx-size", "32768"}) {
+		t.Errorf("entry %+v", m)
+	}
+	big, _ := starterFrom("qwen3-14b")
+	if m := starterModel(big, 16384, 0, "http://x/q.gguf", nil, true); m.Profiles[0].MinMemoryGB != 11 ||
+		!slices.Equal(m.Profiles[0].Args, []string{"--ctx-size", "65536"}) {
+		t.Errorf("a 9 GB starter asks for %d GB, %v", m.Profiles[0].MinMemoryGB, m.Profiles[0].Args)
+	}
+}
+
+func TestTheChoicesAreTheirFlagsAgain(t *testing.T) {
+	in := &serverInit{admin: "ops@example.com", hosts: []string{"llm.example.com"}, postgres: true,
+		mirrorPath: "/data/models", noNode: true, language: "tr", media: true,
+		webhooks: []string{"https://hooks.slack.com/services/T/B/x, json:https://a.example.com/in"},
+		judge:    judgeSpec{Categories: []string{"Violent", "Jailbreak"}}, maxKeyTTL: 7 * 24 * time.Hour}
+	in.starter, _ = starterFrom("qwen3-4b")
+	got := strings.Join(in.initFlags(), " ")
+	want := "--admin ops@example.com --host llm.example.com --language tr --max-key-ttl 168h --postgres " +
+		"--mirror-dir /data/models --no-node --starter qwen3-4b --judge-categories Violent,Jailbreak " +
+		"--webhook https://hooks.slack.com/services/T/B/x --webhook json:https://a.example.com/in --media"
+	if got != want {
+		t.Errorf("flags\n got %s\nwant %s", got, want)
+	}
+	if got := strings.Join((&serverInit{}).initFlags(), " "); got != "" {
+		t.Errorf("nothing chosen is %q", got)
+	}
+	if w := shellWord("Non-violent Illegal Acts,PII"); w != "'Non-violent Illegal Acts,PII'" {
+		t.Errorf("quoted %s", w)
+	}
+}
+
+func TestChoicesThatCannotBeInstalledAreRefused(t *testing.T) {
+	for _, in := range []serverInit{
+		{language: "de"},
+		{judge: judgeSpec{Fail: "maybe"}},
+		{judge: judgeSpec{Categories: []string{"Rudeness"}}},
+		{judge: judgeSpec{Replicas: 9}},
+		{starterCtx: 100},
+		{maxKeyTTL: time.Minute},
+		{vip: "10.0.0.160/24"},
+		{standbys: true, vip: "10.0.0.160"},
+	} {
+		if err := in.checkChoices(); err == nil {
+			t.Errorf("taken: %+v", in)
+		}
+	}
+	if err := (&serverInit{standbys: true, vip: "10.0.0.160/24"}).checkChoices(); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestWithStandbysTheMirrorAnswersEveryControlPlane(t *testing.T) {
+	in := &serverInit{hosts: []string{"10.0.0.5"}, patroniNodes: []pgha.Node{
+		{Member: pgha.Member{Name: "db1", IP: "10.0.0.6"}}, {Member: pgha.Member{Name: "db2", IP: "10.0.0.7"}},
+	}}
+	if u := in.mirrorUnit(); !strings.Contains(u, "--api-listen 127.0.0.1:8082") || strings.Contains(u, "--api-allow") {
+		t.Errorf("one control plane: the API is for this machine only:\n%s", u)
+	}
+	in.standbys = true
+	u := in.mirrorUnit()
+	for _, want := range []string{"--api-listen :8082", "--api-allow 10.0.0.5", "--api-allow 10.0.0.6", "--api-allow 10.0.0.7"} {
+		if !strings.Contains(u, want) {
+			t.Errorf("the unit lacks %q:\n%s", want, u)
+		}
+	}
+	if got := in.mirrorAPIURL(); got != "http://10.0.0.5:8082" {
+		t.Errorf("the control planes reach the mirror at %s", got)
+	}
+}
+
+func TestTheFloatingAddressIsInTheCertificate(t *testing.T) {
+	in := &serverInit{vip: "10.0.0.160/24"}
+	if !slices.Contains(in.certHosts(), "10.0.0.160") {
+		t.Errorf("hosts %v", in.certHosts())
+	}
+}
+
+func TestStandbysWantTheStoresMachines(t *testing.T) {
+	in := &serverInit{standbys: true, out: &strings.Builder{}}
+	if err := in.ensureStandbys(context.Background()); err == nil || !strings.Contains(err.Error(), "--patroni") {
+		t.Errorf("standbys with nowhere to go: %v", err)
+	}
+}
+
+func TestTwoClustersOnOneNetworkKeepApartFloatingAddresses(t *testing.T) {
+	a, b := vrrpRouterID("10.0.0.161"), vrrpRouterID("10.0.0.164")
+	if a == b || a < 1 || a > 255 || b < 1 || b > 255 {
+		t.Errorf("router ids %d and %d", a, b)
+	}
+	conf := keepalivedConf("ens18", "10.0.0.164", 24, 100, "secret12")
+	if !strings.Contains(conf, fmt.Sprintf("virtual_router_id %d\n", b)) || !strings.Contains(conf, "interface ens18") {
+		t.Errorf("conf:\n%s", conf)
+	}
+}
+
+func TestTheJudgesAndTheStarterShareTheCPUsRatherThanEachTakingAll(t *testing.T) {
+	for _, c := range []struct {
+		in             serverInit
+		judge, starter int
+	}{
+		// One machine: one judge, on up to four cores; the starter has the rest.
+		{serverInit{cpus: 4}, 4, 0},
+		{serverInit{cpus: 8}, 4, 4},
+		{serverInit{cpus: 32}, 4, 8},
+		{serverInit{cpus: 2}, 2, 0},
+		{serverInit{cpus: 1}, 0, 0},
+		{serverInit{cpus: 4, noGuardModel: true}, judgeCores, 4}, // no judge: all for the starter
+		// Two asked for on one machine: two cores each, one each where two
+		// would not fit both.
+		{serverInit{cpus: 8, judge: judgeSpec{Replicas: 2}}, 2, 4},
+		{serverInit{cpus: 2, judge: judgeSpec{Replicas: 2}}, 1, 0},
+		{serverInit{cpus: 8, judge: judgeSpec{Replicas: 3}}, 2, 2},
+		{serverInit{cpus: 4, noNode: true}, 2, 0}, // on nodes not known yet
+	} {
+		got := c.in.cpuPlan()
+		if got.judge != c.judge || got.starter != c.starter {
+			t.Errorf("%+v: judge %d starter %d, want %d %d", c.in, got.judge, got.starter, c.judge, c.starter)
+		}
+	}
+	m := guardModel("http://x/g.gguf", 2, 1)
+	if p := m.Profiles[0]; p.CPUCores != 1 || p.MinMemoryGB != 2 || !slices.Contains(p.Args, "--cache-ram") {
+		t.Errorf("judge profile: %d cores, %d GB, args %v", p.CPUCores, p.MinMemoryGB, p.Args)
+	}
+	s := starterModel(starterChoices[0], defaultContext, 2, "http://x/q.gguf", []string{"6000-24g"}, true)
+	if cpu := s.Profiles[len(s.Profiles)-1]; cpu.Name != "cpu" || cpu.CPUCores != 2 || s.Profiles[0].CPUCores != 0 {
+		t.Errorf("starter: GPU profile %d cores, CPU %+v", s.Profiles[0].CPUCores, cpu)
+	}
+}
+
+// A second judge on the same machine shares its cores and is lost with it:
+// one machine has one, more machines two.
+func TestOneMachineHasOneJudgeAndMoreHaveTwo(t *testing.T) {
+	for _, c := range []struct {
+		in   serverInit
+		want int
+	}{
+		{serverInit{}, 1},
+		{serverInit{noNode: true}, 2},
+		{serverInit{patroni: []string{"a@db1", "b@db2"}}, 2},
+		{serverInit{standbys: true}, 2},
+		{serverInit{judge: judgeSpec{Replicas: 3}}, 3},
+	} {
+		if got := c.in.judgeFor().Replicas; got != c.want {
+			t.Errorf("%+v: %d judges, want %d", c.in, got, c.want)
+		}
+	}
+	// The defaults are left out of the command; a choice against them is in.
+	ha := serverInit{noNode: true, patroni: []string{"a@db1", "b@db2"}, judge: judgeSpec{Replicas: 2}}
+	if f := strings.Join(ha.initFlags(), " "); strings.Contains(f, "--judge-replicas") {
+		t.Errorf("two judges on three machines named: %s", f)
+	}
+	one := serverInit{judge: judgeSpec{Replicas: 2}}
+	if f := strings.Join(one.initFlags(), " "); !strings.Contains(f, "--judge-replicas 2") {
+		t.Errorf("two judges on one machine not named: %s", f)
+	}
+}
@@ -9,7 +9,9 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"slices"
+	"strconv"
 	"strings"
 	"time"

@@ -120,10 +122,36 @@ func (in *serverInit) writeUnit(path, body string) (bool, error) {

 func (in *serverInit) mirrorUnit() string {
 	base := "http://" + net.JoinHostPort(in.reachableAddr(), "8081")
-	return mirrorUnitFor(mirrorDir, mirrorAPI, base, nil,
+	if in.standbys {
+		return mirrorUnitFor(in.mirrorRoot(), ":8082", base, in.mirrorAllow(),
+			"'llmgw server init'. Bytes on :8081 for every node; the\n# management API for the control planes only, whichever leads.")
+	}
+	return mirrorUnitFor(in.mirrorRoot(), mirrorAPI, base, nil,
 		"'llmgw server init'. Bytes on :8081 for every node; the\n# management API on loopback only, for the control plane beside it.")
 }

+// localMirrorAPI is the management API of the mirror beside this control
+// plane: on loopback, or, with standbys that may lead instead, on an address
+// they reach.
+func (in *serverInit) localMirrorAPI() string {
+	if in.standbys {
+		return "http://" + net.JoinHostPort(in.reachableAddr(), "8082")
+	}
+	return "http://" + mirrorAPI
+}
+
+// mirrorAllow are the control planes the mirror's management API answers
+// besides loopback: this one by its own address, and each standby.
+func (in *serverInit) mirrorAllow() []string {
+	out := []string{in.reachableAddr()}
+	for _, n := range in.patroniNodes {
+		if !slices.Contains(out, n.IP) {
+			out = append(out, n.IP)
+		}
+	}
+	return out
+}
+
 // mirrorUnitFor is a mirror's systemd unit. allow is who, besides the
 // machine itself, may use the management API.
 func mirrorUnitFor(dir, apiListen, base string, allow []string, about string) string {
@@ -160,7 +188,7 @@ func (in *serverInit) mirrorAPIURL() string {
 	if in.mirrorURL != "" {
 		return in.mirrorURL
 	}
-	return "http://" + mirrorAPI
+	return in.localMirrorAPI()
 }

 // useMirror points the control plane at a mirror on another machine, set up
@@ -202,15 +230,16 @@ func (in *serverInit) ensureMirror(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	if cfg.Mirror.API != "" && cfg.Mirror.API != "http://"+mirrorAPI {
+	if cfg.Mirror.API != "" && cfg.Mirror.API != "http://"+mirrorAPI && cfg.Mirror.API != in.localMirrorAPI() {
 		in.kept("mirror at %s, as server.yaml says", cfg.Mirror.API)
 		return nil
 	}

-	if err := os.MkdirAll(mirrorDir, 0o755); err != nil {
+	dir := in.mirrorRoot()
+	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-	if err := in.chown(mirrorDir, true); err != nil {
+	if err := in.chown(dir, true); err != nil {
 		return err
 	}
 	changed, err := in.writeUnit(mirrorUnitPath, in.mirrorUnit())
@@ -227,21 +256,25 @@ func (in *serverInit) ensureMirror(ctx context.Context) error {
 		if err := in.systemctl(ctx, "restart", "llmgw-mirror"); err != nil {
 			return err
 		}
-		in.done("model mirror in %s, serving on :8081", mirrorDir)
+		in.done("model mirror in %s, serving on :8081", dir)
 	} else {
-		in.kept("model mirror in %s", mirrorDir)
+		in.kept("model mirror in %s", dir)
 	}

 	if cfg.Mirror.API == "" {
-		if err := appendMirrorBlockFor(in.configPath(), "http://"+mirrorAPI,
-			"# The model mirror on this machine, added by 'llmgw server init'. Its\n"+
-				"# management API is on loopback, so it needs no certificate."); err != nil {
+		comment := "# The model mirror on this machine, added by 'llmgw server init'. Its\n" +
+			"# management API is on loopback, so it needs no certificate."
+		if in.standbys {
+			comment = "# The model mirror on this machine, added by 'llmgw server init'. Its\n" +
+				"# management API answers the control planes' addresses only."
+		}
+		if err := appendMirrorBlockFor(in.configPath(), in.localMirrorAPI(), comment); err != nil {
 			return err
 		}
 		in.done("server.yaml points at the mirror")
 	}

-	m, err := mirror.NewClient("http://"+mirrorAPI, tlsconf.Config{}, 5*time.Second)
+	m, err := mirror.NewClient(in.localMirrorAPI(), tlsconf.Config{}, 5*time.Second)
 	if err != nil {
 		return err
 	}
@@ -414,8 +447,9 @@ func hasNVIDIADevice() bool {
 // --- the starter model ---

 // starterModel is the catalog entry: a GPU profile first when there is a card,
-// and a CPU profile always, both pinned to this machine.
-func starterModel(source string, gpuClasses []string, pinned bool) catalog.Model {
+// and a CPU profile always, both pinned to this machine. ctx is the context a
+// client may use; each engine holds four times that, for four at once.
+func starterModel(spec starterSpec, ctx, cores int, source string, gpuClasses []string, pinned bool) catalog.Model {
 	var pin map[string]string
 	if pinned {
 		pin = map[string]string{localLabelKey: localLabelValue}
@@ -424,21 +458,25 @@ func starterModel(source string, gpuClasses []string, pinned bool) catalog.Model
 	for _, class := range gpuClasses {
 		profiles = append(profiles, catalog.Profile{
 			Name: "gpu-" + class, Engine: "llamacpp", GPUClass: class,
-			Priority: 200, MinMemoryGB: 2, NodeSelector: pin,
-			Args: []string{"--ctx-size", "32768"},
+			Priority: 200, MinMemoryGB: spec.minMemoryGB(), NodeSelector: pin,
+			Args: []string{"--ctx-size", strconv.Itoa(max(32768, 4*ctx))},
 		})
 	}
 	profiles = append(profiles, catalog.Profile{
-		Name: "cpu", Engine: "llamacpp", Priority: 100, MinMemoryGB: 2, NodeSelector: pin,
-		Args: []string{"--ctx-size", "16384"},
+		Name: "cpu", Engine: "llamacpp", Priority: 100, MinMemoryGB: spec.minMemoryGB(), CPUCores: cores, NodeSelector: pin,
+		Args: []string{"--ctx-size", strconv.Itoa(max(16384, 4*ctx))},
 	})
+	var aliases []string
+	if spec.Alias != "" {
+		aliases = []string{spec.Alias}
+	}
 	return catalog.Model{
-		Name:           starterName,
-		Aliases:        []string{starterAlias},
-		Description:    "A small model init put here so there is something to try; fast, not clever.",
+		Name:           spec.Name,
+		Aliases:        aliases,
+		Description:    "The model init put here so there is something to try: " + spec.About + ".",
 		Source:         source,
 		RoutingProfile: "chat",
-		ContextLength:  4096,
+		ContextLength:  ctx,
 		MaxOutput:      1024,
 		Scaling:        catalog.Scaling{Min: 1, Max: 1},
 		Profiles:       profiles,
@@ -446,8 +484,8 @@ func starterModel(source string, gpuClasses []string, pinned bool) catalog.Model
 }

 // guardModel is the judge's catalog entry: CPU only, so it takes no card from
-// the models people use, on whichever node has room.
-func guardModel(source string) catalog.Model {
+// the models people use, on whichever node has room; replicas copies of it.
+func guardModel(source string, replicas, cores int) catalog.Model {
 	return catalog.Model{
 		Name:        guardModelName,
 		Description: "The guardrails' judge: reads prompts and answers for unsafe content. Not offered to clients.",
@@ -456,10 +494,15 @@ func guardModel(source string) catalog.Model {
 		Guard:       &catalog.GuardModel{Format: "qwen3guard"},
 		// Two: every judged request waits on it, and with fail: closed a
 		// judge that is not there refuses everything.
-		Scaling: catalog.Scaling{Min: 2, Max: 2},
+		Scaling: catalog.Scaling{Min: replicas, Max: replicas},
 		Profiles: []catalog.Profile{{
-			Name: "cpu", Engine: "llamacpp", Priority: 100, MinMemoryGB: 2,
-			Args: []string{"--ctx-size", "8192"},
+			// About 1.6 GB with its context, which stays so with no prompt
+			// cache: llama.cpp keeps up to 8 GB of prompts by default, and a
+			// judge's, each a different text, are not asked again. With the
+			// cache one grew to 3.2 GB over a day of traffic; reserving 4 for
+			// that left a 7 GB machine room for only one of the two.
+			Name: "cpu", Engine: "llamacpp", Priority: 100, MinMemoryGB: judgeMemoryGB, CPUCores: cores,
+			Args: []string{"--ctx-size", "8192", "--cache-ram", "0"},
 		}},
 	}
 }
@@ -469,15 +512,20 @@ func (in *serverInit) ensureStarter(ctx context.Context) error {
 	// Served here when this machine is a node, pinned so it does not wander
 	// to the first GPU node that joins; otherwise on whichever node joins.
 	pinned := !in.noNode
-	return in.ensureServed(ctx, starterName, starterSource, starterVersion, pinned,
-		func(url string, classes []string) catalog.Model { return starterModel(url, classes, pinned) })
+	spec, n := in.starterModelSpec(), in.starterContext()
+	return in.ensureServed(ctx, spec.Name, spec.Source, starterVersion, pinned,
+		func(url string, classes []string) catalog.Model {
+			return starterModel(spec, n, in.cpuPlan().starter, url, classes, pinned)
+		})
 }

 // ensureGuardModel fetches the guardrails' judge model into the mirror and
 // adds it to the catalog, to run on any node with room.
 func (in *serverInit) ensureGuardModel(ctx context.Context) error {
 	return in.ensureServed(ctx, guardModelName, guardModelSource, guardModelVersion, false,
-		func(url string, _ []string) catalog.Model { return guardModel(url) })
+		func(url string, _ []string) catalog.Model {
+			return guardModel(url, in.judgeFor().Replicas, in.cpuPlan().judge)
+		})
 }

 // ensureServed fetches a model into the mirror, adds it to the catalog, and
@@ -661,3 +709,55 @@ func waitFor(ctx context.Context, limit time.Duration, what string, done func()
 		}
 	}
 }
+
+// cpuSplit is the cores init's models reserve: each judge replica's, and
+// the starter's on CPU.
+type cpuSplit struct{ judge, starter int }
+
+// cpuPlan divides the CPUs between the judges and the starter, so that the
+// engines do not each take every core. Without it, two judge replicas and
+// the starter on one 4-core control plane all ran on all four: under load
+// most judgments missed their budget and the requests were refused.
+//
+// A judge needs cores: a judgment of about 280 tokens took 8.0 s on one,
+// 4.2 s on two and 2.3 s on four, against a 5 s budget. On one machine its
+// one replica gets up to four; where there are two, two each (one each only
+// where two would not fit both). The starter has what is left, up to 8, or
+// no reservation at all when nothing is, rather than a starter that fits
+// nowhere. A machine that is not the node reserves two a judge on whichever
+// node takes it, and the starter, on a node not known yet, none.
+func (in *serverInit) cpuPlan() cpuSplit {
+	if in.noNode {
+		return cpuSplit{judge: judgeCores}
+	}
+	n := in.cpus
+	if n <= 0 {
+		n = runtime.NumCPU()
+	}
+	if n < 2 {
+		return cpuSplit{}
+	}
+	judges := 0
+	if !in.noGuardModel {
+		judges = in.judgeFor().Replicas
+	}
+	judge := judgeCores
+	switch {
+	case judges == 1:
+		judge = min(n, judgeCoresAlone)
+	case judges > 0 && judges*judge > n:
+		judge = max(1, n/judges)
+	}
+	left := max(n-judges*judge, 0)
+	return cpuSplit{judge: judge, starter: min(left, 8)}
+}
+
+// judgeCores and judgeMemoryGB are what a judge replica needs: two cores
+// for a judgment within its budget, and 2 GB for its 1.6 with no prompt
+// cache. judgeCoresAlone is what the one judge of a single machine takes,
+// past which a model this small hardly gets faster.
+const (
+	judgeCores      = 2
+	judgeCoresAlone = 4
+	judgeMemoryGB   = 2
+)
@@ -28,7 +28,7 @@ func TestTheInitAgentUnitIsTheShippedUnit(t *testing.T) {
 }

 func TestTheStarterUsesTheGPUAndFallsBackToCPUOnThisMachine(t *testing.T) {
-	m := starterModel("http://10.0.0.5:8081/qwen2.5-0.5b-instruct/starter/q.gguf", []string{"4090-24g"}, true)
+	m := starterModel(starterChoices[0], defaultContext, 0, "http://10.0.0.5:8081/qwen2.5-0.5b-instruct/starter/q.gguf", []string{"4090-24g"}, true)
 	c, err := catalog.New([]catalog.Model{m})
 	if err != nil {
 		t.Fatalf("the starter is not a valid catalog entry: %v", err)
@@ -53,7 +53,7 @@ func TestTheStarterUsesTheGPUAndFallsBackToCPUOnThisMachine(t *testing.T) {
 		t.Error("the starter should be running, not waiting to be asked for")
 	}

-	if m := starterModel("http://x/q.gguf", nil, true); len(m.Profiles) != 1 || m.Profiles[0].Name != "cpu" {
+	if m := starterModel(starterChoices[0], defaultContext, 0, "http://x/q.gguf", nil, true); len(m.Profiles) != 1 || m.Profiles[0].Name != "cpu" {
 		t.Errorf("without a GPU only the CPU profile: %+v", m.Profiles)
 	}
 }
@@ -96,7 +96,7 @@ func TestTheMirrorUnitAdvertisesAnAddressNodesCanReach(t *testing.T) {
 }

 func TestWithNoNodeHereTheStarterGoesToTheFirstNodeThatJoins(t *testing.T) {
-	m := starterModel("http://x/q.gguf", nil, false)
+	m := starterModel(starterChoices[0], defaultContext, 0, "http://x/q.gguf", nil, false)
 	for _, p := range m.Profiles {
 		if len(p.NodeSelector) > 0 {
 			t.Errorf("profile %s is pinned to a machine that is not a node: %v", p.Name, p.NodeSelector)
@@ -171,7 +171,7 @@ func TestTheInstalledConfigurationIsHardenedAndLoads(t *testing.T) {
 }

 func TestTheGuardModelIsAValidJudge(t *testing.T) {
-	m := guardModel("http://10.0.0.5:8081/qwen3guard-0.6b/guard/g.gguf")
+	m := guardModel("http://10.0.0.5:8081/qwen3guard-0.6b/guard/g.gguf", 2, 2)
 	c, err := catalog.New([]catalog.Model{m})
 	if err != nil {
 		t.Fatalf("not a valid catalog entry: %v", err)
@@ -51,6 +51,8 @@ func (in *serverInit) ensurePatroni(ctx context.Context) (err error) {
 			Remote: remote,
 		})
 	}
+	// Kept: the standbys are made control planes on the same machines.
+	in.patroniNodes = setup.DB
 	self, err := sourceIPToward(setup.DB[0].IP)
 	if err != nil {
 		return err
@@ -0,0 +1,39 @@
+package cli
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+)
+
+// Three machines, each able to take over: the store's two machines are made
+// control planes too, standing by while this one leads, as 'llmgw server add'
+// makes any machine one. With the store replicated across them and etcd's
+// three votes on the three, losing any one machine loses neither the store
+// nor the gateway. With a floating address, clients keep the one address.
+
+// ensureStandbys makes each machine of the replicated store a control plane,
+// one after the other.
+func (in *serverInit) ensureStandbys(ctx context.Context) error {
+	if len(in.patroniNodes) == 0 {
+		return errors.New("the standbys go on the store's machines: give them with --patroni")
+	}
+	var hosts []string
+	if ip, _, err := net.ParseCIDR(in.vip); err == nil {
+		hosts = []string{ip.String()}
+	}
+	for i, n := range in.patroniNodes {
+		fmt.Fprintf(in.out, "  ..    making %s a control plane too\n", n.Name)
+		sa := serverAdd{
+			etcDir: in.etcDir, pkiDir: in.pkiDir, hosts: hosts, vip: in.vip,
+			remote: n.Remote, noFirewall: in.noFirewall, addr: n.IP, ip: n.IP,
+			out: in.out, priority: 100 - 10*i, quiet: true,
+		}
+		if err := sa.run(ctx); err != nil {
+			return fmt.Errorf("%s: %w", n.Name, err)
+		}
+		in.done("%s (%s) is a control plane too, standing by while this one leads", n.Name, n.IP)
+	}
+	return nil
+}
@@ -0,0 +1,751 @@
+package cli
+
+import (
+	"fmt"
+	"net/mail"
+	"net/url"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/notify"
+)
+
+// The parts of an install, each chosen and each with its settings: what the
+// setup screens show before anything is installed, for one machine and for
+// three alike. Beside each part is what it is for and what is missing
+// without it; Enter opens its settings, which say the same at more length.
+
+type installPart struct {
+	title string
+	// about is what the part is, at the length its dialog has room for.
+	about string
+	// fixed parts are always installed: they have settings, not a box.
+	fixed bool
+	on    bool
+	// fields are its settings; none is a part only to tick.
+	fields []*setupField
+	// summary is a line of what it will be; off what is missing without it.
+	summary func() string
+	off     string
+	// needs, when set, says why the part cannot be had with the rest as
+	// chosen: a starter model with no mirror to fetch it into.
+	needs func() string
+}
+
+type installForm struct {
+	ha    bool
+	host  string
+	found []string
+	parts []*installPart
+	// focus is a part, or len(parts) for the button that goes on.
+	focus int
+	// open is the part whose settings are open in a dialog.
+	open   *installPart
+	dialog *setupDialog
+	// err is said in a dialog of its own; when errField is set, closing it
+	// opens that field's part with the focus on it.
+	err      string
+	errPart  *installPart
+	errField *setupField
+	height   int
+
+	standby *installPart
+	vipF    *setupField
+
+	control, store, mirror, node, starter, media, judge, firewall, alerts, limits, turns, bundle *installPart
+
+	admin, hosts, language, signup         *setupField
+	storeKind                              *setupField
+	mirrorWhere, mirrorDirF, mirrorURL     *setupField
+	starterPick, starterSource, starterCtx *setupField
+	judgeFail, judgeCopies, judgeBudget    *setupField
+	judgeCats                              []*setupField
+	webhooks                               *setupField
+	rpm, tpm, keyDays                      *setupField
+	idle, safe                             *setupField
+	bundlePath, bundleSHA                  *setupField
+}
+
+// newInstallForm is the parts as in has them: its flags, or the defaults.
+func newInstallForm(in *serverInit, host string, found []string, ha bool) *installForm {
+	f := &installForm{ha: ha, host: host, found: found, height: 24}
+
+	// --- the control plane ---
+	f.admin = textSetupField("Administrator's email", in.admin, "you@example.com",
+		"A password is made for this account and shown once, at the end.")
+	if !ha {
+		f.admin.Hint += " Leave it empty to make accounts later with 'llmgw users create'."
+	}
+	known := "none found"
+	if len(found) > 0 {
+		known = strings.Join(found, ", ")
+	}
+	f.hosts = textSetupField("Other names nodes reach this machine by", strings.Join(in.hosts, ", "),
+		"llm.example.com, 203.0.113.10",
+		"Already in its certificate: "+known+". Add a DNS name, a NAT address or a floating address, comma-separated.")
+	lang := 0
+	if in.language == "tr" {
+		lang = 1
+	}
+	f.language = choiceField("The portal speaks", []string{"English", "Türkçe"}, lang,
+		"To a browser that asks for neither. Each person can switch at the foot of any page.")
+	f.signup = choiceField("Sign-up form", []string{"closed", "open"}, map[bool]int{false: 0, true: 1}[in.signupOpen], "")
+	f.signup.Notes = []string{
+		"Accounts are made by an administrator, or come from single sign-on.",
+		"Anyone who reaches the portal can ask for an account; it waits for an administrator's approval.",
+	}
+	f.control = &installPart{
+		title: "Control plane", fixed: true, on: true,
+		about: "The gateway every request comes through, the admin API, the web portal on port 8080, and the " +
+			"certificate authority that signs every node's identity. Always installed: it is what llmgw is.\n\n" +
+			"Its authority's key stays in " + orText(in.pkiDir, defaultPKIDir) + " on this machine. Back it up: nothing recovers it.",
+		fields: []*setupField{f.admin, f.hosts, f.language, f.signup},
+		summary: func() string {
+			s := []string{}
+			if a := f.admin.Value(); a != "" {
+				s = append(s, "administrator "+a)
+			} else {
+				s = append(s, "no administrator")
+			}
+			s = append(s, f.language.Options[f.language.Choice], "sign-up "+f.signup.Options[f.signup.Choice])
+			return strings.Join(s, " · ")
+		},
+	}
+
+	// --- the store ---
+	f.storeKind = choiceField("Kept in", []string{"SQLite", "PostgreSQL"}, map[bool]int{false: 0, true: 1}[in.postgres], "")
+	f.storeKind.Notes = []string{
+		"A file on this machine. Nothing to look after; enough for one control plane and a team's traffic.",
+		"Installed here, with its own role and a generated password. For a larger store, or before adding a second control plane.",
+	}
+	f.store = &installPart{
+		title: "Store", fixed: true, on: true,
+		about: "Accounts, API keys, the catalog of models, usage and the cluster's settings live here.",
+		summary: func() string {
+			if ha {
+				return "PostgreSQL under Patroni, on the other two"
+			}
+			return f.storeKind.Options[f.storeKind.Choice] + " on this machine"
+		},
+	}
+	if ha {
+		f.store.about += "\n\nWith three machines it is PostgreSQL on the other two, replicated under Patroni: " +
+			"if the primary is lost the standby takes over in about thirty seconds, and the control plane follows. " +
+			"The machines are asked for on the next page."
+	} else {
+		f.store.fields = []*setupField{f.storeKind}
+	}
+
+	// --- control planes on all three ---
+	if ha {
+		f.vipF = textSetupField("Floating address", in.vip, "10.0.0.160/24",
+			"Optional. An unused address on these machines' network, with its prefix: keepalived keeps it on "+
+				"whichever control plane leads, and clients use it. Without one, put a load balancer in front, "+
+				"or give clients the three addresses.")
+		f.standby = &installPart{
+			title: "Control plane on all three", on: in.standbys,
+			about: "The two database machines become control planes too, standing by while this one leads. " +
+				"If the leader is lost, one of them takes over within seconds: it places models, and every node " +
+				"is told of it and fails over without being touched. With the store on two machines and etcd's " +
+				"three votes on the three, losing any one machine loses neither the store nor the gateway.\n\n" +
+				"The model mirror stays on this machine: while it is down, models the nodes already have keep " +
+				"serving, and new ones wait for it.",
+			fields: []*setupField{f.vipF},
+			off:    "the gateway runs on this machine only: if it is lost, the store survives but nothing is served until it is back",
+			summary: func() string {
+				if v := f.vipF.Value(); v != "" {
+					return "two standbys; " + v + " follows whichever leads"
+				}
+				return "two standbys; no floating address"
+			},
+		}
+	}
+
+	// --- the mirror ---
+	where := 0
+	if in.mirrorURL != "" {
+		where = 1
+	}
+	f.mirrorWhere = choiceField("Where", []string{"on this machine", "on another machine"}, where, "")
+	f.mirrorWhere.Notes = []string{
+		"Serves model files on port 8081 to every node; its management API is on loopback only.",
+		"Set up there first with 'llmgw mirror init --control-plane <this machine>'.",
+	}
+	f.mirrorDirF = textSetupField("Directory", orText(in.mirrorPath, mirrorDir), mirrorDir,
+		"Models are large: a 7B model is about 5 GB, a 70B about 40 GB. Put it on the biggest disk.")
+	f.mirrorDirF.Show = func() bool { return f.mirrorWhere.Choice == 0 }
+	f.mirrorURL = textSetupField("Its management API", in.mirrorURL, "http://10.0.0.20:8082", "")
+	f.mirrorURL.Show = func() bool { return f.mirrorWhere.Choice == 1 }
+	f.mirror = &installPart{
+		title: "Model mirror", on: !in.noMirror || in.mirrorURL != "",
+		about: "Downloads each model once, from Hugging Face or wherever it comes from, and serves the files to " +
+			"every node on the network, so ten nodes do not download the same 40 GB ten times. " +
+			"The starter model, the judge and an offline bundle go into it.",
+		fields: []*setupField{f.mirrorWhere, f.mirrorDirF, f.mirrorURL},
+		off:    "each model's files must already be on a mirror somewhere; no starter model, no judge",
+		summary: func() string {
+			if f.mirrorWhere.Choice == 1 {
+				return "at " + orText(f.mirrorURL.Value(), "(an address)")
+			}
+			return "on this machine, in " + orText(f.mirrorDirF.Value(), mirrorDir)
+		},
+	}
+
+	// --- this machine as a node ---
+	f.node = &installPart{
+		title: "This machine as a node", on: !in.noNode,
+		about: "Runs models here as well, on this machine's NVIDIA GPUs when it has them and on its CPU otherwise. " +
+			"The node installs its own engines (llama.cpp first, vLLM after where the card can run it).\n\n" +
+			"Leave it off when this machine has neither the memory nor the cards to spare: models then run on " +
+			"the nodes added later with 'llmgw node add'.",
+		off:     "models run only on nodes added later",
+		summary: func() string { return "serves models here, on its GPUs or its CPU" },
+	}
+	if ha {
+		f.node.about += " With three machines the control plane usually serves none."
+	}
+
+	// --- the starter model ---
+	var opts, notes []string
+	pick := 0
+	cur := in.starterModelSpec()
+	for i, c := range starterChoices {
+		opts = append(opts, strings.TrimSuffix(c.Name, "-instruct"))
+		notes = append(notes, fmt.Sprintf("%s, about %.1f GB: %s.", c.Name, c.SizeGB, c.About))
+		if c.Name == cur.Name {
+			pick = i
+		}
+	}
+	opts = append(opts, "other")
+	notes = append(notes, "Any single GGUF file on Hugging Face.")
+	custom := ""
+	if in.starter.Source != "" && !slices.ContainsFunc(starterChoices, func(c starterSpec) bool { return c.Name == in.starter.Name }) {
+		pick, custom = len(starterChoices), in.starter.Source
+	}
+	f.starterPick = choiceField("Model", opts, pick, "")
+	f.starterPick.Notes = notes
+	f.starterSource = textSetupField("Its file", custom, "hf:owner/repo/file.gguf", "")
+	f.starterSource.Show = func() bool { return f.starterPick.Choice == len(starterChoices) }
+	f.starterCtx = textSetupField("Context a client may use, in tokens", strconv.Itoa(in.starterContext()), "4096",
+		"The engine holds four times this, for four requests at once; more context takes more memory.")
+	f.starter = &installPart{
+		title: "Starter model", on: !in.noModel,
+		about: "A model fetched into the mirror and served on this machine, so there is something to ask the " +
+			"moment the install finishes. Small ones answer on any CPU; the larger want a GPU. More models are " +
+			"added later from /admin/mirror or with 'llmgw ctl model add'.",
+		fields: []*setupField{f.starterPick, f.starterSource, f.starterCtx},
+		off:    "nothing to ask until a model is added",
+		summary: func() string {
+			name := opts[f.starterPick.Choice]
+			if f.starterPick.Choice == len(starterChoices) {
+				name = orText(f.starterSource.Value(), "(a file)")
+			} else {
+				name = fmt.Sprintf("%s (%.1f GB)", starterChoices[f.starterPick.Choice].Name, starterChoices[f.starterPick.Choice].SizeGB)
+			}
+			return name + ", " + f.starterCtx.Value() + " tokens"
+		},
+		needs: func() string {
+			if !f.mirror.on {
+				return "the starter model is fetched into the mirror: turn the mirror on, or the starter model off"
+			}
+			return ""
+		},
+	}
+	if ha {
+		f.starter.about += " Unless this machine is a node, it runs on the first node that joins with room for it."
+	}
+
+	// --- pictures and 3D ---
+	f.media = &installPart{
+		title: "Pictures and 3D", on: in.media,
+		about: "The nodes install ComfyUI, and once a node has a card that fits one the control plane adds a " +
+			"picture model (FLUX.1 schnell) and a 3D model (TripoSR) by itself, so the portal's pictures and 3D " +
+			"pages and their APIs work without anybody writing a definition. They load when asked for and give " +
+			"their card back when idle.\n\n" +
+			"Each comes under its own licence, kept with every file it makes. A preset someone removes is not " +
+			"added again. Later: 'llmgw ctl model presets auto off|on'.",
+		off:     "no pictures or 3D until a preset is added from the console or /admin",
+		summary: func() string { return "ComfyUI; a picture model and a 3D model once a card fits" },
+	}
+
+	// --- the guardrails' judge ---
+	j := in.judgeFor()
+	f.judgeFail = choiceField("When no judge answers in time", []string{"refuse", "serve flagged"},
+		map[string]int{"closed": 0, "open": 1}[j.Fail], "")
+	f.judgeFail.Notes = []string{
+		"The request is refused (503). Safe, and why the judge runs twice.",
+		"The request is served unjudged and marked so in the logs. Nothing is refused for the judge's sake.",
+	}
+	f.judgeCopies = textSetupField("Copies", strconv.Itoa(j.Replicas), "2",
+		"On one machine one copy, on up to four cores; with more machines two, two cores each, on different nodes. Each reserves 2 GB.")
+	f.judgeBudget = textSetupField("Waits at most", durationYAML(j.Budget), "5s",
+		"A short text is judged in about two seconds on CPUs.")
+	judgeFields := []*setupField{f.judgeFail, f.judgeCopies, f.judgeBudget, headingField("Refuses")}
+	catNotes := map[string]string{
+		"PII":                          "the patterns already catch secrets and card numbers",
+		"Unethical Acts":               "refuses much ordinary work",
+		"Politically Sensitive Topics": "refuses much ordinary work",
+		"Copyright Violation":          "refuses much ordinary work",
+	}
+	for _, c := range judgeCategories {
+		t := toggleField(c, slices.Contains(j.Categories, c), catNotes[c])
+		f.judgeCats = append(f.judgeCats, t)
+		judgeFields = append(judgeFields, t)
+	}
+	f.judge = &installPart{
+		title: "Guardrails' judge", on: !in.noGuardModel,
+		about: "Qwen3Guard 0.6B reads every prompt and every answer for what patterns cannot see: violence, " +
+			"crime, sexual content, self-harm, jailbreaks. It runs on CPUs and takes no card. Without it the " +
+			"baseline still blocks secrets and card numbers and flags prompt injection.",
+		fields: judgeFields,
+		off:    "requests are checked by patterns only: secrets, card numbers, injection",
+		summary: func() string {
+			n := 0
+			for _, c := range f.judgeCats {
+				if c.On {
+					n++
+				}
+			}
+			return fmt.Sprintf("Qwen3Guard ×%s on CPUs, %d categories, unanswered: %s",
+				f.judgeCopies.Value(), n, f.judgeFail.Options[f.judgeFail.Choice])
+		},
+		needs: func() string {
+			if !f.mirror.on {
+				return "the judge's model is fetched into the mirror: turn the mirror on, or the judge off"
+			}
+			return ""
+		},
+	}
+
+	// --- the firewall ---
+	f.firewall = &installPart{
+		title: "Firewall", on: !in.noFirewall,
+		about: "An nftables table of llmgw's own keeps its internal ports — the agents' 7443, the mirror's 8081, " +
+			"the store's — to the networks the cluster is on. The portal and API on 8080 stay open. " +
+			"Other rules on the machine are left as they are.",
+		off:     "llmgw's internal ports answer every network this machine is on",
+		summary: func() string { return "internal ports to the cluster's networks only" },
+	}
+
+	// --- notifications ---
+	f.webhooks = textSetupField("Webhooks", strings.Join(in.webhooks, ", "), "https://hooks.slack.com/services/…",
+		"Slack, Mattermost, Rocket.Chat, or any address taking JSON; comma-separated. slack: or json: in front says which. A test is sent to each.")
+	f.alerts = &installPart{
+		title: "Notifications", on: len(in.webhooks) > 0,
+		about: "Where the cluster says what went wrong: a model parked because it fits nowhere, a node lost, " +
+			"a judge not answering, a budget spent.",
+		fields: []*setupField{f.webhooks},
+		off:    "nothing is said outside the dashboards",
+		summary: func() string {
+			hooks, err := parseWebhooks([]string{f.webhooks.Value()})
+			if err != nil || len(hooks) == 0 {
+				return "(no webhook yet)"
+			}
+			var where []string
+			for _, h := range hooks {
+				where = append(where, notify.Redact(h.URL))
+			}
+			return strings.Join(where, ", ")
+		},
+	}
+
+	// --- limits ---
+	f.rpm = textSetupField("Requests a minute", strconv.Itoa(orInt(in.defaultRPM, defaultRPM)), "60", "")
+	f.tpm = textSetupField("Tokens a minute", strconv.Itoa(orInt(in.defaultTPM, defaultTPM)), "200000", "")
+	ttl := in.maxKeyTTL
+	if ttl <= 0 {
+		ttl = defaultMaxKeyTTL
+	}
+	f.keyDays = textSetupField("The longest a key lives, in days", strconv.Itoa(int(ttl.Hours()/24)), "90",
+		"A key made without an expiry gets this. Shorter per organization, team or project later.")
+	f.limits = &installPart{
+		title: "Limits and keys", fixed: true, on: true,
+		about: "What a key may use when nothing more particular gives it a limit: a project made without limits " +
+			"would otherwise be metered by nothing. Organizations, teams and projects get their own later.",
+		fields: []*setupField{f.rpm, f.tpm, f.keyDays},
+		summary: func() string {
+			return fmt.Sprintf("%s requests and %s tokens a minute; keys live %s days", f.rpm.Value(), f.tpm.Value(), f.keyDays.Value())
+		},
+	}
+
+	// --- on-demand turns ---
+	f.idle = textSetupField("Unused for", durationYAML(orDur(in.evictAfterIdle, 2*time.Minute)), "2m",
+		"before a model loaded on demand gives its card to another that wants it.")
+	f.safe = textSetupField("Safe after loading for", durationYAML(orDur(in.minLifetime, 5*time.Minute)), "5m",
+		"so two models do not take turns paying for loads. 1m each suits one card shared by a picture model and a 3D model.")
+	f.turns = &installPart{
+		title: "Taking turns on a card", fixed: true, on: true,
+		about: "Models that load when asked for share the cards: on a site with fewer cards than such models, " +
+			"one waits for another to go idle. These are the waits.",
+		fields: []*setupField{f.idle, f.safe},
+		summary: func() string {
+			return "after " + f.idle.Value() + " unused; safe for " + f.safe.Value() + " after loading"
+		},
+	}
+
+	// --- offline bundle ---
+	f.bundlePath = textSetupField("Bundle", in.bundle, "/media/usb/llmgw-bundle.tar",
+		"Made on a machine with internet by 'llmgw bundle create'.")
+	f.bundleSHA = textSetupField("Its sha256", in.bundleSHA, "the sha256 'llmgw bundle create' printed", "")
+	f.bundleSHA.Text.Width = 64
+	f.bundle = &installPart{
+		title: "Offline bundle", on: in.bundle != "",
+		about: "For a site with no internet: engines, releases and models carried in on a disk. They go into the " +
+			"mirror, and the cluster is set to reach nothing outside.",
+		fields:  []*setupField{f.bundlePath, f.bundleSHA},
+		off:     "engines and models are downloaded from the internet",
+		summary: func() string { return orText(f.bundlePath.Value(), "(a file)") },
+		needs: func() string {
+			if !f.mirror.on {
+				return "an offline bundle goes into the model mirror: turn the mirror on"
+			}
+			return ""
+		},
+	}
+
+	f.parts = []*installPart{f.control, f.store}
+	if ha {
+		f.parts = append(f.parts, f.standby)
+	}
+	f.parts = append(f.parts, f.mirror, f.node, f.starter, f.media, f.judge, f.firewall,
+		f.alerts, f.limits, f.turns, f.bundle)
+	return f
+}
+
+func orText(s, d string) string {
+	if strings.TrimSpace(s) == "" {
+		return d
+	}
+	return s
+}
+
+func orInt(n, d int) int {
+	if n <= 0 {
+		return d
+	}
+	return n
+}
+
+func orDur(v, d time.Duration) time.Duration {
+	if v <= 0 {
+		return d
+	}
+	return v
+}
+
+// openPart opens a part's settings.
+func (f *installForm) openPart(p *installPart) {
+	f.open = p
+	f.dialog = &setupDialog{Title: p.title, About: p.about, Fields: p.fields}
+	f.dialog.first()
+}
+
+// fail says what is wrong, and with what, so that closing the message opens it.
+func (f *installForm) fail(p *installPart, field *setupField, msg string) error {
+	f.err, f.errPart, f.errField = msg, p, field
+	return fmt.Errorf("%s", msg)
+}
+
+// key takes a key; next is whether the person asked to go on, the choices
+// already put into in.
+func (f *installForm) key(k tea.KeyMsg, in *serverInit) (next bool) {
+	if f.err != "" {
+		p, field := f.errPart, f.errField
+		f.err, f.errPart, f.errField = "", nil, nil
+		if p != nil {
+			f.openPart(p)
+			if field != nil {
+				f.dialog.focusOn(field)
+			}
+		}
+		return false
+	}
+	if f.dialog != nil {
+		if f.dialog.key(k) {
+			f.dialog, f.open = nil, nil
+		}
+		return false
+	}
+	n := len(f.parts) + 1
+	switch k.String() {
+	case "down", "tab", "j":
+		f.focus = (f.focus + 1) % n
+	case "up", "shift+tab", "k":
+		f.focus = (f.focus + n - 1) % n
+	case " ", "x":
+		if f.focus < len(f.parts) {
+			p := f.parts[f.focus]
+			if p.fixed {
+				break
+			}
+			p.on = !p.on
+			// A part that is nothing until it is told something is told
+			// at once.
+			if p.on && (p == f.alerts && f.webhooks.Value() == "" || p == f.bundle && f.bundlePath.Value() == "") {
+				f.openPart(p)
+			}
+		}
+	case "enter":
+		if f.focus < len(f.parts) {
+			f.openPart(f.parts[f.focus])
+			return false
+		}
+		return f.apply(in) == nil
+	}
+	return false
+}
+
+// apply checks the choices and puts them into in; what is wrong is kept to
+// be said.
+func (f *installForm) apply(in *serverInit) error {
+	for _, p := range f.parts {
+		if p.on && p.needs != nil {
+			if why := p.needs(); why != "" {
+				return f.fail(nil, nil, why)
+			}
+		}
+	}
+	admin := f.admin.Value()
+	if admin != "" || f.ha {
+		if _, err := mail.ParseAddress(admin); err != nil {
+			msg := "the administrator's email is not an address"
+			if admin == "" {
+				msg = "the administrator's email is needed"
+			}
+			return f.fail(f.control, f.admin, msg)
+		}
+	}
+	var hosts []string
+	for _, h := range strings.Split(f.hosts.Value(), ",") {
+		if h = strings.TrimSpace(h); h != "" {
+			hosts = append(hosts, h)
+		}
+	}
+
+	mirrorURL := ""
+	if f.mirror.on && f.mirrorWhere.Choice == 1 {
+		u, err := url.Parse(f.mirrorURL.Value())
+		if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
+			return f.fail(f.mirror, f.mirrorURL, "the other machine's mirror: its management API, as http://host:8082")
+		}
+		mirrorURL = f.mirrorURL.Value()
+	}
+	mirrorPath := ""
+	if f.mirror.on && f.mirrorWhere.Choice == 0 {
+		mirrorPath = f.mirrorDirF.Value()
+		if !strings.HasPrefix(mirrorPath, "/") {
+			return f.fail(f.mirror, f.mirrorDirF, "the mirror's directory: a path from /")
+		}
+	}
+
+	var starter starterSpec
+	ctx := 0
+	if f.starter.on {
+		if f.starterPick.Choice < len(starterChoices) {
+			starter = starterChoices[f.starterPick.Choice]
+		} else {
+			s, err := starterFrom(f.starterSource.Value())
+			if err != nil || !strings.HasPrefix(s.Source, "hf:") {
+				return f.fail(f.starter, f.starterSource, "the starter model's file: hf:<owner>/<repo>/<file>.gguf")
+			}
+			starter = s
+		}
+		n, err := strconv.Atoi(f.starterCtx.Value())
+		if err != nil || n < 512 || n > 262144 {
+			return f.fail(f.starter, f.starterCtx, "the starter's context: a number of tokens from 512 to 262144")
+		}
+		ctx = n
+	}
+
+	var judge judgeSpec
+	if f.judge.on {
+		judge.Fail = []string{"closed", "open"}[f.judgeFail.Choice]
+		n, err := strconv.Atoi(f.judgeCopies.Value())
+		if err != nil || n < 1 || n > 8 {
+			return f.fail(f.judge, f.judgeCopies, "the judge's copies: from 1 to 8")
+		}
+		judge.Replicas = n
+		d, err := time.ParseDuration(f.judgeBudget.Value())
+		if err != nil || d < 500*time.Millisecond || d > time.Minute {
+			return f.fail(f.judge, f.judgeBudget, "how long the judge is waited for: a duration such as 5s, at most 1m")
+		}
+		judge.Budget = d
+		for i, c := range f.judgeCats {
+			if c.On {
+				judge.Categories = append(judge.Categories, judgeCategories[i])
+			}
+		}
+		if len(judge.Categories) == 0 {
+			return f.fail(f.judge, f.judgeCats[0], "the judge refuses nothing: tick a category, or turn the judge off")
+		}
+	}
+
+	var hooks []string
+	if f.alerts.on {
+		h := f.webhooks.Value()
+		parsed, err := parseWebhooks([]string{h})
+		if err != nil {
+			return f.fail(f.alerts, f.webhooks, err.Error())
+		}
+		if len(parsed) == 0 {
+			return f.fail(f.alerts, f.webhooks, "give a webhook, or turn notifications off")
+		}
+		hooks = []string{h}
+	}
+
+	rpm, err := strconv.Atoi(f.rpm.Value())
+	if err != nil || rpm < 1 {
+		return f.fail(f.limits, f.rpm, "requests a minute: a whole number, 1 or more")
+	}
+	tpm, err := strconv.Atoi(f.tpm.Value())
+	if err != nil || tpm < 1 {
+		return f.fail(f.limits, f.tpm, "tokens a minute: a whole number, 1 or more")
+	}
+	keyDays, err := strconv.Atoi(f.keyDays.Value())
+	if err != nil || keyDays < 1 || keyDays > 3650 {
+		return f.fail(f.limits, f.keyDays, "the longest a key lives: days, from 1 to 3650")
+	}
+	idle, err := time.ParseDuration(f.idle.Value())
+	if err != nil || idle < 0 {
+		return f.fail(f.turns, f.idle, "a duration such as 2m or 90s")
+	}
+	safe, err := time.ParseDuration(f.safe.Value())
+	if err != nil || safe < 0 {
+		return f.fail(f.turns, f.safe, "a duration such as 5m or 90s")
+	}
+
+	bundle, sum := "", ""
+	if f.bundle.on {
+		bundle, sum = f.bundlePath.Value(), strings.ToLower(f.bundleSHA.Value())
+		switch {
+		case bundle == "":
+			return f.fail(f.bundle, f.bundlePath, "give the bundle's path, or turn the offline bundle off")
+		case sum == "":
+			return f.fail(f.bundle, f.bundleSHA, "give the bundle's sha256, as 'llmgw bundle create' printed it")
+		}
+	}
+
+	in.admin, in.hosts = admin, hosts
+	in.language = map[int]string{0: "", 1: "tr"}[f.language.Choice]
+	in.signupOpen = f.signup.Choice == 1
+	in.postgres = !f.ha && f.storeKind.Choice == 1
+	in.noMirror = !f.mirror.on || mirrorURL != ""
+	in.mirrorURL, in.mirrorPath = mirrorURL, mirrorPath
+	in.noNode = !f.node.on
+	in.noModel = !f.starter.on
+	in.starter, in.starterCtx = starter, ctx
+	in.media = f.media.on
+	in.noGuardModel = !f.judge.on
+	in.judge = judge
+	in.noFirewall = !f.firewall.on
+	in.webhooks = hooks
+	in.defaultRPM, in.defaultTPM = rpm, tpm
+	in.maxKeyTTL = time.Duration(keyDays) * 24 * time.Hour
+	in.evictAfterIdle, in.minLifetime = 0, 0
+	if idle != 2*time.Minute {
+		in.evictAfterIdle = idle
+	}
+	if safe != 5*time.Minute {
+		in.minLifetime = safe
+	}
+	in.bundle, in.bundleSHA = bundle, sum
+	in.standbys, in.vip = false, ""
+	if f.standby != nil && f.standby.on {
+		in.standbys, in.vip = true, f.vipF.Value()
+	}
+	if err := in.checkChoices(); err != nil {
+		if strings.HasPrefix(err.Error(), "floating address") {
+			return f.fail(f.standby, f.vipF, err.Error())
+		}
+		return f.fail(nil, nil, err.Error())
+	}
+	return nil
+}
+
+// view is the list of parts, and what the focused one is, under it.
+func (f *installForm) view(width int) string {
+	var b strings.Builder
+	b.WriteString("\n  " + sDim.Render("Space turns a part on or off · Enter opens its settings and says more") + "\n\n")
+	titleW := 0
+	for _, p := range f.parts {
+		titleW = max(titleW, len(p.title))
+	}
+	for i, p := range f.parts {
+		box := "[ ]"
+		switch {
+		case p.fixed:
+			box = " • "
+		case p.on:
+			box = "[" + sOK.Render("x") + "]"
+		}
+		title := fmt.Sprintf("%-*s", titleW, p.title)
+		line := ""
+		if p.on {
+			line = p.summary()
+		} else {
+			line = sDim.Render(p.off)
+		}
+		if i == f.focus {
+			title = fSelected.Render(title)
+			b.WriteString(fSelected.Render("› ") + box + " " + title + "  " + truncateWidth(line, max(20, width-titleW-8)) + "\n")
+		} else {
+			b.WriteString("  " + box + " " + title + "  " + truncateWidth(line, max(20, width-titleW-8)) + "\n")
+		}
+	}
+	b.WriteString("\n" + button(f.focus == len(f.parts), "Next") + "\n")
+	if f.focus < len(f.parts) {
+		p := f.parts[f.focus]
+		b.WriteString("\n  " + lipgloss.NewStyle().Bold(true).Render(p.title) + "\n")
+		b.WriteString(paragraphs(p.about, max(40, width-6), "  ") + "\n")
+	}
+	return b.String()
+}
+
+// overlay is the dialog over the list, if one is open: its title and body.
+func (f *installForm) overlay() (string, string) {
+	if f.err != "" {
+		return "Not yet", f.err + "\n\n" + sDim.Render("any key to go back")
+	}
+	if f.dialog != nil {
+		return f.dialog.Title, f.dialog.view(max(8, f.height-8))
+	}
+	return "", ""
+}
+
+// keys is the key bar for the list or its dialog.
+func (f *installForm) keys() string {
+	switch {
+	case f.err != "":
+		return "any key back"
+	case f.dialog != nil:
+		return setupDialogKeys(f.dialog)
+	}
+	return "↑↓ move · Space on/off · Enter settings, or on Next go on · Ctrl+C leave"
+}
+
+// planView says what will be installed and what will not, part by part, in
+// words: the last look before anything is done.
+func (f *installForm) planView(width int) string {
+	var b strings.Builder
+	b.WriteString("\n  " + lipgloss.NewStyle().Bold(true).Render("Installed on "+f.host) + "\n\n")
+	var left []*installPart
+	for _, p := range f.parts {
+		if !p.on {
+			left = append(left, p)
+			continue
+		}
+		fmt.Fprintf(&b, "  %s %s\n      %s\n", sOK.Render("✓"), p.title, wrap(p.summary(), max(40, width-8), "      "))
+	}
+	if len(left) > 0 {
+		b.WriteString("\n  " + lipgloss.NewStyle().Bold(true).Render("Left out") + "\n\n")
+		for _, p := range left {
+			fmt.Fprintf(&b, "  %s %s\n      %s\n", sDim.Render("-"), p.title, sDim.Render(wrap(p.off, max(40, width-8), "      ")))
+		}
+	}
+	return b.String()
+}
@@ -0,0 +1,322 @@
+package cli
+
+import (
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/x/ansi"
+)
+
+// A form in a dialog: text to type, one of a few choices, a thing on or off,
+// and headings between them. The setup's settings for each part are one of
+// these, opened over the list of parts.
+
+type fieldKind int
+
+const (
+	fkText fieldKind = iota
+	// fkChoice is one of Options, changed with ← →.
+	fkChoice
+	// fkToggle is on or off, changed with Space.
+	fkToggle
+	// fkHeading is a title between fields; it takes no focus.
+	fkHeading
+)
+
+type setupField struct {
+	Label string
+	// Hint is said under the field; Notes, for a choice, under each option
+	// as it is chosen.
+	Hint  string
+	Notes []string
+	Kind  fieldKind
+
+	Text    textField
+	Options []string
+	Choice  int
+	On      bool
+	// Show, when set, says whether the field is shown, and so whether it
+	// counts: a directory for a mirror kept elsewhere is neither.
+	Show func() bool
+}
+
+func textSetupField(label, value, placeholder, hint string) *setupField {
+	t := newTextField()
+	t.SetValue(value)
+	t.Placeholder, t.CharLimit, t.Width = placeholder, 800, 40
+	return &setupField{Label: label, Hint: hint, Kind: fkText, Text: t}
+}
+
+func choiceField(label string, options []string, choice int, hint string) *setupField {
+	return &setupField{Label: label, Hint: hint, Kind: fkChoice, Options: options, Choice: choice}
+}
+
+func toggleField(label string, on bool, hint string) *setupField {
+	return &setupField{Label: label, Hint: hint, Kind: fkToggle, On: on}
+}
+
+func headingField(label string) *setupField {
+	return &setupField{Label: label, Kind: fkHeading}
+}
+
+func (f *setupField) shown() bool { return f.Show == nil || f.Show() }
+
+func (f *setupField) Value() string { return strings.TrimSpace(f.Text.Value()) }
+
+// setupDialog is a form over the screen, with what it is for above it.
+type setupDialog struct {
+	Title  string
+	About  string
+	Fields []*setupField
+	focus  int
+}
+
+// focusable is whether a field can have the focus now.
+func (d *setupDialog) focusable(i int) bool {
+	f := d.Fields[i]
+	return f.Kind != fkHeading && f.shown()
+}
+
+// first puts the focus on the first field that takes it.
+func (d *setupDialog) first() {
+	d.focus = -1
+	d.move(1)
+}
+
+// focusOn puts the focus on a field, as when it is what is wrong.
+func (d *setupDialog) focusOn(f *setupField) {
+	for i, x := range d.Fields {
+		if x == f {
+			d.focus = i
+		}
+	}
+	d.blurAll()
+}
+
+func (d *setupDialog) move(dir int) {
+	n := len(d.Fields)
+	for range n {
+		d.focus = (d.focus + dir + n) % n
+		if d.focusable(d.focus) {
+			break
+		}
+	}
+	d.blurAll()
+}
+
+// blurAll leaves only the focused text field with a cursor.
+func (d *setupDialog) blurAll() {
+	for i, f := range d.Fields {
+		if f.Kind != fkText {
+			continue
+		}
+		if i == d.focus {
+			f.Text.Focus()
+		} else {
+			f.Text.Blur()
+		}
+	}
+}
+
+// hasFields is whether there is anything to set, rather than only to read.
+func (d *setupDialog) hasFields() bool {
+	for i := range d.Fields {
+		if d.focusable(i) {
+			return true
+		}
+	}
+	return false
+}
+
+// lastFocusable is the last field that takes the focus now.
+func (d *setupDialog) lastFocusable() int {
+	for i := len(d.Fields) - 1; i >= 0; i-- {
+		if d.focusable(i) {
+			return i
+		}
+	}
+	return -1
+}
+
+// key takes a key and says whether the dialog is done: Esc, or Enter on
+// the last field.
+func (d *setupDialog) key(k tea.KeyMsg) (done bool) {
+	switch k.Type {
+	case tea.KeyEsc:
+		return true
+	case tea.KeyEnter:
+		if !d.hasFields() || d.focus == d.lastFocusable() {
+			return true
+		}
+		d.move(1)
+		return false
+	case tea.KeyTab, tea.KeyDown:
+		if d.hasFields() {
+			d.move(1)
+		}
+		return false
+	case tea.KeyShiftTab, tea.KeyUp:
+		if d.hasFields() {
+			d.move(-1)
+		}
+		return false
+	}
+	if d.focus < 0 || d.focus >= len(d.Fields) || !d.focusable(d.focus) {
+		return false
+	}
+	f := d.Fields[d.focus]
+	switch f.Kind {
+	case fkText:
+		f.Text, _ = f.Text.Update(k)
+	case fkChoice:
+		switch k.String() {
+		case "left", "h":
+			f.Choice = (f.Choice + len(f.Options) - 1) % len(f.Options)
+		case "right", "l", " ":
+			f.Choice = (f.Choice + 1) % len(f.Options)
+		}
+	case fkToggle:
+		if k.String() == " " || k.String() == "x" {
+			f.On = !f.On
+		}
+	}
+	return false
+}
+
+// dialogWidth is how wide the text in a dialog is wrapped.
+const dialogWidth = 66
+
+// view draws the form in at most maxLines lines, the part around the focus
+// when it is longer: a long form scrolls as the focus moves.
+func (d *setupDialog) view(maxLines int) string {
+	var lines []string
+	add := func(s string) { lines = append(lines, strings.Split(s, "\n")...) }
+	if d.About != "" {
+		add(paragraphs(d.About, dialogWidth, ""))
+	}
+	if !d.hasFields() {
+		add("")
+		add(sDim.Render("Nothing to set for this part. Esc or Enter to go back."))
+		return clipLines(lines, 0, 0, maxLines)
+	}
+	add("")
+	focusStart, focusEnd := 0, 0
+	for i, f := range d.Fields {
+		if !f.shown() {
+			continue
+		}
+		focused := i == d.focus
+		if focused {
+			focusStart = len(lines)
+		}
+		label := func(s string) string {
+			if focused {
+				return fSelected.Render("› " + s)
+			}
+			return "  " + s
+		}
+		switch f.Kind {
+		case fkHeading:
+			add("")
+			add("  " + lipgloss.NewStyle().Bold(true).Render(f.Label))
+			continue
+		case fkText:
+			add(label(f.Label))
+			add("    " + f.Text.View())
+		case fkChoice:
+			var opts []string
+			for j, o := range f.Options {
+				if j == f.Choice {
+					opts = append(opts, "("+sOK.Render("•")+") "+o)
+				} else {
+					opts = append(opts, "( ) "+sDim.Render(o))
+				}
+			}
+			add(label(f.Label))
+			// Side by side while they fit, else one a line.
+			if row := strings.Join(opts, "  "); ansi.StringWidth(row) <= dialogWidth-4 {
+				add("    " + row)
+			} else {
+				for _, o := range opts {
+					add("    " + o)
+				}
+			}
+			if f.Choice < len(f.Notes) && f.Notes[f.Choice] != "" {
+				add("    " + sDim.Render(wrap(f.Notes[f.Choice], dialogWidth-4, "    ")))
+			}
+		case fkToggle:
+			box := "[ ]"
+			if f.On {
+				box = "[" + sOK.Render("x") + "]"
+			}
+			add(label(box) + " " + f.Label)
+		}
+		if f.Hint != "" {
+			add("    " + sDim.Render(wrap(f.Hint, dialogWidth-4, "    ")))
+		}
+		if focused {
+			focusEnd = len(lines) - 1
+		}
+		if f.Kind != fkToggle {
+			add("")
+		}
+	}
+	for len(lines) > 0 && lines[len(lines)-1] == "" {
+		lines = lines[:len(lines)-1]
+	}
+	return clipLines(lines, focusStart, focusEnd, maxLines)
+}
+
+// clipLines is at most n of lines, keeping lines from to through in sight
+// as far as they fit, with a mark at an edge that has more beyond it.
+func clipLines(lines []string, from, through, n int) string {
+	if n <= 2 || len(lines) <= n {
+		return strings.Join(lines, "\n")
+	}
+	top := 0
+	// The last line shown is a mark when there is more below: the focus
+	// ends a line above it.
+	if through > n-2 {
+		top = through - (n - 2)
+	}
+	// Its first line wins over its last, under the mark above.
+	if from > 0 && top > from-1 {
+		top = from - 1
+	}
+	top = max(0, min(top, len(lines)-n))
+	out := append([]string{}, lines[top:top+n]...)
+	if top > 0 {
+		out[0] = sDim.Render("  ↑ more")
+	}
+	if top+n < len(lines) {
+		out[n-1] = sDim.Render("  ↓ more")
+	}
+	return strings.Join(out, "\n")
+}
+
+// paragraphs wraps text paragraph by paragraph, blank lines kept between.
+func paragraphs(s string, width int, indent string) string {
+	var out []string
+	for _, p := range strings.Split(s, "\n\n") {
+		out = append(out, indent+wrap(p, width, indent))
+	}
+	return strings.Join(out, "\n\n")
+}
+
+// setupDialogKeys is the key bar under a dialog.
+func setupDialogKeys(d *setupDialog) string {
+	if !d.hasFields() {
+		return "Esc or Enter back"
+	}
+	keys := "Tab/↑↓ move"
+	if d.focus >= 0 && d.focus < len(d.Fields) {
+		switch d.Fields[d.focus].Kind {
+		case fkChoice:
+			keys += " · ←→ choose"
+		case fkToggle:
+			keys += " · Space tick"
+		}
+	}
+	return keys + " · Esc done"
+}
@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"net/mail"
 	"os"
 	"path/filepath"
 	"strings"
@@ -47,35 +46,16 @@ func (w *lineWriter) Write(p []byte) (int, error) {
 }

 // Form fields, in order.
-const (
-	fAdmin = iota
-	fHosts
-	fWebhooks
-	fPostgres
-	fMirror
-	fNode
-	fModel
-	fGuard
-	fBundle
-	fBundleSHA
-	fStart
-	fCount
-)
-
 type initModel struct {
 	in    *serverInit
 	found []string // this machine's addresses

-	// The form, until it is submitted.
-	form      bool
-	focus     int
-	admin     textField
-	hosts     textField
-	webhooks  textField
-	bundle    textField
-	bundleSHA textField
-	toggles   [fCount]bool
-	formError string
+	// The parts to install, until they are chosen and the plan agreed to.
+	form    bool
+	plan    bool
+	choices *installForm
+	// scroll is how far the panel is scrolled, back to the top on each page.
+	scroll int

 	// Then the run.
 	running  bool
@@ -95,43 +75,9 @@ type initModel struct {
 }

 func newInitModel(in *serverInit, found []string, askForm bool) initModel {
-	admin := newTextField()
-	admin.Placeholder = "you@example.com"
-	admin.SetValue(in.admin)
-	admin.CharLimit = 200
-	admin.Width = 40
-	hosts := newTextField()
-	hosts.Placeholder = "llm.example.com, 203.0.113.10"
-	hosts.SetValue(strings.Join(in.hosts, ", "))
-	hosts.CharLimit = 400
-	hosts.Width = 40
-	webhooks := newTextField()
-	webhooks.Placeholder = "https://hooks.slack.com/services/…"
-	webhooks.SetValue(strings.Join(in.webhooks, ", "))
-	webhooks.CharLimit = 800
-	webhooks.Width = 40
-	bundle := newTextField()
-	bundle.Placeholder = "/media/usb/llmgw-bundle.tar"
-	bundle.SetValue(in.bundle)
-	bundle.CharLimit = 400
-	bundle.Width = 40
-	bundleSHA := newTextField()
-	bundleSHA.Placeholder = "the sha256 'llmgw bundle create' printed"
-	bundleSHA.SetValue(in.bundleSHA)
-	bundleSHA.CharLimit = 64
-	bundleSHA.Width = 64
-	sp := newSpinner()
-	m := initModel{in: in, found: found, form: askForm, admin: admin, hosts: hosts, webhooks: webhooks,
-		bundle: bundle, bundleSHA: bundleSHA, spin: sp, width: 100}
-	m.toggles[fPostgres] = in.postgres
-	m.toggles[fMirror] = !in.noMirror
-	m.toggles[fNode] = !in.noNode
-	m.toggles[fModel] = !in.noModel
-	m.toggles[fGuard] = !in.noGuardModel
-	if askForm {
-		m.admin.Focus()
-	}
-	return m
+	host, _ := os.Hostname()
+	return initModel{in: in, found: found, form: askForm, choices: newInstallForm(in, host, found, false),
+		spin: newSpinner(), width: 100, height: 30}
 }

 func (m initModel) Init() tea.Cmd {
@@ -147,6 +93,7 @@ func (m initModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
 		m.width, m.height = msg.Width, msg.Height
+		m.choices.height = msg.Height
 		if m.framed {
 			m.width = msg.Width - navWidth - 6
 		}
@@ -209,118 +156,32 @@ func (m *initModel) addLine(l string) {

 func (m initModel) formKey(k tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch k.Type {
-	case tea.KeyTab, tea.KeyDown:
-		m.moveFocus(1)
+	case tea.KeyPgDown:
+		m.scroll += max(1, m.height-8)
 		return m, nil
-	case tea.KeyShiftTab, tea.KeyUp:
-		m.moveFocus(-1)
+	case tea.KeyPgUp:
+		m.scroll = max(0, m.scroll-max(1, m.height-8))
 		return m, nil
-	case tea.KeyEnter:
-		if m.focus != fStart {
-			m.moveFocus(1)
-			return m, nil
-		}
-		admin := strings.TrimSpace(m.admin.Value())
-		if admin != "" {
-			if _, err := mail.ParseAddress(admin); err != nil {
-				m.formError = "the administrator's email is not an address"
-				m.focus = fAdmin
-				m.admin.Focus()
-				return m, nil
-			}
-		}
-		bundle, sum := strings.TrimSpace(m.bundle.Value()), strings.ToLower(strings.TrimSpace(m.bundleSHA.Value()))
-		switch {
-		case bundle != "" && sum == "":
-			m.formError = "give the bundle's sha256, as 'llmgw bundle create' printed it"
-			m.focus = fBundleSHA
-			m.moveFocus(0)
-			return m, nil
-		case bundle != "" && !m.toggles[fMirror] && m.in.mirrorURL == "":
-			m.formError = "an offline bundle goes into the model mirror: tick it"
-			m.focus = fMirror
-			m.moveFocus(0)
-			return m, nil
-		}
-		hooks := strings.TrimSpace(m.webhooks.Value())
-		if _, err := parseWebhooks([]string{hooks}); err != nil {
-			m.formError = err.Error()
-			m.focus = fWebhooks
-			m.moveFocus(0)
-			return m, nil
-		}
-		m.in.webhooks = nil
-		if hooks != "" {
-			m.in.webhooks = []string{hooks}
-		}
-		m.in.bundle, m.in.bundleSHA = bundle, sum
-		m.in.admin = admin
-		m.in.hosts = nil
-		for _, h := range strings.Split(m.hosts.Value(), ",") {
-			if h = strings.TrimSpace(h); h != "" {
-				m.in.hosts = append(m.in.hosts, h)
-			}
-		}
-		m.in.postgres = m.toggles[fPostgres]
-		m.in.noMirror = !m.toggles[fMirror]
-		m.in.noNode = !m.toggles[fNode]
-		m.in.noModel = !m.toggles[fModel]
-		m.in.noGuardModel = !m.toggles[fGuard]
-		m.form = false
-		return m, tea.Batch(m.spin.Tick, func() tea.Msg { return startInitMsg{} })
 	}
-	switch m.focus {
-	case fAdmin:
-		var cmd tea.Cmd
-		m.admin, cmd = m.admin.Update(k)
-		return m, cmd
-	case fHosts:
-		var cmd tea.Cmd
-		m.hosts, cmd = m.hosts.Update(k)
-		return m, cmd
-	case fWebhooks:
-		var cmd tea.Cmd
-		m.webhooks, cmd = m.webhooks.Update(k)
-		return m, cmd
-	case fBundle:
-		var cmd tea.Cmd
-		m.bundle, cmd = m.bundle.Update(k)
-		return m, cmd
-	case fBundleSHA:
-		var cmd tea.Cmd
-		m.bundleSHA, cmd = m.bundleSHA.Update(k)
-		return m, cmd
-	case fPostgres, fMirror, fNode, fModel, fGuard:
-		if k.String() == " " || k.String() == "x" {
-			m.toggles[m.focus] = !m.toggles[m.focus]
+	if m.plan {
+		switch k.Type {
+		case tea.KeyEsc:
+			m.plan, m.scroll = false, 0
+		case tea.KeyEnter:
+			m.form, m.plan, m.scroll = false, false, 0
+			return m, tea.Batch(m.spin.Tick, func() tea.Msg { return startInitMsg{} })
 		}
+		return m, nil
+	}
+	if m.choices.key(k, m.in) {
+		m.plan, m.scroll = true, 0
 	}
 	return m, nil
 }

-func (m *initModel) moveFocus(d int) {
-	m.focus = (m.focus + d + fCount) % fCount
-	// With --mirror there is no mirror to run here, so nothing to tick.
-	if m.focus == fMirror && m.in.mirrorURL != "" {
-		m.focus = (m.focus + d + fCount) % fCount
-	}
-	m.admin.Blur()
-	m.hosts.Blur()
-	m.webhooks.Blur()
-	m.bundle.Blur()
-	m.bundleSHA.Blur()
-	switch m.focus {
-	case fAdmin:
-		m.admin.Focus()
-	case fHosts:
-		m.hosts.Focus()
-	case fWebhooks:
-		m.webhooks.Focus()
-	case fBundle:
-		m.bundle.Focus()
-	case fBundleSHA:
-		m.bundleSHA.Focus()
-	}
+// command is this install as a command line, for doing it again from a script.
+func (in *serverInit) command() string {
+	return strings.Join(append([]string{"sudo llmgw server init"}, in.initFlags()...), " \\\n    ")
 }

 func (m initModel) View() string {
@@ -331,27 +192,50 @@ func (m initModel) View() string {
 	if i := strings.Index(body, "\n\n"); i >= 0 {
 		body = body[i+1:]
 	}
-	steps := []navItem{{Label: "Start", State: "done"}, {Label: "Settings", State: "current"}, {Label: "Install", State: "todo"}}
-	keys := "Tab/↑↓ move · Space tick · Enter on Set up · Ctrl+C leave"
-	if !m.form {
+	steps := []navItem{{Label: "Start", State: "done"}, {Label: "Choices", State: "current"},
+		{Label: "Plan", State: "todo"}, {Label: "Install", State: "todo"}}
+	keys := m.choices.keys()
+	title := "What to install"
+	switch {
+	case m.form && m.plan:
 		steps[1].State, steps[2].State = "done", "current"
-		keys = "Ctrl+C stop"
+		keys, title = "Enter install · Esc back to the choices · PgUp/PgDn scroll · Ctrl+C leave", "Plan"
+	case !m.form:
+		steps[1].State, steps[2].State, steps[3].State = "done", "done", "current"
+		keys, title = "Ctrl+C stop", "Installing"
 		if m.done {
-			steps[2].State = "done"
+			steps[3].State = "done"
 			keys = "Enter close"
 		}
 	}
-	host, _ := os.Hostname()
-	return frame{Width: m.width + navWidth + 6, Height: m.height, Title: "llmgw setup", Where: host,
-		NavTitle: "Steps", Nav: steps, PanelTitle: "This machine as a control plane", Body: body, Keys: keys}.render()
+	f := frame{Width: m.width + navWidth + 6, Height: m.height, Title: "llmgw setup",
+		NavTitle: "Steps", Nav: steps, PanelTitle: title, Body: body, Keys: keys, Scroll: m.scroll}
+	if m.form && !m.plan {
+		f.DialogTitle, f.Dialog = m.choices.overlay()
+	}
+	f.Where, _ = os.Hostname()
+	return f.render()
 }

 // plainView is the screen as text, for a panel or a terminal that is not one.
 func (m initModel) plainView() string {
 	var b strings.Builder
 	b.WriteString(sTitle.Render("llmgw · setting up this machine as a control plane") + "\n\n")
+	if m.form && m.plan {
+		b.WriteString(m.choices.planView(m.width))
+		b.WriteString("\n  " + sDim.Render("The same from a script:") + "\n")
+		for _, l := range strings.Split(m.in.command(), "\n") {
+			b.WriteString("  " + l + "\n")
+		}
+		b.WriteString("\n" + button(true, "Enter to install") + "\n")
+		return b.String()
+	}
 	if m.form {
-		return b.String() + m.formView()
+		b.WriteString(m.choices.view(m.width))
+		if title, d := m.choices.overlay(); d != "" && !m.framed {
+			b.WriteString("\n" + sTitle.Render(title) + "\n" + d + "\n")
+		}
+		return b.String()
 	}
 	for _, l := range m.visibleLines() {
 		b.WriteString(m.lineView(l) + "\n")
@@ -411,53 +295,6 @@ func (m initModel) lineView(l string) string {
 	return "    " + t
 }

-func (m initModel) formView() string {
-	var b strings.Builder
-	label := func(i int, s string) string {
-		if m.focus == i {
-			return sTitle.Render("› " + s)
-		}
-		return "  " + s
-	}
-	check := func(i int, s, hint string) string {
-		box := "[ ]"
-		if m.toggles[i] {
-			box = "[" + sOK.Render("x") + "]"
-		}
-		return fmt.Sprintf("%s %s %s\n", label(i, box), s, sDim.Render(hint))
-	}
-	fmt.Fprintf(&b, "%s\n    %s\n", label(fAdmin, "Administrator's email"), m.admin.View())
-	b.WriteString("    " + sDim.Render("A password is generated and shown once. Leave empty to create accounts later.") + "\n\n")
-	fmt.Fprintf(&b, "%s\n    %s\n", label(fHosts, "Other names nodes will reach this machine by"), m.hosts.View())
-	found := "none found"
-	if len(m.found) > 0 {
-		found = strings.Join(m.found, ", ")
-	}
-	b.WriteString("    " + sDim.Render("Already in the certificate: "+found+". Add a DNS name or NAT address here.") + "\n\n")
-	fmt.Fprintf(&b, "%s\n    %s\n", label(fWebhooks, "Notification webhooks"), m.webhooks.View())
-	b.WriteString("    " + sDim.Render("Where a parked model, a lost node or a spent budget is said: Slack, Mattermost, or any URL taking JSON. Comma-separated; a test is sent.") + "\n\n")
-	b.WriteString(check(fPostgres, "PostgreSQL", "rather than SQLite; installed here, for several control planes or a larger store"))
-	if m.in.mirrorURL != "" {
-		b.WriteString("  Model mirror " + sDim.Render("at "+m.in.mirrorURL+", from --mirror") + "\n")
-	} else {
-		b.WriteString(check(fMirror, "Model mirror", "downloads model files once for every node"))
-	}
-	b.WriteString(check(fNode, "This machine as a node", "serves models here too, on its GPUs or CPU"))
-	b.WriteString(check(fModel, "Starter model", "a small Qwen, so there is something to ask at once"))
-	b.WriteString(check(fGuard, "Guardrails' judge", "Llama Guard 3 1B on a CPU, refusing violent, criminal and abusive requests"))
-	fmt.Fprintf(&b, "\n%s\n    %s\n", label(fBundle, "Offline bundle"), m.bundle.View())
-	b.WriteString("    " + sDim.Render("For a site with no internet: engines, releases and models from 'llmgw bundle create'. Empty downloads them.") + "\n")
-	fmt.Fprintf(&b, "%s\n    %s\n", label(fBundleSHA, "Its sha256"), m.bundleSHA.View())
-	b.WriteString("\n" + label(fStart, lipgloss.NewStyle().Bold(true).Render("Set up")) + "\n")
-	if m.formError != "" {
-		b.WriteString("\n" + sBad.Render(m.formError) + "\n")
-	}
-	if !m.framed { // the frame's key bar says it
-		b.WriteString("\n" + sDim.Render("tab or ↑↓ to move · space to tick · enter on Set up to start · ctrl+c to leave") + "\n")
-	}
-	return b.String()
-}
-
 // runInitTUI runs init with the screen above, asking the form first when
 // the flags left the administrator unset.
 func (in *serverInit) runInitTUI(ctx context.Context, out io.Writer) error {
@@ -3,6 +3,7 @@ package cli
 import (
 	"strings"
 	"testing"
+	"time"

 	tea "github.com/charmbracelet/bubbletea"
 )
@@ -11,23 +12,54 @@ func typeIn(m tea.Model, s string) tea.Model {
 	return send(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)})
 }

+// toPart moves the focus in the list of parts to the one titled so.
+func toPart(t *testing.T, m tea.Model, title string) tea.Model {
+	t.Helper()
+	f := m.(initModel).choices
+	for i := 0; i <= len(f.parts); i++ {
+		if f.focus < len(f.parts) && f.parts[f.focus].title == title {
+			return m
+		}
+		m = press(m, "down")
+	}
+	t.Fatalf("no part %q", title)
+	return m
+}
+
+// toNext moves the focus to the button that goes on, and presses it.
+func toNext(m tea.Model) tea.Model {
+	f := m.(initModel).choices
+	for f.focus != len(f.parts) {
+		m = press(m, "down")
+	}
+	return press(m, "enter")
+}
+
 func TestTheInitFormBecomesInitsSettings(t *testing.T) {
 	in := &serverInit{pkiDir: "/etc/llmgw/pki"}
 	var m tea.Model = newInitModel(in, []string{"10.0.0.140"}, true)
-	if v := m.View(); !strings.Contains(v, "Already in the certificate: 10.0.0.140") {
+	m = press(toPart(t, m, "Control plane"), "enter")
+	m = typeIn(m, "ops@example.com")
+	m = press(m, "tab")
+	if v := m.View(); !strings.Contains(v, "Already in its certificate: 10.0.0.140") {
 		t.Fatalf("the addresses found are not shown:\n%s", v)
 	}
-	m = typeIn(m, "ops@example.com")
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab})
 	m = typeIn(m, "llm.example.com, 203.0.113.10")
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab})
+	m = press(m, "esc")
+	m = press(toPart(t, m, "Store"), "enter", "right", "esc") // PostgreSQL
+	// Turning notifications on asks for the webhook at once.
+	m = press(toPart(t, m, "Notifications"), "space")
+	if m.(initModel).choices.dialog == nil {
+		t.Fatal("notifications turned on without asking where")
+	}
 	m = typeIn(m, "https://hooks.slack.com/services/T1/B2/x, json:https://alerts.example.com/in")
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(" ")}) // PostgreSQL on
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab},
-		tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(" ")}) // starter model off
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(" ")})         // judge off
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab}) // no bundle
-	m = send(m, tea.KeyMsg{Type: tea.KeyEnter})
+	m = press(m, "esc")
+	m = press(toPart(t, m, "Starter model"), "space")     // off
+	m = press(toPart(t, m, "Guardrails' judge"), "space") // off
+	m = toNext(m)
+	if !m.(initModel).plan {
+		t.Fatalf("Next did not lead to the plan: %s", m.(initModel).choices.err)
+	}

 	if in.admin != "ops@example.com" || strings.Join(in.hosts, "|") != "llm.example.com|203.0.113.10" {
 		t.Errorf("admin %q hosts %q", in.admin, in.hosts)
@@ -38,24 +70,33 @@ func TestTheInitFormBecomesInitsSettings(t *testing.T) {
 	if hooks, err := parseWebhooks(in.webhooks); err != nil || len(hooks) != 2 || hooks[0].Format != "slack" || hooks[1].Format != "json" {
 		t.Errorf("webhooks %q: %+v %v", in.webhooks, hooks, err)
 	}
+	v := m.View()
+	for _, want := range []string{"✓ Store", "PostgreSQL on this machine", "Left out", "Starter model", "--postgres", "--no-model"} {
+		if !strings.Contains(v, want) {
+			t.Errorf("the plan lacks %q:\n%s", want, v)
+		}
+	}
+	m = press(m, "enter")
 	if m.(initModel).form {
-		t.Error("the form stayed up after Set up")
+		t.Error("the form stayed up after the plan was agreed to")
 	}
 }

 func TestAWebhookThatIsNoAddressKeepsTheFormUp(t *testing.T) {
 	in := &serverInit{}
 	var m tea.Model = newInitModel(in, nil, true)
-	for range fWebhooks {
-		m = send(m, tea.KeyMsg{Type: tea.KeyTab})
-	}
+	m = press(toPart(t, m, "Notifications"), "space")
 	m = typeIn(m, "hooks.slack.com/services/x")
-	for range fStart - fWebhooks {
-		m = send(m, tea.KeyMsg{Type: tea.KeyTab})
+	m = toNext(press(m, "esc"))
+	im := m.(initModel)
+	if !im.form || im.plan || !strings.Contains(m.View(), "http(s) address") {
+		t.Fatalf("an address without its scheme was taken:\n%s", m.View())
 	}
-	m = send(m, tea.KeyMsg{Type: tea.KeyEnter})
-	if !m.(initModel).form || m.(initModel).focus != fWebhooks || !strings.Contains(m.View(), "http(s) address") {
-		t.Errorf("an address without its scheme was taken:\n%s", m.View())
+	// Closing the message opens the field that is wrong.
+	m = press(m, "q")
+	d := m.(initModel).choices.dialog
+	if d == nil || d.Fields[d.focus] != m.(initModel).choices.webhooks {
+		t.Errorf("the webhook was not given the cursor")
 	}
 }

@@ -65,34 +106,119 @@ func TestAnOfflineBundleIsGivenInTheFormWithItsDigest(t *testing.T) {
 	if v := m.View(); !strings.Contains(v, "Offline bundle") {
 		t.Fatalf("the form offers no bundle:\n%s", v)
 	}
-	for range fBundle {
-		m = send(m, tea.KeyMsg{Type: tea.KeyTab})
-	}
+	m = press(toPart(t, m, "Offline bundle"), "space")
 	m = typeIn(m, "/media/usb/b.tar")
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyEnter})
-	if !m.(initModel).form || !strings.Contains(m.View(), "sha256") || m.(initModel).focus != fBundleSHA {
+	m = toNext(press(m, "esc"))
+	if m.(initModel).plan || !strings.Contains(m.View(), "sha256") {
 		t.Fatalf("a bundle without its digest was accepted:\n%s", m.View())
 	}
+	m = press(m, "q") // the message closed, the digest has the cursor
 	m = typeIn(m, strings.Repeat("AB", 32))
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyEnter})
-	if m.(initModel).form || in.bundle != "/media/usb/b.tar" || in.bundleSHA != strings.Repeat("ab", 32) {
-		t.Errorf("bundle %q sha %q, form up %v", in.bundle, in.bundleSHA, m.(initModel).form)
+	m = toNext(press(m, "esc"))
+	if !m.(initModel).plan || in.bundle != "/media/usb/b.tar" || in.bundleSHA != strings.Repeat("ab", 32) {
+		t.Errorf("bundle %q sha %q, plan %v: %s", in.bundle, in.bundleSHA, m.(initModel).plan, m.(initModel).choices.err)
 	}
 }

 func TestAnEmailThatIsNotOneIsSaidSo(t *testing.T) {
 	in := &serverInit{}
 	var m tea.Model = newInitModel(in, nil, true)
+	m = press(m, "enter") // the control plane, first
 	m = typeIn(m, "not an address")
-	for range fStart {
-		m = send(m, tea.KeyMsg{Type: tea.KeyTab})
-	}
-	m = send(m, tea.KeyMsg{Type: tea.KeyEnter})
-	if !m.(initModel).form || !strings.Contains(m.View(), "not an address") {
+	m = toNext(press(m, "esc"))
+	if m.(initModel).plan || !strings.Contains(m.View(), "not an address") {
 		t.Errorf("a bad email was accepted:\n%s", m.View())
 	}
 }

+func TestEachPartsSettingsReachInit(t *testing.T) {
+	in := &serverInit{}
+	var m tea.Model = newInitModel(in, nil, true)
+	m = press(toPart(t, m, "Control plane"), "enter", "tab", "tab", "right", "tab", "right", "esc") // Türkçe, sign-up open
+	// The starter: qwen3-8b, the fifth, with 8192 tokens.
+	m = press(toPart(t, m, "Starter model"), "enter", "right", "right", "right", "right", "tab")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "8192"), "esc")
+	// The judge: serving flagged, three copies, 3s, and PII too.
+	m = press(toPart(t, m, "Guardrails' judge"), "enter", "right", "tab")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "3"), "tab")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = typeIn(m, "3s")
+	for range 6 { // past the five ticked, to PII
+		m = press(m, "tab")
+	}
+	m = press(m, "space", "esc")
+	m = press(toPart(t, m, "Pictures and 3D"), "space")
+	m = press(toPart(t, m, "Limits and keys"), "enter")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "120"), "tab", "tab")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "30"), "esc")
+	m = press(toPart(t, m, "Taking turns on a card"), "enter")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "1m"), "tab")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "1m"), "esc")
+	m = press(toPart(t, m, "Model mirror"), "enter", "tab")
+	m = send(m, tea.KeyMsg{Type: tea.KeyCtrlU})
+	m = press(typeIn(m, "/data/models"), "esc")
+	m = toNext(m)
+	if !m.(initModel).plan {
+		t.Fatalf("not taken: %s", m.(initModel).choices.err)
+	}
+	switch {
+	case in.language != "tr" || !in.signupOpen:
+		t.Errorf("language %q signup %v", in.language, in.signupOpen)
+	case in.starter.Name != "qwen3-8b" || in.starterCtx != 8192:
+		t.Errorf("starter %q ctx %d", in.starter.Name, in.starterCtx)
+	case in.judge.Fail != "open" || in.judge.Replicas != 3 || in.judge.Budget != 3*time.Second ||
+		len(in.judge.Categories) != 6 || in.judge.Categories[5] != "PII":
+		t.Errorf("judge %+v", in.judge)
+	case !in.media:
+		t.Error("pictures and 3D not taken")
+	case in.defaultRPM != 120 || in.defaultTPM != defaultTPM || in.maxKeyTTL != 30*24*time.Hour:
+		t.Errorf("limits %d %d %s", in.defaultRPM, in.defaultTPM, in.maxKeyTTL)
+	case in.evictAfterIdle != time.Minute || in.minLifetime != time.Minute:
+		t.Errorf("turns %s %s", in.evictAfterIdle, in.minLifetime)
+	case in.mirrorPath != "/data/models":
+		t.Errorf("mirror %q", in.mirrorPath)
+	}
+	v := m.View()
+	for _, want := range []string{"--starter qwen3-8b", "--starter-context 8192", "--judge-fail open", "--judge-replicas 3",
+		"--language tr", "--media", "--mirror-dir /data/models", "--evict-after-idle 1m", "--max-key-ttl 720h"} {
+		if !strings.Contains(v, want) {
+			t.Errorf("the command lacks %q:\n%s", want, v)
+		}
+	}
+}
+
+func TestAStarterModelWantsTheMirror(t *testing.T) {
+	in := &serverInit{}
+	var m tea.Model = newInitModel(in, nil, true)
+	m = toNext(press(toPart(t, m, "Model mirror"), "space"))
+	if m.(initModel).plan || !strings.Contains(m.View(), "turn the mirror on") {
+		t.Errorf("a starter model with no mirror to fetch it into was taken:\n%s", m.View())
+	}
+}
+
+func TestALongDialogScrollsWithItsFocus(t *testing.T) {
+	in := &serverInit{}
+	m := newInitModel(in, nil, true)
+	m.choices.height = 24
+	var tm tea.Model = press(toPart(t, m, "Guardrails' judge"), "enter")
+	_, top := tm.(initModel).choices.overlay()
+	if !strings.Contains(top, "↓ more") || strings.Contains(top, "Copyright Violation") {
+		t.Fatalf("a dialog taller than the screen is not cut:\n%s", top)
+	}
+	for range 11 {
+		tm = press(tm, "tab")
+	}
+	if _, bottom := tm.(initModel).choices.overlay(); !strings.Contains(bottom, "Copyright Violation") {
+		t.Errorf("the focus went where it cannot be seen:\n%s", bottom)
+	}
+}
+
 func TestInitsLinesAreFiledAndThePasswordKeptInView(t *testing.T) {
 	in := &serverInit{admin: "ops@example.com", pkiDir: "/etc/llmgw/pki"}
 	var m tea.Model = newInitModel(in, nil, false)
@@ -132,17 +258,14 @@ func TestInitsLinesAreFiledAndThePasswordKeptInView(t *testing.T) {
 	}
 }

-func TestWithAMirrorElsewhereTheFormDoesNotOfferOne(t *testing.T) {
+func TestWithAMirrorElsewhereTheFormSaysSo(t *testing.T) {
 	in := &serverInit{mirrorURL: "http://10.0.0.150:8082"}
 	var m tea.Model = newInitModel(in, nil, true)
-	if v := m.View(); !strings.Contains(v, "at http://10.0.0.150:8082, from --mirror") {
+	if v := m.View(); !strings.Contains(v, "at http://10.0.0.150:8082") {
 		t.Errorf("the mirror in use is not shown:\n%s", v)
 	}
-	// Tab from the addresses goes to the webhooks, past the mirror line to
-	// PostgreSQL, then the node.
-	m = send(m, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab}, tea.KeyMsg{Type: tea.KeyTab},
-		tea.KeyMsg{Type: tea.KeyTab})
-	if f := m.(initModel).focus; f != fNode {
-		t.Errorf("focus %d, want the node toggle %d", f, fNode)
+	m = toNext(m)
+	if !m.(initModel).plan || in.mirrorURL != "http://10.0.0.150:8082" || !in.noMirror {
+		t.Errorf("mirror %q noMirror %v: %s", in.mirrorURL, in.noMirror, m.(initModel).choices.err)
 	}
 }
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 	"net"
-	"net/mail"
 	"os"
 	"strings"
 	"sync"
@@ -15,7 +14,6 @@ import (
 	"github.com/charmbracelet/lipgloss"

 	joinpkg "gitea.mynodes.xyz/ilker/llmgw/internal/join"
-	"gitea.mynodes.xyz/ilker/llmgw/internal/notify"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/onboard"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/pgha"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/preflight"
@@ -36,7 +34,8 @@ type setupPage int

 const (
 	pWelcome setupPage = iota
-	pAdmin
+	// pChoices is what is installed, part by part, each with its settings.
+	pChoices
 	pMachines
 	// pWait shows the codes for machines joining rather than logged into,
 	// until they have all dialled in.
@@ -113,6 +112,10 @@ func newDBMachine(n int) dbMachine {
 	if os.Getenv("SSH_AUTH_SOCK") == "" {
 		m.auth = authKey
 	}
+	// As choosing the way to log in sets them: a key file's path is not a
+	// secret to hide.
+	m.secret.Mask = m.auth == authPassword
+	m.secret.Placeholder = map[int]string{authKey: "/root/.ssh/id_ed25519", authPassword: "the user's ssh password"}[m.auth]
 	return m
 }

@@ -151,8 +154,7 @@ type setupModel struct {
 	ips    []string
 	choice int // 0 one machine, 1 high availability

-	admin, names, webhooks textField
-	afocus                 int // admin, names, webhooks, next
+	choices *installForm

 	db     [2]dbMachine
 	mfocus int // over both machines' fields, then the check button
@@ -181,14 +183,15 @@ type setupModel struct {
 }

 func newSetupModel(host string, ips []string) setupModel {
-	admin := newTextField()
-	admin.Placeholder, admin.CharLimit, admin.Width = "you@example.com", 200, 40
-	names := newTextField()
-	names.Placeholder, names.CharLimit, names.Width = "llm.example.com, 203.0.113.10", 400, 40
-	webhooks := newTextField()
-	webhooks.Placeholder, webhooks.CharLimit, webhooks.Width = "https://hooks.slack.com/services/…", 800, 40
+	in := newDefaultServerInit()
+	// The control plane of a replicated setup is not where models run;
+	// nodes are added once it is up. Either can still be chosen.
+	in.noNode, in.noModel = true, true
+	in.standbys = true
+	// Two judges, on two of the three machines' nodes.
+	in.judge.Replicas = 2
 	return setupModel{
-		ref: &progRef{}, host: host, ips: ips, admin: admin, names: names, webhooks: webhooks,
+		ref: &progRef{}, host: host, ips: ips, in: &in, choices: newInstallForm(&in, host, ips, true),
 		db: [2]dbMachine{newDBMachine(1), newDBMachine(2)}, spin: newSpinner(), width: 100, height: 30,
 		log: &[]string{}, logMu: &sync.Mutex{},
 	}
@@ -207,6 +210,7 @@ func (m setupModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
 		m.width, m.height = msg.Width, msg.Height
+		m.choices.height = msg.Height
 		m.run.width = msg.Width - navWidth - 6
 	case spinTickMsg:
 		var cmd tea.Cmd
@@ -244,6 +248,11 @@ func (m setupModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }

 func (m setupModel) key(k tea.KeyMsg) (tea.Model, tea.Cmd) {
+	// The choices' own dialogs take their keys, Esc among them.
+	if m.page == pChoices && (m.choices.dialog != nil || m.choices.err != "") {
+		m.choices.key(k, m.in)
+		return m, nil
+	}
 	// A dialog open takes the next key, whatever it is, to close it.
 	if m.formErr != "" {
 		m.formErr = ""
@@ -275,12 +284,13 @@ func (m setupModel) key(k tea.KeyMsg) (tea.Model, tea.Cmd) {
 				m.single = true
 				return m, tea.Quit
 			}
-			m.page = pAdmin
-			m.afocus = 0
-			m.admin.Focus()
+			m.page = pChoices
+		}
+	case pChoices:
+		if m.choices.key(k, m.in) {
+			m.page, m.mfocus = pMachines, 0
+			m.focusMachine()
 		}
-	case pAdmin:
-		return m.adminKey(k)
 	case pMachines:
 		return m.machinesKey(k)
 	case pCheck:
@@ -309,73 +319,6 @@ func (m setupModel) key(k tea.KeyMsg) (tea.Model, tea.Cmd) {
 	return m, nil
 }

-func (m setupModel) adminKey(k tea.KeyMsg) (tea.Model, tea.Cmd) {
-	move := func(d int) {
-		m.afocus = (m.afocus + d + 4) % 4
-		m.admin.Blur()
-		m.names.Blur()
-		m.webhooks.Blur()
-		switch m.afocus {
-		case 0:
-			m.admin.Focus()
-		case 1:
-			m.names.Focus()
-		case 2:
-			m.webhooks.Focus()
-		}
-	}
-	switch k.Type {
-	case tea.KeyTab, tea.KeyDown:
-		move(1)
-		return m, nil
-	case tea.KeyShiftTab, tea.KeyUp:
-		move(-1)
-		return m, nil
-	case tea.KeyEnter:
-		if m.afocus < 3 {
-			move(1)
-			return m, nil
-		}
-		if _, err := mail.ParseAddress(strings.TrimSpace(m.admin.Value())); err != nil {
-			m.formErr = "the administrator's email is needed, and that is not one"
-			m.afocus = 0
-			move(0)
-			return m, nil
-		}
-		if _, err := parseWebhooks(m.webhookList()); err != nil {
-			m.formErr = err.Error()
-			m.afocus = 2
-			move(0)
-			return m, nil
-		}
-		m.formErr = ""
-		m.page, m.mfocus = pMachines, 0
-		m.db[0].addr.Focus()
-		return m, nil
-	}
-	var cmd tea.Cmd
-	switch m.afocus {
-	case 0:
-		m.admin, cmd = m.admin.Update(k)
-	case 1:
-		m.names, cmd = m.names.Update(k)
-	case 2:
-		m.webhooks, cmd = m.webhooks.Update(k)
-	}
-	return m, cmd
-}
-
-// webhookList is the webhooks asked for, one an item.
-func (m setupModel) webhookList() []string {
-	var out []string
-	for _, s := range strings.Split(m.webhooks.Value(), ",") {
-		if s = strings.TrimSpace(s); s != "" {
-			out = append(out, s)
-		}
-	}
-	return out
-}
-
 func (m *setupModel) focusMachine() {
 	for i := range m.db {
 		for f := 0; f < mfCount; f++ {
@@ -534,7 +477,7 @@ func (m *setupModel) startCheck() tea.Cmd {
 		if d.auth == authJoin {
 			m.conns = append(m.conns, dbConn{remote: d.joined, addr: d.joined.Addr, joined: d.joined})
 			machines = append(machines, preflight.Machine{Name: d.joined.Hostname + " (" + d.joined.Addr + ", joined)",
-				Addr: d.joined.Addr, Roles: []preflight.Role{preflight.RoleDatabase}, Remote: d.joined})
+				Addr: d.joined.Addr, Roles: m.dbRoles(), Remote: d.joined})
 			continue
 		}
 		g := &onboard.GoSSH{
@@ -549,7 +492,7 @@ func (m *setupModel) startCheck() tea.Cmd {
 		}
 		m.conns = append(m.conns, dbConn{remote: g, addr: g.Addr, ssh: g})
 		machines = append(machines, preflight.Machine{Name: g.Addr, Addr: g.Addr,
-			Roles: []preflight.Role{preflight.RoleDatabase}, Remote: g})
+			Roles: m.dbRoles(), Remote: g})
 	}
 	m.checking = true
 	m.report = preflight.Report{}
@@ -580,6 +523,15 @@ func (m *setupModel) startCheck() tea.Cmd {
 	}
 }

+// dbRoles are what the other two machines are to be: the store, and a
+// control plane too when they stand by.
+func (m setupModel) dbRoles() []preflight.Role {
+	if m.in.standbys {
+		return []preflight.Role{preflight.RoleDatabase, preflight.RoleControl}
+	}
+	return []preflight.Role{preflight.RoleDatabase}
+}
+
 // targets are the database machines as user@address, for the command line.
 func (m setupModel) targets() []string {
 	var out []string
@@ -593,47 +545,20 @@ func (m setupModel) targets() []string {
 	return out
 }

-func (m setupModel) namesList() []string {
-	var out []string
-	for _, h := range strings.Split(m.names.Value(), ",") {
-		if h = strings.TrimSpace(h); h != "" {
-			out = append(out, h)
-		}
-	}
-	return out
-}
-
 // command is what this setup is on the command line, for doing it again
 // from a script — with keys in place, since a password cannot be given there.
 func (m setupModel) command() string {
-	parts := []string{"sudo --preserve-env=SSH_AUTH_SOCK llmgw server init",
-		"--admin " + strings.TrimSpace(m.admin.Value())}
-	for _, h := range m.namesList() {
-		parts = append(parts, "--host "+h)
-	}
-	for _, t := range m.targets() {
-		parts = append(parts, "--patroni "+t)
-	}
-	for _, w := range m.webhookList() {
-		parts = append(parts, "--webhook "+w)
-	}
-	parts = append(parts, "--no-node", "--no-model")
-	return strings.Join(parts, " \\\n    ")
+	in := *m.in
+	in.patroni = m.targets()
+	return strings.Join(append([]string{"sudo --preserve-env=SSH_AUTH_SOCK llmgw server init"}, in.initFlags()...), " \\\n    ")
 }

 // startRun installs: sudo granted where it asks for a password, the control
 // plane here, the store on the other two, then sudo taken back.
 func (m *setupModel) startRun() tea.Cmd {
-	in := newDefaultServerInit()
-	in.admin = strings.TrimSpace(m.admin.Value())
-	in.hosts = m.namesList()
+	in := m.in
 	in.patroni = m.targets()
-	in.webhooks = m.webhookList()
-	// The control plane of a replicated setup is not where models run;
-	// nodes are added once it is up.
-	in.noNode, in.noModel = true, true
-	m.in = &in
-	m.run = newInitModel(&in, nil, false)
+	m.run = newInitModel(in, nil, false)
 	m.run.running, m.run.width, m.run.spin = true, m.width, m.spin
 	ref, conns, logp, mu, listener := m.ref, m.conns, m.log, m.logMu, m.listener
 	return func() tea.Msg {
@@ -688,7 +613,7 @@ var setupSteps = []struct {
 	label string
 	page  setupPage
 }{
-	{"Start", pWelcome}, {"Administrator", pAdmin}, {"Machines", pMachines},
+	{"Start", pWelcome}, {"Choices", pChoices}, {"Machines", pMachines},
 	{"Checks", pCheck}, {"Plan", pPlan}, {"Install", pRun},
 }

@@ -721,6 +646,9 @@ func (m setupModel) View() string {
 	if m.formErr != "" {
 		f.DialogTitle, f.Dialog = "Not yet", m.formErr+"\n\n"+sDim.Render("any key to go back")
 	}
+	if m.page == pChoices {
+		f.DialogTitle, f.Dialog = m.choices.overlay()
+	}
 	return f.render()
 }

@@ -729,8 +657,12 @@ func (m setupModel) pageView() (string, string, string) {
 	switch m.page {
 	case pWelcome:
 		return "Start", m.welcomeView(), "↑↓ choose · Enter go on · Ctrl+C leave"
-	case pAdmin:
-		return "Administrator", m.adminView(), "Tab/↑↓ move · Enter next · Esc back · Ctrl+C leave"
+	case pChoices:
+		keys := m.choices.keys()
+		if m.choices.dialog == nil && m.choices.err == "" {
+			keys = strings.Replace(keys, " · Ctrl+C", " · Esc back · Ctrl+C", 1)
+		}
+		return "What to install", m.choices.view(m.width - navWidth - 6), keys
 	case pMachines:
 		return "Database machines", m.machinesView(), "Tab/↑↓ move · ←→ how to log in · Enter next · Esc back · PgUp/PgDn scroll"
 	case pWait:
@@ -771,26 +703,8 @@ func (m setupModel) welcomeView() string {
 	}
 	opt(0, "One machine", "This machine runs everything: control plane, model mirror,\n      and models if it has room.")
 	opt(1, "High availability — three machines",
-		"This one is the control plane; two more keep the store, replicated,\n      so losing any one machine loses nothing.")
-	return b.String()
-}
-
-func (m setupModel) adminView() string {
-	var b strings.Builder
-	label := func(i int, s string) string {
-		if m.afocus == i {
-			return fSelected.Render("› " + s)
-		}
-		return "  " + s
-	}
-	b.WriteString("\n")
-	fmt.Fprintf(&b, "%s\n    %s\n    %s\n\n", label(0, "Administrator's email"), m.admin.View(),
-		sDim.Render("A password is generated and shown once, at the end."))
-	fmt.Fprintf(&b, "%s\n    %s\n    %s\n\n", label(1, "Other names nodes will reach this machine by"), m.names.View(),
-		sDim.Render("Known: "+strings.Join(append([]string{m.host}, m.ips...), ", ")+". Add a DNS name or a floating address."))
-	fmt.Fprintf(&b, "%s\n    %s\n    %s\n\n", label(2, "Notification webhooks"), m.webhooks.View(),
-		sDim.Render("Where a parked model, a lost node or a spent budget is said: Slack, Mattermost, or any URL taking JSON. Optional; a test is sent."))
-	b.WriteString(button(m.afocus == 3, "Next") + "\n")
+		"Each of the three can run the gateway; two keep the store, replicated,\n"+
+			"      and etcd votes on all three, so losing any one machine loses nothing.")
 	return b.String()
 }

@@ -907,24 +821,25 @@ func (m setupModel) checkView() string {

 func (m setupModel) planView() string {
 	var b strings.Builder
-	b.WriteString("\n  What will be installed:\n\n")
-	fmt.Fprintf(&b, "  %s  %s\n      %s\n", lipgloss.NewStyle().Bold(true).Render(m.host), sDim.Render(m.thisAddr()),
-		"control plane and gateway, model mirror, etcd (the third vote)")
-	fmt.Fprintf(&b, "      administrator %s\n", strings.TrimSpace(m.admin.Value()))
-	if hooks, _ := parseWebhooks(m.webhookList()); len(hooks) > 0 {
-		var where []string
-		for _, h := range hooks {
-			where = append(where, notify.Redact(h.URL)+" ("+h.Format+")")
-		}
-		fmt.Fprintf(&b, "      alerts to %s\n", strings.Join(where, ", "))
+	b.WriteString(m.choices.planView(m.width - navWidth - 6))
+	b.WriteString("\n  " + lipgloss.NewStyle().Bold(true).Render("The three machines") + "\n")
+	here := "control plane, leading at first; model mirror; etcd"
+	there := "PostgreSQL under Patroni, etcd"
+	if m.in.standbys {
+		there = "control plane, standing by; " + there
 	}
+	if m.in.vip != "" {
+		here += "; keepalived"
+		there += "; keepalived"
+	}
+	fmt.Fprintf(&b, "  %s  %s\n      %s\n", lipgloss.NewStyle().Bold(true).Render(m.host), sDim.Render(m.thisAddr()), here)
 	granted := false
 	for _, d := range m.db {
 		addr := strings.TrimSpace(d.addr.Value())
 		if d.joined != nil {
 			addr = d.joined.Hostname + "  " + sDim.Render(d.joined.Addr+", joined")
 		}
-		fmt.Fprintf(&b, "  %s\n      PostgreSQL under Patroni, etcd\n", lipgloss.NewStyle().Bold(true).Render(addr))
+		fmt.Fprintf(&b, "  %s\n      %s\n", lipgloss.NewStyle().Bold(true).Render(addr), there)
 		granted = granted || d.sudo.Value() != ""
 	}
 	b.WriteString("\n  The store is replicated from the first to the second; if the primary is lost\n" +
@@ -26,6 +26,12 @@ func press(m tea.Model, keys ...string) tea.Model {
 			msg = tea.KeyMsg{Type: tea.KeyTab}
 		case "down":
 			msg = tea.KeyMsg{Type: tea.KeyDown}
+		case "up":
+			msg = tea.KeyMsg{Type: tea.KeyUp}
+		case "space":
+			msg = tea.KeyMsg{Type: tea.KeySpace, Runes: []rune(" ")}
+		case "left":
+			msg = tea.KeyMsg{Type: tea.KeyLeft}
 		case "esc":
 			msg = tea.KeyMsg{Type: tea.KeyEsc}
 		case "right":
@@ -41,20 +47,28 @@ func press(m tea.Model, keys ...string) tea.Model {
 func TestTheSetupAsksForWhatHighAvailabilityNeedsAndRefusesWhatWillNotDo(t *testing.T) {
 	m := tea.Model(newSetupModel("ctl", []string{"10.0.0.5"}))
 	m = press(m, "down", "enter")
-	if s := m.(setupModel); s.page != pAdmin {
-		t.Fatalf("high availability did not lead to the administrator: page %d", s.page)
+	if s := m.(setupModel); s.page != pChoices {
+		t.Fatalf("high availability did not lead to the choices: page %d", s.page)
+	}
+	// Three machines, each a control plane, unless told otherwise.
+	if v := m.View(); !strings.Contains(v, "Control plane on all three") || !strings.Contains(v, "two standbys") {
+		t.Errorf("the standbys are not offered, ticked:\n%s", v)
 	}
 	// No email: refused, with a reason.
-	m = press(m, "tab", "tab", "tab", "enter")
-	if s := m.(setupModel); s.page != pAdmin || !strings.Contains(s.formErr, "email") {
-		t.Fatalf("went on without an administrator: %+v", s.formErr)
+	m = press(m, "up", "enter")
+	if s := m.(setupModel); s.page != pChoices || !strings.Contains(s.choices.err, "email") {
+		t.Fatalf("went on without an administrator: %+v", s.choices.err)
 	}
-	// The refusal is a dialog; a key closes it, and the cursor is back on
-	// the email.
+	// The refusal is a dialog; a key closes it, and the control plane's
+	// settings open with the cursor on the email.
 	if !strings.Contains(m.View(), "Not yet") {
 		t.Error("the refusal was not shown as a dialog")
 	}
-	m = press(m, "x", "a@example.com", "tab", "tab", "tab", "enter")
+	m = press(m, "q")
+	if s := m.(setupModel); s.choices.dialog == nil || s.choices.dialog.Fields[s.choices.dialog.focus] != s.choices.admin {
+		t.Fatal("the email was not given the cursor")
+	}
+	m = press(m, "a@example.com", "esc", "enter")
 	s := m.(setupModel)
 	if s.page != pMachines {
 		t.Fatalf("page %d: %s", s.page, s.formErr)
@@ -78,7 +92,7 @@ func TestTheSetupAsksForWhatHighAvailabilityNeedsAndRefusesWhatWillNotDo(t *test
 		t.Errorf("a valid pair refused: %s", err)
 	}
 	cmd := s.command()
-	for _, want := range []string{"--admin a@example.com", "--patroni ubuntu@10.0.0.6", "--patroni ubuntu@10.0.0.7", "--no-node"} {
+	for _, want := range []string{"--admin a@example.com", "--patroni ubuntu@10.0.0.6", "--patroni ubuntu@10.0.0.7", "--no-node", "--standbys"} {
 		if !strings.Contains(cmd, want) {
 			t.Errorf("command lacks %q:\n%s", want, cmd)
 		}
@@ -442,6 +442,9 @@ type Auth struct {

 	// OIDC is sign-in through an identity provider.
 	OIDC OIDC `koanf:"oidc"`
+	// LDAP is sign-in against a directory, Active Directory above all, and
+	// the accounts kept in step with it.
+	LDAP LDAP `koanf:"ldap"`
 	// SCIM is account provisioning by the identity provider.
 	SCIM SCIM `koanf:"scim"`

@@ -550,7 +553,7 @@ type Control struct {
 	// Only meaningful with a shared store, where a second control plane can
 	// see the claim. Long enough to survive a slow query or a brief network
 	// stall, short enough that a standby takes over before anyone has finished
-	// reading the alert. Zero takes the default.
+	// reading the alert. Zero takes the default, 10s.
 	LeaseTTL time.Duration `koanf:"lease_ttl"`
 }

@@ -968,6 +971,12 @@ func (s Server) Validate() error {
 	if err := s.Auth.OIDC.Validate(); err != nil {
 		return err
 	}
+	if err := s.Auth.LDAP.Validate(); err != nil {
+		return err
+	}
+	if s.Auth.LDAP.Enabled() && !s.Auth.Enabled {
+		return fmt.Errorf("auth.ldap needs auth.enabled: it signs people in to the accounts the store keeps")
+	}
 	if err := s.AgentTLS.Validate(); err != nil {
 		return err
 	}
@@ -0,0 +1,137 @@
+package config
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// LDAP is sign-in against a directory — Active Directory above all — with
+// the directory's own passwords, and the accounts kept in step with it.
+//
+//	auth:
+//	  ldap:
+//	    urls: [ldaps://dc1.corp.example.com, ldaps://dc2.corp.example.com]
+//	    bind_dn: CN=llmgw,OU=Service Accounts,DC=corp,DC=example,DC=com
+//	    bind_password_file: /etc/llmgw/secrets/ldap-bind
+//	    base_dn: OU=Staff,DC=corp,DC=example,DC=com
+//	    create_accounts: true
+//	    roles: {admin: [llmgw-admins]}
+//	    memberships: {ml-team: "team:Acme/ml"}
+//
+// A person signs in on the portal's form with their sAMAccountName, their
+// userPrincipalName or their mail, and their directory password. The
+// gateway finds them with the bind account, checks the password by binding
+// as them, and reads their groups, nested ones included. Every sync_interval
+// the leader reads the directory again: an account disabled or gone there
+// is suspended here, its sessions ended and its API keys refused.
+type LDAP struct {
+	// URLs are the directory's servers, tried in turn: ldaps:// (636), or
+	// ldap:// (389) with StartTLS.
+	URLs []string `koanf:"urls"`
+	// StartTLS upgrades an ldap:// connection before anything is sent. A
+	// password never crosses a connection without TLS: ldap:// without it
+	// is refused.
+	StartTLS bool `koanf:"start_tls"`
+	// CAFile is the authority the servers' certificates are checked against,
+	// when it is not the system's: an AD Certificate Services root.
+	CAFile string `koanf:"ca_file"`
+	// BindDN and the file holding its password: a service account that may
+	// read users and groups. Nothing is written to the directory.
+	BindDN           string `koanf:"bind_dn"`
+	BindPasswordFile string `koanf:"bind_password_file"`
+	// BaseDN is where people are searched for, subtree included.
+	BaseDN string `koanf:"base_dn"`
+	// GroupBaseDN is where their groups are; empty is BaseDN's domain root.
+	GroupBaseDN string `koanf:"group_base_dn"`
+	// UserFilter narrows who may sign in, ANDed with the login match: a
+	// group (memberOf=...) or an OU's people only. Empty is every enabled
+	// user object.
+	UserFilter string `koanf:"user_filter"`
+	// Label is what the form says to sign in with: "Sign in with your
+	// <label> account". Empty is "Active Directory".
+	Label string `koanf:"label"`
+	// CreateAccounts makes an account, active, for a person the directory
+	// vouches for and the gateway does not know. Off, only existing accounts
+	// sign in this way.
+	CreateAccounts bool `koanf:"create_accounts"`
+	// Roles maps a staff role (viewer, operator, billing, admin) to the
+	// groups that give it, by name (CN) or whole DN. Set at every sign-in
+	// and sync: someone taken out of the group loses the role.
+	Roles map[string][]string `koanf:"roles"`
+	// Memberships maps a group, by CN or DN, to a place in the tree —
+	// org:NAME, team:ORG/TEAM, project:ORG/TEAM/PROJECT — joined at sign-in
+	// and kept by the sync, which also takes away a place whose group the
+	// person has left.
+	Memberships map[string]string `koanf:"memberships"`
+	// SyncInterval is how often the leader reads the directory. Zero is
+	// 15m; negative turns the sync off, leaving only sign-in.
+	SyncInterval time.Duration `koanf:"sync_interval"`
+	// Timeout bounds each round trip to a server. Zero is 10s.
+	Timeout time.Duration `koanf:"timeout"`
+}
+
+// Enabled reports whether directory sign-in is configured.
+func (l LDAP) Enabled() bool { return len(l.URLs) > 0 }
+
+// Validate says what in the configuration cannot work.
+func (l LDAP) Validate() error {
+	if !l.Enabled() {
+		return nil
+	}
+	for _, raw := range l.URLs {
+		u, err := url.Parse(raw)
+		if err != nil || u.Host == "" {
+			return fmt.Errorf("auth.ldap.urls: %q is not an ldap:// or ldaps:// address", raw)
+		}
+		switch u.Scheme {
+		case "ldaps":
+		case "ldap":
+			if !l.StartTLS {
+				return fmt.Errorf("auth.ldap.urls: %q is plaintext: use ldaps://, or set start_tls; passwords would cross it", raw)
+			}
+		default:
+			return fmt.Errorf("auth.ldap.urls: %q is not an ldap:// or ldaps:// address", raw)
+		}
+	}
+	switch {
+	case strings.TrimSpace(l.BindDN) == "" || l.BindPasswordFile == "":
+		return errors.New("auth.ldap: bind_dn and bind_password_file are needed, for the account that finds people")
+	case strings.TrimSpace(l.BaseDN) == "":
+		return errors.New("auth.ldap: base_dn is needed, where people are searched for")
+	case l.UserFilter != "" && !(strings.HasPrefix(l.UserFilter, "(") && strings.HasSuffix(l.UserFilter, ")")):
+		return fmt.Errorf("auth.ldap.user_filter: %q is not an LDAP filter in parentheses", l.UserFilter)
+	}
+	for role := range l.Roles {
+		if !validStaffRole(role) {
+			return fmt.Errorf("auth.ldap.roles: %q is not viewer, operator, billing or admin", role)
+		}
+	}
+	for g, place := range l.Memberships {
+		if !validPlace(place) {
+			return fmt.Errorf("auth.ldap.memberships[%s]: %q is not org:NAME, team:ORG/TEAM or project:ORG/TEAM/PROJECT", g, place)
+		}
+	}
+	return nil
+}
+
+// Interval is SyncInterval with its default; zero means off.
+func (l LDAP) Interval() time.Duration {
+	switch {
+	case l.SyncInterval < 0:
+		return 0
+	case l.SyncInterval == 0:
+		return 15 * time.Minute
+	}
+	return l.SyncInterval
+}
+
+// RoundTrip is Timeout with its default.
+func (l LDAP) RoundTrip() time.Duration {
+	if l.Timeout <= 0 {
+		return 10 * time.Second
+	}
+	return l.Timeout
+}
@@ -72,21 +72,34 @@ func (o OIDC) Validate() error {
 		return errors.New("auth.oidc.client_id is required")
 	}
 	for role := range o.Roles {
-		switch role {
-		case "viewer", "operator", "billing", "admin":
-		default:
+		if !validStaffRole(role) {
 			return fmt.Errorf("auth.oidc.roles: %q is not viewer, operator, billing or admin", role)
 		}
 	}
 	for g, where := range o.Memberships {
-		kind, path, ok := strings.Cut(where, ":")
-		if !ok || path == "" || (kind != "org" && kind != "team" && kind != "project") {
+		if !validPlace(where) {
 			return fmt.Errorf("auth.oidc.memberships.%s is %q: org:NAME, team:ORG/TEAM or project:ORG/TEAM/PROJECT", g, where)
 		}
 	}
 	return nil
 }

+// validStaffRole is a role groups may give: viewer, operator, billing, admin.
+func validStaffRole(role string) bool {
+	switch role {
+	case "viewer", "operator", "billing", "admin":
+		return true
+	}
+	return false
+}
+
+// validPlace is a place in the tree a group may give: org:NAME,
+// team:ORG/TEAM or project:ORG/TEAM/PROJECT.
+func validPlace(where string) bool {
+	kind, path, ok := strings.Cut(where, ":")
+	return ok && path != "" && (kind == "org" || kind == "team" || kind == "project")
+}
+
 // SCIM lets an identity provider provision accounts (/scim/v2): made,
 // suspended and reinstated as they are there, with groups mapped by
 // auth.oidc's roles and memberships.
@@ -45,6 +45,19 @@ func (a *API) nodeExporterTargetsWith(r *http.Request, nodes []NodeView) []SDGro
 		name, _ := os.Hostname()
 		add(host, name, "control-plane")
 	}
+	// Every control plane, not this one only, before the store's members:
+	// Prometheus asks each of them, and a machine that one called a control
+	// plane and another a store member was two targets, its every series
+	// counted twice.
+	if a.controlPlanes != nil {
+		for _, cp := range a.controlPlanes().Members {
+			host := cp.Address
+			if h, _, err := net.SplitHostPort(host); err == nil {
+				host = h
+			}
+			add(strings.TrimSpace(host), cp.Name, "control-plane")
+		}
+	}
 	for _, n := range nodes {
 		host := n.MgmtAddr
 		if h, _, err := net.SplitHostPort(host); err == nil {
@@ -21,3 +21,29 @@ func TestNodeExporterTargetsAreTheControlPlaneAndTheStore(t *testing.T) {
 		}
 	}
 }
+
+func TestEveryControlPlaneListsTheOthersAlike(t *testing.T) {
+	// 140 called 150 a store member and 150 called itself a control plane:
+	// Prometheus, asking both, scraped 150 twice and counted it twice.
+	targets := func(self string) map[string]string {
+		a := &API{}
+		a.SetStoreStatus(func() ([]StoreMember, error) {
+			return []StoreMember{{Name: "llmgw-pg01", Host: "10.0.0.149"}, {Name: "llmgw-ctl02", Host: "10.0.0.150"}}, nil
+		})
+		a.SetControlPlanes(func() ControlPlanes {
+			return ControlPlanes{Members: []ControlPlane{{Name: "llmgw-ctl", Address: "10.0.0.140:7443"},
+				{Name: "llmgw-ctl02", Address: "10.0.0.150:7443"}}}
+		})
+		r := httptest.NewRequest("GET", "http://"+self+":9091/prometheus/targets", nil)
+		out := map[string]string{}
+		for _, g := range a.nodeExporterTargetsWith(r, nil) {
+			out[g.Targets[0]] = g.Labels["role"]
+		}
+		return out
+	}
+	from140, from150 := targets("10.0.0.140"), targets("10.0.0.150")
+	if from140["10.0.0.150:9100"] != "control-plane" || from150["10.0.0.140:9100"] != "control-plane" ||
+		from140["10.0.0.149:9100"] != "store" {
+		t.Errorf("from 140 %v, from 150 %v", from140, from150)
+	}
+}
@@ -1533,6 +1533,11 @@ type External struct {
 	// rather than the key itself, so the key is in neither the catalog, the
 	// store nor the audit log; empty for a provider that asks for none.
 	APIKeyFile string `json:"api_key_file,omitempty" koanf:"api_key_file"`
+	// APIKeyFiles are several keys for the provider, in place of
+	// APIKeyFile: one endpoint each (external:MODEL#1, #2…), so a key that
+	// answers 429 or 401 is passed over while its breaker is open and the
+	// request goes to another. A provider's limits are per key.
+	APIKeyFiles []ExternalKey `json:"api_key_files,omitempty" koanf:"api_key_files"`
 	// Peer names the federated llmgw cluster this model is offered by, for
 	// a model that federation added (`llmgw ctl federation add`) rather
 	// than one written by hand. Such a model is named PEER/MODEL, comes and
@@ -1551,6 +1556,14 @@ type External struct {
 	Output string `json:"output,omitempty" koanf:"output"`
 }

+// ExternalKey is one of a provider's keys.
+type ExternalKey struct {
+	// File holds the key, on the control plane, as APIKeyFile does.
+	File string `json:"file" koanf:"file"`
+	// Weight is its share of the requests against the others'; zero is 1.
+	Weight float64 `json:"weight,omitempty" koanf:"weight"`
+}
+
 // APIComfyUI is External.API for a ComfyUI server.
 const APIComfyUI = "comfyui"

@@ -1568,6 +1581,20 @@ func (e *External) validate(model string, profiles int) error {
 	if strings.TrimSpace(e.Model) == "" {
 		return fmt.Errorf("model %q: external model needs the name the provider knows it by", model)
 	}
+	if e.APIKeyFile != "" && len(e.APIKeyFiles) > 0 {
+		return fmt.Errorf("model %q: api_key_file or api_key_files, not both", model)
+	}
+	for i, k := range e.APIKeyFiles {
+		if strings.TrimSpace(k.File) == "" {
+			return fmt.Errorf("model %q: api_key_files[%d] names no file", model, i)
+		}
+		if k.Weight < 0 {
+			return fmt.Errorf("model %q: api_key_files[%d] has a negative weight", model, i)
+		}
+	}
+	if len(e.APIKeyFiles) > 0 && e.Peer != "" {
+		return fmt.Errorf("model %q: a federated model is reached with its peer's key, not api_key_files", model)
+	}
 	switch e.API {
 	case "", "openai":
 		if e.Workflow != "" || e.Output != "" {
@@ -429,3 +429,23 @@ func TestAGuardModelSaysHowItIsReadAndAlwaysRuns(t *testing.T) {
 		t.Error("a judge is not critical by default")
 	}
 }
+
+func TestAProvidersKeysAreOneListOrOneFile(t *testing.T) {
+	ext := func(e External) Model {
+		e.URL, e.Model = "https://api.example.com", "m"
+		return Model{Name: "cloud", Source: "external", External: &e}
+	}
+	for _, bad := range []External{
+		{APIKeyFile: "/k", APIKeyFiles: []ExternalKey{{File: "/k2"}}},
+		{APIKeyFiles: []ExternalKey{{File: " "}}},
+		{APIKeyFiles: []ExternalKey{{File: "/k", Weight: -1}}},
+		{Peer: "p", APIKeyFiles: []ExternalKey{{File: "/k"}}},
+	} {
+		if _, err := New([]Model{ext(bad)}); err == nil {
+			t.Errorf("taken: %+v", bad)
+		}
+	}
+	if _, err := New([]Model{ext(External{APIKeyFiles: []ExternalKey{{File: "/a", Weight: 2}, {File: "/b"}}})}); err != nil {
+		t.Error(err)
+	}
+}
@@ -438,15 +438,6 @@ func (c *Controller) externalEndpoints() []endpoint.Info {
 				continue
 			}
 		}
-		key := ""
-		if f := m.External.APIKeyFile; f != "" {
-			b, err := secrets.Read(context.Background(), f)
-			if err != nil {
-				c.log.Warn("an external model's key could not be read; not offered", "model", m.Name, "err", err)
-				continue
-			}
-			key = strings.TrimSpace(string(b))
-		}
 		// A peer's endpoint says so in its id, which is what usage records
 		// as the replica that answered.
 		id := "external:" + m.Name
@@ -462,14 +453,39 @@ func (c *Controller) externalEndpoints() []endpoint.Info {
 			}
 			engine, workflow = endpoint.EngineComfyUI, w
 		}
-		out = append(out, endpoint.Info{
+		base := endpoint.Info{
 			ID: id, URL: strings.TrimRight(m.External.URL, "/"),
-			Models: append([]string{m.Name}, m.Aliases...), APIKey: key,
+			Models: append([]string{m.Name}, m.Aliases...),
 			Engine: engine, Pool: "external", Weight: 1,
 			UpstreamModel: m.External.Model,
 			Peer:          m.External.Peer, PeerCluster: cluster, PeerTags: tags,
 			Workflow: workflow,
-		})
+		}
+		keys := m.External.APIKeyFiles
+		if len(keys) == 0 {
+			keys = []catalog.ExternalKey{{File: m.External.APIKeyFile}}
+		}
+		for i, k := range keys {
+			e := base
+			// One endpoint a key, numbered, so usage says which answered
+			// and a breaker stands for one key — never the key itself.
+			if len(m.External.APIKeyFiles) > 0 {
+				e.ID = fmt.Sprintf("%s#%d", id, i+1)
+				if k.Weight > 0 {
+					e.Weight = k.Weight
+				}
+			}
+			if k.File != "" {
+				b, err := secrets.Read(context.Background(), k.File)
+				if err != nil {
+					c.log.Warn("an external model's key could not be read; not offered", "model", m.Name,
+						"endpoint", e.ID, "err", err)
+					continue
+				}
+				e.APIKey = strings.TrimSpace(string(b))
+			}
+			out = append(out, e)
+		}
 	}
 	return out
 }
@@ -73,3 +73,28 @@ func TestAnExternalModelIsPublishedWithItsKeyAndNothingIsPlacedForIt(t *testing.
 		}
 	}
 }
+
+// Several keys for one provider: an endpoint each, numbered, with its
+// weight; one whose file cannot be read is left out and the others stay.
+func TestEachOfAProvidersKeysIsAnEndpointOfItsOwn(t *testing.T) {
+	dir := t.TempDir()
+	a, c := filepath.Join(dir, "a.key"), filepath.Join(dir, "c.key")
+	_ = os.WriteFile(a, []byte("sk-a\n"), 0o600)
+	_ = os.WriteFile(c, []byte("sk-c"), 0o600)
+	cat, err := catalog.New([]catalog.Model{{Name: "cloud", Source: "external",
+		External: &catalog.External{URL: "https://api.example.com", Model: "gpt-4o-mini",
+			APIKeyFiles: []catalog.ExternalKey{{File: a, Weight: 3}, {File: filepath.Join(dir, "gone")}, {File: c}}}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	sink := &recordSink{}
+	New(DefaultConfig(), catalog.NewLive(cat), noDispatch{}, sink, slog.New(slog.DiscardHandler)).Publish(t.Context())
+	got := map[string]endpoint.Info{}
+	for _, e := range sink.infos {
+		got[e.ID] = e
+	}
+	if len(got) != 2 || got["external:cloud#1"].APIKey != "sk-a" || got["external:cloud#1"].Weight != 3 ||
+		got["external:cloud#3"].APIKey != "sk-c" || got["external:cloud#3"].Weight != 1 {
+		t.Errorf("published %+v", sink.infos)
+	}
+}
@@ -3,6 +3,7 @@ package control
 import (
 	"context"
 	"crypto/rand"
+	"database/sql"
 	"encoding/hex"
 	"errors"
 	"log/slog"
@@ -59,6 +60,17 @@ type Leadership struct {

 	hookMu sync.Mutex
 	onLead []func()
+
+	// cut is a store this process could not reach, and back when it was
+	// reached again: Run's alone, so unlocked.
+	cut  bool
+	back time.Time
+}
+
+// LeaseReader reads who holds a lease without competing for it: a store
+// that has it lets a standby hold back after the store returns.
+type LeaseReader interface {
+	Leadership(ctx context.Context, role string) (store.Lease, error)
 }

 // OnLead is called each time this process becomes the leader, after
@@ -91,8 +103,9 @@ func NewLeadership(st LeaseStore, ttl time.Duration, log *slog.Logger) *Leadersh
 	if ttl <= 0 {
 		// Long enough to survive a slow database or a brief network stall,
 		// short enough that a standby takes over before anyone has finished
-		// reading the alert.
-		ttl = 15 * time.Second
+		// reading the alert. A store out of reach for longer — its primary
+		// being replaced — does not move it: see holdBack.
+		ttl = 10 * time.Second
 	}
 	l := &Leadership{
 		store: st,
@@ -146,6 +159,9 @@ func (l *Leadership) attempt(ctx context.Context) {
 	if l.stopped.Load() {
 		return
 	}
+	if l.holdBack(ctx) {
+		return
+	}
 	lease, err := l.store.AcquireLeadership(ctx, controlRole, l.owner, l.ttl)
 	switch {
 	case err == nil && l.stopped.Load():
@@ -177,9 +193,47 @@ func (l *Leadership) attempt(ctx context.Context) {
 		// stop a cluster from healing itself.
 		l.log.Warn("could not reach the store to renew leadership; keeping it for now",
 			"err", err)
+		l.cut, l.back = true, time.Time{}
 	}
 }

+// holdBack is a standby leaving a lapsed lease alone for one round after the
+// store returns from being out of reach.
+//
+// A store's primary that is lost takes longer to replace than the lease
+// lives, so the lease has lapsed by the time the store answers again — for
+// the leader as for the standbys, which all failed to reach it alike. The
+// first to ask then took it, and it was as often a standby as the leader:
+// leadership moved for nothing, and the new leader spent half a minute
+// learning from the agents where the judges were, refusing requests
+// meanwhile. The leader renews within a round of the store's return, so a
+// standby that waits that round takes the lease only from a leader that is
+// gone.
+func (l *Leadership) holdBack(ctx context.Context) bool {
+	if l.leader.Load() || !l.cut {
+		return false
+	}
+	r, ok := l.store.(LeaseReader)
+	if !ok {
+		l.cut = false
+		return false
+	}
+	if _, err := r.Leadership(ctx, controlRole); err != nil && !errors.Is(err, sql.ErrNoRows) {
+		l.back = time.Time{}
+		return true
+	}
+	if l.back.IsZero() {
+		l.back = time.Now()
+		l.log.Info("the store answers again; leaving the lease to its holder for a round", "owner", l.owner)
+	}
+	// A round less a tenth, for the ticker's own jitter.
+	if time.Since(l.back) < l.renew-l.renew/10 {
+		return true
+	}
+	l.cut, l.back = false, time.Time{}
+	return false
+}
+
 // StepDown gives the lease up now, for a process on its way out: called
 // before the agents are let go, so the standby they move to is already the
 // leader, and before the process exits, which would otherwise race the
@@ -1,6 +1,8 @@
 package control

 import (
+	"context"
+	"errors"
 	"log/slog"
 	"path/filepath"
 	"testing"
@@ -75,3 +77,80 @@ func TestAStandbyIsToldWhenItBecomesTheLeader(t *testing.T) {
 		t.Fatal("b became the leader and was not told")
 	}
 }
+
+// cuttable is a store that can be out of reach, as one whose primary was lost.
+type cuttable struct {
+	*store.DB
+	down bool
+}
+
+func (c *cuttable) AcquireLeadership(ctx context.Context, role, owner string, ttl time.Duration) (store.Lease, error) {
+	if c.down {
+		return store.Lease{}, errors.New("dial error: timeout")
+	}
+	return c.DB.AcquireLeadership(ctx, role, owner, ttl)
+}
+
+func (c *cuttable) Leadership(ctx context.Context, role string) (store.Lease, error) {
+	if c.down {
+		return store.Lease{}, errors.New("dial error: timeout")
+	}
+	return c.DB.Leadership(ctx, role)
+}
+
+// The store out of reach for longer than the lease lives, as while Patroni
+// promotes a standby: when it answers again the lease has lapsed for all,
+// and the leader keeps it rather than a standby taking it for nothing. A
+// leader that is truly gone is still replaced, a round later.
+func TestAStoreThatReturnsLeavesTheLeaderLeading(t *testing.T) {
+	st, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "s.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+	c := &cuttable{DB: st}
+	log := slog.New(slog.DiscardHandler)
+	ctx := t.Context()
+	const ttl = 150 * time.Millisecond
+	a, b := NewLeadership(c, ttl, log), NewLeadership(c, ttl, log)
+	a.attempt(ctx)
+	b.attempt(ctx)
+	if !a.IsLeader() || b.IsLeader() {
+		t.Fatal("a should lead, b stand by")
+	}
+
+	c.down = true
+	a.attempt(ctx)
+	b.attempt(ctx)
+	time.Sleep(ttl + 20*time.Millisecond) // the lease lapses while nobody reaches the store
+	c.down = false
+
+	b.attempt(ctx) // the standby is first to ask
+	if b.IsLeader() {
+		t.Fatal("a standby took the lease the moment the store came back")
+	}
+	a.attempt(ctx)
+	if !a.IsLeader() {
+		t.Fatal("the leader did not keep the lease")
+	}
+	time.Sleep(a.renew)
+	b.attempt(ctx)
+	if b.IsLeader() {
+		t.Error("the standby took the lease from a leader renewing it")
+	}
+
+	// Now the leader is gone: the standby takes over after its round.
+	c.down = true
+	b.attempt(ctx)
+	time.Sleep(ttl + 20*time.Millisecond)
+	c.down = false
+	b.attempt(ctx)
+	if b.IsLeader() {
+		t.Fatal("took it at once")
+	}
+	time.Sleep(b.renew)
+	b.attempt(ctx)
+	if !b.IsLeader() {
+		t.Error("a leader that was gone was not replaced")
+	}
+}
@@ -504,7 +504,11 @@ func (s *Server) run(j *Job) {
 			req = fitted
 		}
 	}
+	// Under the lock: a job is read by Get while it runs, and the race
+	// detector caught this write beside it.
+	s.mu.Lock()
 	j.Request = req
+	s.mu.Unlock()
 	memGB := int((header.MemoryBytes(set.Bytes, req.CtxPool) + 1<<30 - 1) >> 30)
 	basis := fmt.Sprintf("weights %.1f GB + KV cache %.1f GB for %d tokens + engine",
 		gb(set.Bytes), gb(int64(req.CtxPool)*header.KVBytesPerToken()), req.CtxPool)
@@ -21,6 +21,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"slices"
 	"sync"
 	"time"

@@ -248,6 +249,19 @@ func (s *Service) Resources(ctx context.Context, name, profile string, memoryGB,
 	return final, err
 }

+// SetProfiles replaces a model's profiles, as a model added with them
+// would have: for a model whose engines are to run otherwise, its args among
+// it. Running replicas keep what they were started with until restarted.
+func (s *Service) SetProfiles(ctx context.Context, name string, profiles []catalog.Profile, by string) (catalog.Model, error) {
+	if len(profiles) == 0 {
+		return catalog.Model{}, errors.New("a model needs a profile")
+	}
+	return s.update(ctx, name, by, "replace its profiles", func(m *catalog.Model) error {
+		m.Profiles = slices.Clone(profiles)
+		return nil
+	})
+}
+
 // SetClass sets a model's capacity class: critical, standard or
 // opportunistic, or empty to go back to what its scaling implies.
 func (s *Service) SetClass(ctx context.Context, name, class, by string) (catalog.Model, error) {
@@ -915,7 +915,20 @@ func (r *Reconciler) reconcileModel(ctx context.Context, m catalog.Model) {
 	// A drained replica is stopped once its replacement is serving, or once the
 	// grace period expires. Stopping it the moment it was drained would cut
 	// in-flight requests, which is the thing draining exists to avoid.
-	replaced := len(liveIDs) >= desired
+	//
+	// Serving counts a replica being restarted that still answers: with
+	// replicas restarted one after another, the second's retiring kept the
+	// first's drained one waiting out its grace — and with it the second's
+	// replacement, on a node with no room until the first had gone.
+	serving := len(liveIDs)
+	r.mu.Lock()
+	for _, id := range retiringIDs {
+		if rep, ok := r.replicas[id]; ok && rep.State == Ready {
+			serving++
+		}
+	}
+	r.mu.Unlock()
+	replaced := serving >= desired
 	for _, id := range drainingIDs {
 		r.mu.Lock()
 		rep, ok := r.replicas[id]
@@ -2436,3 +2436,51 @@ func TestTheRoomAnInPlaceRestartFreesIsItsReplacements(t *testing.T) {
 		}
 	}
 }
+
+// Two models restarted together on a node whose cores are all reserved,
+// one to need more and one less: the judge fits only once the starter
+// has given back its cores. The judge's restart waits for that, rather
+// than being refused as if nothing would ever make room. Met on a 4-core
+// single-machine install after `ctl model resources` on both.
+func TestARestartWaitsForRoomAnotherRestartWillGiveBack(t *testing.T) {
+	cpu := inventory.Node{ID: "a", MgmtAddr: "10.0.0.1", State: inventory.Ready, MemoryTotalMB: 16 * 1024, CPUCount: 4}
+	judge := catalog.Model{Name: "judge", Source: "/m", Scaling: catalog.Scaling{Min: 2, Max: 2},
+		Profiles: []catalog.Profile{{Name: "cpu", Engine: "llamacpp", MinMemoryGB: 2, CPUCores: 1}}}
+	starter := catalog.Model{Name: "starter", Source: "/m", Scaling: catalog.Scaling{Min: 1, Max: 1},
+		Profiles: []catalog.Profile{{Name: "cpu", Engine: "llamacpp", MinMemoryGB: 2, CPUCores: 2}}}
+	h := newFleetHarness(t, []catalog.Model{judge, starter}, cpu)
+	h.settle(t, 3)
+	var old []string
+	for _, rep := range h.r.ReadyReplicas() {
+		old = append(old, rep.ID)
+	}
+	if len(old) != 3 {
+		t.Fatalf("%d replicas ready, want 3", len(old))
+	}
+
+	judge.Profiles[0].CPUCores, starter.Profiles[0].CPUCores = 2, 0
+	cat, err := catalog.New([]catalog.Model{judge, starter})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h.r.cat.Store(cat)
+	if err := h.r.Restart(old...); err != nil {
+		t.Fatal(err)
+	}
+	for range 12 {
+		h.r.Reconcile(t.Context())
+		h.markReady()
+		h.advance(10 * time.Second)
+	}
+	for _, id := range old {
+		if st := h.r.RestartState(id); strings.HasPrefix(st, "refused") {
+			t.Errorf("%s: %s", id, st)
+		}
+		if rep, ok := replicaByID(h, id); ok && rep.State == Ready {
+			t.Errorf("%s still serves on its old figures", id)
+		}
+	}
+	if j, s := replicasOf(h, "judge"), replicasOf(h, "starter"); j != 2 || s != 1 {
+		t.Errorf("judge %d, starter %d after the restarts", j, s)
+	}
+}
@@ -22,6 +22,10 @@ import (
 //     stopped now, and its replacement takes its place. Waiting would change
 //     nothing; it used to wait DrainGrace anyway, five minutes reading only
 //     "restart replacing", which looked like a restart that never would.
+//   - other replicas whose own restarts are under way: the replacement fits
+//     once they have restarted, as a starter edited to reserve fewer cores
+//     gives back what a judge edited to reserve more needs. Waited for, up
+//     to DrainGrace, so that two restarts each waiting on the other end.
 //   - more than it: the replacement fits nowhere even with it stopped — its
 //     profile was edited to need more than any node has free. Stopping it
 //     would leave the model with nothing, so the restart is given up, and
@@ -62,6 +66,8 @@ func (r *Reconciler) retire(ctx context.Context, m catalog.Model, ids []string,
 			r.log.Warn("restarting a replica in place: it is the only thing in its replacement's way",
 				"replica", id, "model", m.Name)
 			r.stopForRestart(ctx, id, "restarted in place: it was the only thing in its replacement's way")
+		case outcome == noRoom && r.now().Sub(since) <= r.cfg.DrainGrace && r.fitsAfterRestarts(m, id):
+			// Another restart under way gives the room back; waited for.
 		case outcome == noRoom || outcome == overLimit:
 			r.refuseRestart(ctx, id, "its replacement fits on no node even with this replica stopped "+
 				"(llmgw ctl explain-placement "+m.Name+")")
@@ -73,6 +79,28 @@ func (r *Reconciler) retire(ctx context.Context, m catalog.Model, ids []string,
 	}
 }

+// fitsAfterRestarts is whether a model's replacement for a replica fits with
+// that replica gone and every other on its way out: queued to restart, being
+// replaced, or draining. Their replacements take room too, so this is
+// whether waiting could help, not a promise that it will.
+func (r *Reconciler) fitsAfterRestarts(m catalog.Model, id string) bool {
+	gone := []victim{{ID: id, Model: m.Name}}
+	r.mu.Lock()
+	for oid, o := range r.replicas {
+		if oid == id {
+			continue
+		}
+		if o.State == Draining || !o.RetiringAt.IsZero() || slices.Contains(r.restartQueue[o.Model], oid) {
+			gone = append(gone, victim{ID: oid, Model: o.Model})
+		}
+	}
+	r.mu.Unlock()
+	if len(gone) == 1 {
+		return false
+	}
+	return r.fitsWithout(m, nil, gone)
+}
+
 // stopForRestart drains a replica and stops it at once, and places its
 // replacement in what it freed.
 //
@@ -0,0 +1,395 @@
+// Package directory keeps accounts in step with an outside directory —
+// Active Directory over LDAP — at sign-in and by a periodic sync: made for
+// people the directory vouches for, given the staff role and the places in
+// the tree their groups map to, and suspended when the directory disables or
+// loses them.
+package directory
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/store"
+)
+
+// Identity is a person as the directory has them.
+type Identity struct {
+	// ID never changes for the person: an AD objectGUID.
+	ID    string
+	DN    string
+	Email string
+	Name  string
+	// Groups are the person's groups, nested ones included, each by its CN
+	// and by its DN, so a mapping may name either.
+	Groups []string
+	// Disabled is an account the directory has turned off.
+	Disabled bool
+}
+
+// Mapping is what a person's groups give them: a staff role and places in
+// the tree. The same shape as auth.oidc's.
+type Mapping struct {
+	Roles       map[string][]string
+	Memberships map[string]string
+}
+
+// Role is the highest staff role the groups give, "" when none.
+func (m Mapping) Role(groups []string) string {
+	for _, r := range []string{store.RoleAdmin, store.RoleOperator, store.RoleBilling, store.RoleViewer} {
+		if slices.ContainsFunc(m.Roles[r], func(g string) bool { return hasGroup(groups, g) }) {
+			return r
+		}
+	}
+	return ""
+}
+
+// Places are the places in the tree the groups give, each once.
+func (m Mapping) Places(groups []string) []string {
+	var out []string
+	for g, where := range m.Memberships {
+		if hasGroup(groups, g) && !slices.Contains(out, where) {
+			out = append(out, where)
+		}
+	}
+	slices.Sort(out)
+	return out
+}
+
+// Groups are every group the mapping names.
+func (m Mapping) Groups() []string {
+	var out []string
+	add := func(g string) {
+		if !slices.ContainsFunc(out, func(o string) bool { return strings.EqualFold(o, g) }) {
+			out = append(out, g)
+		}
+	}
+	for _, gs := range m.Roles {
+		for _, g := range gs {
+			add(g)
+		}
+	}
+	for g := range m.Memberships {
+		add(g)
+	}
+	slices.Sort(out)
+	return out
+}
+
+// hasGroup matches a group's CN or DN as AD does: case aside.
+func hasGroup(groups []string, g string) bool {
+	return slices.ContainsFunc(groups, func(have string) bool { return strings.EqualFold(have, g) })
+}
+
+// Store is what keeping accounts needs of the store.
+type Store interface {
+	UserByEmail(ctx context.Context, email string) (store.User, error)
+	UserByID(ctx context.Context, id string) (store.User, error)
+	CreateUser(ctx context.Context, u store.User) error
+	SetStaffRole(ctx context.Context, id, role string) error
+	SetUserState(ctx context.Context, id string, state store.UserState) error
+	DeleteUserSessions(ctx context.Context, userID string) error
+	AddMembership(ctx context.Context, user string, scope store.Scope, id, role, by string, at time.Time) error
+	RemoveMembership(ctx context.Context, userID string, scope store.Scope, scopeID string, at time.Time) (int, error)
+	MembershipsOf(ctx context.Context, userID string) ([]store.Membership, error)
+	AllOrgs(ctx context.Context) ([]store.Org, error)
+	AllTeams(ctx context.Context) ([]store.TeamPath, error)
+	AllProjects(ctx context.Context) ([]store.ProjectPath, error)
+	DirectoryUser(ctx context.Context, directory, externalID string) (store.DirectoryLink, error)
+	LinkDirectory(ctx context.Context, userID, directory, externalID string, at time.Time) error
+	DirectoryLinks(ctx context.Context, directory string) ([]store.DirectoryLink, error)
+	SetSyncSuspended(ctx context.Context, userID string, suspended bool, at time.Time) error
+}
+
+// Keeper keeps one directory's accounts.
+type Keeper struct {
+	St Store
+	// Name is the directory's, as links and memberships record it: "ldap".
+	Name           string
+	Mapping        Mapping
+	CreateAccounts bool
+	Now            func() time.Time
+}
+
+// The ways a person the directory vouches for is still refused.
+var (
+	ErrNoAccount = errors.New("no account here, and accounts are not made for the directory's people")
+	ErrSuspended = errors.New("the account is suspended here")
+	ErrNotActive = errors.New("the account is not active here")
+	ErrNoEmail   = errors.New("the directory has no mail for this person")
+	// ErrImplausible is a sync that would suspend too many at once: done
+	// nothing, and said.
+	ErrImplausible = errors.New("the directory's answer is implausible; nobody was suspended")
+)
+
+func (k *Keeper) now() time.Time {
+	if k.Now != nil {
+		return k.Now()
+	}
+	return time.Now()
+}
+
+// SignIn is the account for a person the directory has just vouched for:
+// found by their directory id, else their mail, else made; given what their
+// groups map to; refused when it may not sign in.
+func (k *Keeper) SignIn(ctx context.Context, id Identity) (store.User, error) {
+	u, link, err := k.account(ctx, id)
+	if err != nil {
+		return store.User{}, err
+	}
+	// The directory has them enabled, or the bind would have failed: an
+	// account the sync suspended for being disabled there is theirs again.
+	if u.State == store.UserSuspended && link.SuspendedBySync {
+		if u, err = k.reinstate(ctx, u); err != nil {
+			return store.User{}, err
+		}
+	}
+	switch {
+	case u.State == store.UserSuspended:
+		return store.User{}, ErrSuspended
+	case !u.CanSignIn():
+		return store.User{}, fmt.Errorf("%w: %s", ErrNotActive, u.State)
+	}
+	if err := k.apply(ctx, &u, id, false); err != nil {
+		return store.User{}, err
+	}
+	return u, nil
+}
+
+// account finds or makes the account and links it to the directory.
+func (k *Keeper) account(ctx context.Context, id Identity) (store.User, store.DirectoryLink, error) {
+	link, err := k.St.DirectoryUser(ctx, k.Name, id.ID)
+	switch {
+	case err == nil:
+		u, err := k.St.UserByID(ctx, link.UserID)
+		return u, link, err
+	case !errors.Is(err, store.ErrNotFound):
+		return store.User{}, link, err
+	}
+	email := store.NormalizeEmail(id.Email)
+	if email == "" {
+		return store.User{}, link, ErrNoEmail
+	}
+	u, err := k.St.UserByEmail(ctx, email)
+	switch {
+	case errors.Is(err, store.ErrNotFound) && k.CreateAccounts:
+		name := id.Name
+		if name == "" {
+			name = email
+		}
+		u = store.User{ID: "usr-" + randomID(), Email: email, Name: name,
+			// No password works here: the directory's is checked.
+			PasswordHash: "!" + k.Name, State: store.UserActive, CreatedAt: k.now()}
+		if err := k.St.CreateUser(ctx, u); err != nil {
+			return store.User{}, link, err
+		}
+	case errors.Is(err, store.ErrNotFound):
+		return store.User{}, link, fmt.Errorf("%w: %s", ErrNoAccount, email)
+	case err != nil:
+		return store.User{}, link, err
+	}
+	if err := k.St.LinkDirectory(ctx, u.ID, k.Name, id.ID, k.now()); err != nil {
+		return store.User{}, link, err
+	}
+	return u, store.DirectoryLink{UserID: u.ID, Directory: k.Name, ExternalID: id.ID}, nil
+}
+
+// apply gives the account the role and places its groups map to. With
+// remove, a place this directory gave that the groups no longer do is taken
+// away; one given otherwise is never touched.
+func (k *Keeper) apply(ctx context.Context, u *store.User, id Identity, remove bool) error {
+	if len(k.Mapping.Roles) > 0 {
+		if role := k.Mapping.Role(id.Groups); role != u.StaffRole() {
+			if err := k.St.SetStaffRole(ctx, u.ID, role); err != nil {
+				return err
+			}
+			u.IsAdmin, u.Role = role == store.RoleAdmin, role
+			if role == store.RoleAdmin {
+				u.Role = ""
+			}
+		}
+	}
+	want := map[string]store.Scope{}
+	for _, where := range k.Mapping.Places(id.Groups) {
+		scope, sid, err := k.place(ctx, where)
+		if err != nil {
+			continue // a mapping to a place the tree lacks: said by Sync
+		}
+		want[string(scope)+"/"+sid] = scope
+		if err := k.St.AddMembership(ctx, u.ID, scope, sid, store.RoleMember, k.Name, k.now()); err != nil {
+			return err
+		}
+	}
+	if !remove {
+		return nil
+	}
+	have, err := k.St.MembershipsOf(ctx, u.ID)
+	if err != nil {
+		return err
+	}
+	for _, m := range have {
+		if m.AddedBy != k.Name {
+			continue
+		}
+		if _, ok := want[string(m.Scope)+"/"+m.ScopeID]; ok {
+			continue
+		}
+		if _, err := k.St.RemoveMembership(ctx, u.ID, m.Scope, m.ScopeID, k.now()); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (k *Keeper) reinstate(ctx context.Context, u store.User) (store.User, error) {
+	if err := k.St.SetUserState(ctx, u.ID, store.UserActive); err != nil {
+		return u, err
+	}
+	if err := k.St.SetSyncSuspended(ctx, u.ID, false, k.now()); err != nil {
+		return u, err
+	}
+	u.State = store.UserActive
+	return u, nil
+}
+
+// SyncReport is what a sync did.
+type SyncReport struct {
+	Seen, Updated, Suspended, Reinstated int
+	// Unmapped are mappings to places the tree does not have.
+	Unmapped []string
+}
+
+// Sync brings every account the directory keeps in step with what it says
+// now: people disabled or gone there are suspended here (their sessions
+// ended; their keys refuse, as a suspended owner's do), those enabled again
+// that the sync had suspended are reinstated, and everyone's role and places
+// follow their groups. People the directory has that never signed in here
+// are left until they do.
+func (k *Keeper) Sync(ctx context.Context, people []Identity) (SyncReport, error) {
+	var rep SyncReport
+	rep.Unmapped = k.unmapped(ctx)
+	byID := make(map[string]Identity, len(people))
+	for _, p := range people {
+		byID[p.ID] = p
+	}
+	links, err := k.St.DirectoryLinks(ctx, k.Name)
+	if err != nil {
+		return rep, err
+	}
+	// A directory that answers with nobody, or with half the people missing,
+	// is far likelier a wrong base, a filter or a bind account's lost rights
+	// than half the company leaving at once. Nothing is suspended for it.
+	gone := 0
+	for _, l := range links {
+		if p, there := byID[l.ExternalID]; !there || p.Disabled {
+			gone++
+		}
+	}
+	if len(links) > 0 && (len(people) == 0 || (gone >= 3 && gone*2 > len(links))) {
+		return rep, fmt.Errorf("%w: %d of the %d accounts it keeps would be suspended", ErrImplausible, gone, len(links))
+	}
+	for _, l := range links {
+		rep.Seen++
+		u, err := k.St.UserByID(ctx, l.UserID)
+		if err != nil {
+			continue
+		}
+		p, there := byID[l.ExternalID]
+		switch {
+		case !there || p.Disabled:
+			if u.State == store.UserActive {
+				if err := k.St.SetUserState(ctx, u.ID, store.UserSuspended); err != nil {
+					return rep, err
+				}
+				if err := k.St.DeleteUserSessions(ctx, u.ID); err != nil {
+					return rep, err
+				}
+				if err := k.St.SetSyncSuspended(ctx, u.ID, true, k.now()); err != nil {
+					return rep, err
+				}
+				rep.Suspended++
+			}
+		default:
+			if u.State == store.UserSuspended && l.SuspendedBySync {
+				if u, err = k.reinstate(ctx, u); err != nil {
+					return rep, err
+				}
+				rep.Reinstated++
+			}
+			if u.State != store.UserActive {
+				continue
+			}
+			before := u.StaffRole()
+			if err := k.apply(ctx, &u, p, true); err != nil {
+				return rep, err
+			}
+			if u.StaffRole() != before {
+				rep.Updated++
+			}
+		}
+	}
+	return rep, nil
+}
+
+// unmapped are the mapping's places the tree does not have.
+func (k *Keeper) unmapped(ctx context.Context) []string {
+	var out []string
+	for _, where := range k.Mapping.Memberships {
+		if _, _, err := k.place(ctx, where); err != nil && !slices.Contains(out, where) {
+			out = append(out, where)
+		}
+	}
+	slices.Sort(out)
+	return out
+}
+
+// place finds org:NAME, team:ORG/TEAM, project:ORG/TEAM/PROJECT, as
+// auth.oidc's mapping does.
+func (k *Keeper) place(ctx context.Context, where string) (store.Scope, string, error) {
+	kind, path, _ := strings.Cut(where, ":")
+	norm := func(s string) string {
+		parts := strings.Split(s, "/")
+		for i := range parts {
+			parts[i] = strings.TrimSpace(parts[i])
+		}
+		return strings.Join(parts, "/")
+	}
+	same := func(a string) bool { return strings.EqualFold(norm(a), norm(path)) }
+	switch kind {
+	case "org":
+		orgs, err := k.St.AllOrgs(ctx)
+		for _, o := range orgs {
+			if same(o.Name) {
+				return store.ScopeOrg, o.ID, nil
+			}
+		}
+		return "", "", errors.Join(err, errors.New("no such organization"))
+	case "team":
+		teams, err := k.St.AllTeams(ctx)
+		for _, t := range teams {
+			if same(t.OrgName + "/" + t.Name) {
+				return store.ScopeTeam, t.ID, nil
+			}
+		}
+		return "", "", errors.Join(err, errors.New("no such team"))
+	default:
+		projects, err := k.St.AllProjects(ctx)
+		for _, p := range projects {
+			if same(p.Path) {
+				return store.ScopeProject, p.ID, nil
+			}
+		}
+		return "", "", errors.Join(err, errors.New("no such project"))
+	}
+}
+
+func randomID() string {
+	var b [8]byte
+	_, _ = rand.Read(b[:])
+	return hex.EncodeToString(b[:])
+}
@@ -0,0 +1,142 @@
+package directory
+
+import (
+	"errors"
+	"path/filepath"
+	"slices"
+	"testing"
+	"time"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/store"
+)
+
+func newKeeper(t *testing.T) (*Keeper, *store.DB, string) {
+	t.Helper()
+	st, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "s.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	org, _ := st.CreateOrg(t.Context(), "Acme")
+	team, _ := st.CreateTeam(t.Context(), org, "ml")
+	k := &Keeper{St: st, Name: "ldap", CreateAccounts: true, Mapping: Mapping{
+		Roles:       map[string][]string{"admin": {"llmgw-admins"}, "viewer": {"CN=Staff,OU=Groups,DC=corp,DC=example"}},
+		Memberships: map[string]string{"ml-team": "team:Acme/ml", "ghosts": "team:Acme/nowhere"},
+	}}
+	return k, st, team
+}
+
+var ada = Identity{ID: "guid-ada", DN: "CN=Ada,OU=Staff,DC=corp,DC=example", Email: "Ada@Corp.example", Name: "Ada L",
+	Groups: []string{"ml-team", "CN=ml-team,OU=Groups,DC=corp,DC=example", "Staff", "CN=Staff,OU=Groups,DC=corp,DC=example"}}
+
+func TestAPersonTheDirectoryVouchesForIsMadeAnAccountWithWhatTheirGroupsGive(t *testing.T) {
+	k, st, team := newKeeper(t)
+	u, err := k.SignIn(t.Context(), ada)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if u.Email != "ada@corp.example" || u.Name != "Ada L" || u.PasswordHash != "!ldap" || u.StaffRole() != "viewer" {
+		t.Errorf("account %+v role %q", u, u.StaffRole())
+	}
+	ms, _ := st.MembershipsOf(t.Context(), u.ID)
+	if len(ms) != 1 || ms[0].ScopeID != team || ms[0].AddedBy != "ldap" {
+		t.Errorf("memberships %+v", ms)
+	}
+	// Their mail changes there: still the same account, by its directory id.
+	moved := ada
+	moved.Email = "ada.lovelace@corp.example"
+	again, err := k.SignIn(t.Context(), moved)
+	if err != nil || again.ID != u.ID {
+		t.Errorf("a new mail made a new account: %v %+v", err, again)
+	}
+	// The higher role of two wins.
+	boss := ada
+	boss.Groups = append(slices.Clone(ada.Groups), "llmgw-admins")
+	if u, _ := k.SignIn(t.Context(), boss); u.StaffRole() != "admin" {
+		t.Errorf("role %q", u.StaffRole())
+	}
+}
+
+func TestWithoutAccountsMadeOnlyThoseThatExistSignIn(t *testing.T) {
+	k, _, _ := newKeeper(t)
+	k.CreateAccounts = false
+	if _, err := k.SignIn(t.Context(), ada); !errors.Is(err, ErrNoAccount) {
+		t.Errorf("err %v", err)
+	}
+}
+
+func TestTheSyncSuspendsWhomTheDirectoryDisabledAndReinstatesThemAfter(t *testing.T) {
+	k, st, _ := newKeeper(t)
+	ctx := t.Context()
+	people := []Identity{ada}
+	for _, n := range []string{"b", "c", "d"} {
+		people = append(people, Identity{ID: "guid-" + n, Email: n + "@corp.example"})
+	}
+	ids := map[string]string{}
+	for _, p := range people {
+		u, err := k.SignIn(ctx, p)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ids[p.ID] = u.ID
+	}
+	if err := st.CreateSession(ctx, ids["guid-ada"], "tok", "csrf", time.Hour); err != nil {
+		t.Fatal(err)
+	}
+	// An administrator suspends c here, by hand.
+	_ = st.SetUserState(ctx, ids["guid-c"], store.UserSuspended)
+
+	// Ada is disabled there, and has left ml-team.
+	off := ada
+	off.Disabled = true
+	rep, err := k.Sync(ctx, []Identity{off, people[1], people[2], people[3]})
+	if err != nil {
+		t.Fatal(err)
+	}
+	u, _ := st.UserByID(ctx, ids["guid-ada"])
+	if u.State != store.UserSuspended || rep.Suspended != 1 {
+		t.Errorf("ada %s, report %+v", u.State, rep)
+	}
+	if _, _, err := st.SessionByToken(ctx, "tok"); err == nil {
+		t.Error("a suspended account's session still works")
+	}
+	if !slices.Contains(rep.Unmapped, "team:Acme/nowhere") {
+		t.Errorf("an unmapped place was not said: %+v", rep)
+	}
+
+	// Enabled again, and out of ml-team: reinstated, and its place taken
+	// away. c, suspended by hand, stays so.
+	back := ada
+	back.Groups = []string{"Staff", "CN=Staff,OU=Groups,DC=corp,DC=example"}
+	rep, err = k.Sync(ctx, []Identity{back, people[1], people[2], people[3]})
+	if err != nil {
+		t.Fatal(err)
+	}
+	u, _ = st.UserByID(ctx, ids["guid-ada"])
+	ms, _ := st.MembershipsOf(ctx, u.ID)
+	if u.State != store.UserActive || rep.Reinstated != 1 || len(ms) != 0 {
+		t.Errorf("ada %s, memberships %+v, report %+v", u.State, ms, rep)
+	}
+	if c, _ := st.UserByID(ctx, ids["guid-c"]); c.State != store.UserSuspended {
+		t.Errorf("an account suspended by hand was reinstated: %s", c.State)
+	}
+}
+
+func TestASyncThatWouldSuspendMostIsRefused(t *testing.T) {
+	k, st, _ := newKeeper(t)
+	ctx := t.Context()
+	for _, n := range []string{"a", "b", "c", "d"} {
+		if _, err := k.SignIn(ctx, Identity{ID: "guid-" + n, Email: n + "@corp.example"}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, people := range [][]Identity{nil, {{ID: "guid-a", Email: "a@corp.example"}}} {
+		if _, err := k.Sync(ctx, people); !errors.Is(err, ErrImplausible) {
+			t.Errorf("%d people: %v", len(people), err)
+		}
+	}
+	users, _ := st.Users(ctx, store.UserSuspended)
+	if len(users) != 0 {
+		t.Errorf("suspended %d", len(users))
+	}
+}
@@ -0,0 +1,286 @@
+package directory
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/go-ldap/ldap/v3"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/config"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/secrets"
+)
+
+// LDAP is a directory reached over LDAP, written for Active Directory: its
+// attribute names, its disabled flag, and its matching rule for nested
+// groups (LDAP_MATCHING_RULE_IN_CHAIN).
+type LDAP struct {
+	cfg  config.LDAP
+	tls  *tls.Config
+	dial func(url string) (ldapConn, error)
+}
+
+// ldapConn is the part of a connection used here, so tests need no server.
+type ldapConn interface {
+	Bind(user, password string) error
+	Search(*ldap.SearchRequest) (*ldap.SearchResult, error)
+	SearchWithPaging(*ldap.SearchRequest, uint32) (*ldap.SearchResult, error)
+	Close() error
+}
+
+// inChain is AD's matching rule that follows nested group membership.
+const inChain = "1.2.840.113556.1.4.1941"
+
+// uacDisabled is userAccountControl's ACCOUNTDISABLE bit.
+const uacDisabled = 0x2
+
+var personAttrs = []string{"objectGUID", "sAMAccountName", "userPrincipalName", "mail", "displayName", "userAccountControl"}
+
+// ErrBadCredentials is a person the directory does not know, or a password
+// it does not take: said alike, so a form cannot tell which.
+var ErrBadCredentials = errors.New("the directory does not take that name and password")
+
+// NewLDAP prepares a directory from its configuration.
+func NewLDAP(cfg config.LDAP) (*LDAP, error) {
+	tc := &tls.Config{MinVersion: tls.VersionTLS12}
+	if cfg.CAFile != "" {
+		pem, err := os.ReadFile(cfg.CAFile)
+		if err != nil {
+			return nil, fmt.Errorf("auth.ldap.ca_file: %w", err)
+		}
+		pool := x509.NewCertPool()
+		if !pool.AppendCertsFromPEM(pem) {
+			return nil, fmt.Errorf("auth.ldap.ca_file %s holds no certificate", cfg.CAFile)
+		}
+		tc.RootCAs = pool
+	}
+	d := &LDAP{cfg: cfg, tls: tc}
+	d.dial = d.dialURL
+	return d, nil
+}
+
+func (d *LDAP) dialURL(u string) (ldapConn, error) {
+	c, err := ldap.DialURL(u, ldap.DialWithTLSConfig(d.tls))
+	if err != nil {
+		return nil, err
+	}
+	c.SetTimeout(d.cfg.RoundTrip())
+	if strings.HasPrefix(u, "ldap://") {
+		// Validate refuses ldap:// without start_tls: nothing is sent first.
+		if err := c.StartTLS(d.tls); err != nil {
+			c.Close()
+			return nil, fmt.Errorf("StartTLS: %w", err)
+		}
+	}
+	return c, nil
+}
+
+// service is a connection bound as the account that finds people, to the
+// first server that answers.
+func (d *LDAP) service(ctx context.Context) (ldapConn, error) {
+	pw, err := secrets.Read(ctx, d.cfg.BindPasswordFile)
+	if err != nil {
+		return nil, fmt.Errorf("auth.ldap.bind_password_file: %w", err)
+	}
+	var errs []error
+	for _, u := range d.cfg.URLs {
+		c, err := d.dial(u)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("%s: %w", u, err))
+			continue
+		}
+		if err := c.Bind(d.cfg.BindDN, strings.TrimSpace(string(pw))); err != nil {
+			c.Close()
+			// A server that refuses the service account refuses it
+			// everywhere: not tried on the next.
+			return nil, fmt.Errorf("binding as %s on %s: %w", d.cfg.BindDN, u, err)
+		}
+		return c, nil
+	}
+	return nil, fmt.Errorf("no directory server answered: %w", errors.Join(errs...))
+}
+
+// Authenticate checks a person's name and password against the directory
+// and says who they are there, groups and all.
+func (d *LDAP) Authenticate(ctx context.Context, login, password string) (Identity, error) {
+	login = strings.TrimSpace(login)
+	// An empty password is an unauthenticated bind, which succeeds: never
+	// one for a person.
+	if login == "" || password == "" {
+		return Identity{}, ErrBadCredentials
+	}
+	// DOMAIN\user, as Windows writes it.
+	if i := strings.LastIndexByte(login, '\\'); i >= 0 {
+		login = login[i+1:]
+	}
+	c, err := d.service(ctx)
+	if err != nil {
+		return Identity{}, err
+	}
+	defer c.Close()
+	q := ldap.EscapeFilter(login)
+	filter := "(&" + d.people(false) + "(|(sAMAccountName=" + q + ")(userPrincipalName=" + q + ")(mail=" + q + ")))"
+	res, err := c.Search(ldap.NewSearchRequest(d.cfg.BaseDN, ldap.ScopeWholeSubtree, ldap.NeverDerefAliases,
+		2, 0, false, filter, personAttrs, nil))
+	if err != nil {
+		return Identity{}, fmt.Errorf("finding %s: %w", login, err)
+	}
+	if len(res.Entries) != 1 {
+		// None, or two people one name matches: neither is let in.
+		return Identity{}, ErrBadCredentials
+	}
+	id := identity(res.Entries[0])
+	if err := c.Bind(id.DN, password); err != nil {
+		var le *ldap.Error
+		if errors.As(err, &le) && le.ResultCode == ldap.LDAPResultInvalidCredentials {
+			return Identity{}, ErrBadCredentials
+		}
+		return Identity{}, fmt.Errorf("checking %s's password: %w", login, err)
+	}
+	// Back to the service account to read groups, which a person may not.
+	pw, err := secrets.Read(ctx, d.cfg.BindPasswordFile)
+	if err != nil {
+		return Identity{}, err
+	}
+	if err := c.Bind(d.cfg.BindDN, strings.TrimSpace(string(pw))); err != nil {
+		return Identity{}, err
+	}
+	if id.Groups, err = d.groupsOf(c, id.DN); err != nil {
+		return Identity{}, err
+	}
+	return id, nil
+}
+
+// groupsOf are a person's groups, nested ones included, by CN and DN.
+func (d *LDAP) groupsOf(c ldapConn, dn string) ([]string, error) {
+	filter := "(&(objectClass=group)(member:" + inChain + ":=" + ldap.EscapeFilter(dn) + "))"
+	res, err := c.SearchWithPaging(ldap.NewSearchRequest(d.groupBase(), ldap.ScopeWholeSubtree, ldap.NeverDerefAliases,
+		0, 0, false, filter, []string{"cn"}, nil), 500)
+	if err != nil {
+		return nil, fmt.Errorf("reading the groups of %s: %w", dn, err)
+	}
+	var out []string
+	for _, e := range res.Entries {
+		out = append(out, e.GetAttributeValue("cn"), e.DN)
+	}
+	return out, nil
+}
+
+// People are everyone the directory has under the base, enabled or not,
+// each with the mapped groups they are in: what a sync compares against.
+func (d *LDAP) People(ctx context.Context, m Mapping) ([]Identity, error) {
+	c, err := d.service(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer c.Close()
+	res, err := c.SearchWithPaging(ldap.NewSearchRequest(d.cfg.BaseDN, ldap.ScopeWholeSubtree, ldap.NeverDerefAliases,
+		0, 0, false, d.people(true), personAttrs, nil), 500)
+	if err != nil {
+		return nil, fmt.Errorf("listing people: %w", err)
+	}
+	people := make([]Identity, 0, len(res.Entries))
+	at := map[string]int{}
+	for _, e := range res.Entries {
+		id := identity(e)
+		at[id.ID] = len(people)
+		people = append(people, id)
+	}
+	// Only the groups the mapping names matter: a query each, for its
+	// members nested ones included, rather than one per person.
+	for _, g := range m.Groups() {
+		dns, err := d.groupDNs(c, g)
+		if err != nil {
+			return nil, err
+		}
+		for _, gdn := range dns {
+			filter := "(&" + d.people(true) + "(memberOf:" + inChain + ":=" + ldap.EscapeFilter(gdn) + "))"
+			r, err := c.SearchWithPaging(ldap.NewSearchRequest(d.cfg.BaseDN, ldap.ScopeWholeSubtree,
+				ldap.NeverDerefAliases, 0, 0, false, filter, []string{"objectGUID"}, nil), 500)
+			if err != nil {
+				return nil, fmt.Errorf("reading the members of %s: %w", gdn, err)
+			}
+			for _, e := range r.Entries {
+				if i, ok := at[guid(e.GetRawAttributeValue("objectGUID"))]; ok {
+					people[i].Groups = append(people[i].Groups, g, gdn)
+				}
+			}
+		}
+	}
+	return people, nil
+}
+
+// groupDNs are the groups a mapping's name means: a DN as it is, a CN
+// looked up.
+func (d *LDAP) groupDNs(c ldapConn, g string) ([]string, error) {
+	if strings.Contains(g, "=") {
+		return []string{g}, nil
+	}
+	res, err := c.Search(ldap.NewSearchRequest(d.groupBase(), ldap.ScopeWholeSubtree, ldap.NeverDerefAliases,
+		0, 0, false, "(&(objectClass=group)(cn="+ldap.EscapeFilter(g)+"))", []string{"cn"}, nil))
+	if err != nil {
+		return nil, fmt.Errorf("finding the group %s: %w", g, err)
+	}
+	var out []string
+	for _, e := range res.Entries {
+		out = append(out, e.DN)
+	}
+	return out, nil
+}
+
+// people is the filter for person accounts under the user filter; enabled
+// ones only, unless all.
+func (d *LDAP) people(all bool) string {
+	f := "(objectCategory=person)(objectClass=user)"
+	if !all {
+		f += "(!(userAccountControl:1.2.840.113556.1.4.803:=" + strconv.Itoa(uacDisabled) + "))"
+	}
+	return "(&" + f + d.cfg.UserFilter + ")"
+}
+
+// groupBase is where groups are searched: GroupBaseDN, else the domain root
+// of BaseDN (its DC= parts).
+func (d *LDAP) groupBase() string {
+	if d.cfg.GroupBaseDN != "" {
+		return d.cfg.GroupBaseDN
+	}
+	var dc []string
+	for _, rdn := range strings.Split(d.cfg.BaseDN, ",") {
+		if strings.HasPrefix(strings.ToUpper(strings.TrimSpace(rdn)), "DC=") {
+			dc = append(dc, strings.TrimSpace(rdn))
+		}
+	}
+	if len(dc) == 0 {
+		return d.cfg.BaseDN
+	}
+	return strings.Join(dc, ",")
+}
+
+func identity(e *ldap.Entry) Identity {
+	email := e.GetAttributeValue("mail")
+	if email == "" {
+		email = e.GetAttributeValue("userPrincipalName")
+	}
+	uac, _ := strconv.Atoi(e.GetAttributeValue("userAccountControl"))
+	return Identity{
+		ID: guid(e.GetRawAttributeValue("objectGUID")), DN: e.DN,
+		Email: email, Name: e.GetAttributeValue("displayName"),
+		Disabled: uac&uacDisabled != 0,
+	}
+}
+
+// guid is an objectGUID as Windows writes it: its first three parts
+// little-endian. Another directory's id is kept as hex.
+func guid(b []byte) string {
+	if len(b) != 16 {
+		return fmt.Sprintf("%x", b)
+	}
+	return fmt.Sprintf("%08x-%04x-%04x-%x-%x", binary.LittleEndian.Uint32(b[0:4]),
+		binary.LittleEndian.Uint16(b[4:6]), binary.LittleEndian.Uint16(b[6:8]), b[8:10], b[10:16])
+}
@@ -0,0 +1,130 @@
+package directory
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/go-ldap/ldap/v3"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/config"
+)
+
+// fakeConn is a directory with one person in it.
+type fakeConn struct {
+	binds    []string
+	filters  []string
+	password string // the person's
+	people   int    // how many the person search finds
+}
+
+func (f *fakeConn) Bind(user, password string) error {
+	f.binds = append(f.binds, user)
+	if strings.HasPrefix(user, "CN=Ada") && password != f.password {
+		return &ldap.Error{ResultCode: ldap.LDAPResultInvalidCredentials}
+	}
+	return nil
+}
+
+func (f *fakeConn) Search(r *ldap.SearchRequest) (*ldap.SearchResult, error) {
+	f.filters = append(f.filters, r.Filter)
+	var out []*ldap.Entry
+	for i := range f.people {
+		e := ldap.NewEntry("CN=Ada,OU=Staff,DC=corp,DC=example", map[string][]string{
+			"mail": {"ada@corp.example"}, "displayName": {"Ada"}, "userAccountControl": {"512"},
+		})
+		e.Attributes = append(e.Attributes, &ldap.EntryAttribute{Name: "objectGUID", ByteValues: [][]byte{guidBytes(byte(i))}})
+		out = append(out, e)
+	}
+	return &ldap.SearchResult{Entries: out}, nil
+}
+
+func (f *fakeConn) SearchWithPaging(r *ldap.SearchRequest, _ uint32) (*ldap.SearchResult, error) {
+	f.filters = append(f.filters, r.Filter)
+	return &ldap.SearchResult{Entries: []*ldap.Entry{
+		ldap.NewEntry("CN=ml-team,OU=Groups,DC=corp,DC=example", map[string][]string{"cn": {"ml-team"}}),
+	}}, nil
+}
+
+func (f *fakeConn) Close() error { return nil }
+
+func guidBytes(last byte) []byte {
+	return []byte{0x78, 0x56, 0x34, 0x12, 0x34, 0x12, 0x78, 0x56, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56, last}
+}
+
+func fakeLDAP(t *testing.T, c *fakeConn) *LDAP {
+	t.Helper()
+	pw := filepath.Join(t.TempDir(), "bind")
+	_ = os.WriteFile(pw, []byte("svc-secret\n"), 0o600)
+	d, err := NewLDAP(config.LDAP{URLs: []string{"ldaps://dc1"}, BindDN: "CN=llmgw,OU=Svc,DC=corp,DC=example",
+		BindPasswordFile: pw, BaseDN: "OU=Staff,DC=corp,DC=example", UserFilter: "(memberOf=CN=llm,DC=corp,DC=example)"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	d.dial = func(string) (ldapConn, error) { return c, nil }
+	return d
+}
+
+func TestAPersonIsCheckedByBindingAsThemAndTheirGroupsReadNested(t *testing.T) {
+	c := &fakeConn{password: "ad-secret", people: 1}
+	d := fakeLDAP(t, c)
+	id, err := d.Authenticate(t.Context(), `CORP\ada*)(x=`, "ad-secret")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if id.Email != "ada@corp.example" || id.ID != "12345678-1234-5678-9abc-def012345600" ||
+		!slicesHas(id.Groups, "ml-team") || !slicesHas(id.Groups, "CN=ml-team,OU=Groups,DC=corp,DC=example") {
+		t.Errorf("identity %+v", id)
+	}
+	// The name is escaped into the filter, the domain part dropped; the
+	// user filter is ANDed in; disabled accounts are not found; groups are
+	// read with the in-chain rule.
+	find, groups := c.filters[0], c.filters[1]
+	if !strings.Contains(find, `(sAMAccountName=ada\2a\29\28x=)`) || !strings.Contains(find, "(memberOf=CN=llm,DC=corp,DC=example)") ||
+		!strings.Contains(find, "1.2.840.113556.1.4.803:=2") || !strings.Contains(groups, inChain) {
+		t.Errorf("filters %q", c.filters)
+	}
+	// Service account, then the person, then the service account again.
+	if len(c.binds) != 3 || c.binds[1] != "CN=Ada,OU=Staff,DC=corp,DC=example" {
+		t.Errorf("binds %v", c.binds)
+	}
+}
+
+func TestWrongPasswordsEmptyOnesAndAmbiguousNamesAreRefusedAlike(t *testing.T) {
+	for _, tc := range []struct {
+		people   int
+		password string
+	}{{1, "wrong"}, {1, ""}, {0, "ad-secret"}, {2, "ad-secret"}} {
+		d := fakeLDAP(t, &fakeConn{password: "ad-secret", people: tc.people})
+		if _, err := d.Authenticate(t.Context(), "ada", tc.password); !errors.Is(err, ErrBadCredentials) {
+			t.Errorf("%d found, password %q: %v", tc.people, tc.password, err)
+		}
+	}
+}
+
+func TestPlaintextLDAPIsRefusedWithoutStartTLS(t *testing.T) {
+	base := config.LDAP{BindDN: "CN=x", BindPasswordFile: "/f", BaseDN: "DC=corp"}
+	for _, c := range []struct {
+		urls  []string
+		start bool
+		ok    bool
+	}{{[]string{"ldaps://dc1"}, false, true}, {[]string{"ldap://dc1"}, false, false},
+		{[]string{"ldap://dc1"}, true, true}, {[]string{"http://dc1"}, true, false}} {
+		l := base
+		l.URLs, l.StartTLS = c.urls, c.start
+		if err := l.Validate(); (err == nil) != c.ok {
+			t.Errorf("%v start_tls=%v: %v", c.urls, c.start, err)
+		}
+	}
+}
+
+func slicesHas(xs []string, x string) bool {
+	for _, v := range xs {
+		if v == x {
+			return true
+		}
+	}
+	return false
+}
@@ -33,6 +33,7 @@ var Reference = []Block{
 		{Key: "default_tpm", Type: "int", Doc: "", Nested: ""},
 		{Key: "signup_open", Type: "bool", Doc: "SignupOpen serves the signup form. Accounts it creates are pending until\nan operator approves them, so this is not a way in — but turning it off\nmeans accounts are made with `llmgw users create` instead.", Nested: ""},
 		{Key: "oidc", Type: "OIDC", Doc: "OIDC is sign-in through an identity provider.", Nested: "config.OIDC"},
+		{Key: "ldap", Type: "LDAP", Doc: "LDAP is sign-in against a directory, Active Directory above all, and\nthe accounts kept in step with it.", Nested: "config.LDAP"},
 		{Key: "scim", Type: "SCIM", Doc: "SCIM is account provisioning by the identity provider.", Nested: "config.SCIM"},
 		{Key: "max_key_ttl", Type: "time.Duration", Doc: "MaxKeyTTL is how long any API key may live; a key asked for with no\nexpiry is given this. Organizations, teams and projects can set\nshorter ones (llmgw keys ttl). Zero is no limit.", Nested: ""},
 		{Key: "personal", Type: "Personal", Doc: "Personal is what a person may do on their own, outside any project: make\npersonal keys and use the chat page personally, within these limits.", Nested: "config.Personal"},
@@ -91,7 +92,7 @@ var Reference = []Block{
 		{Key: "timezone", Type: "string", Doc: "Timezone is where models' scaling schedules are read, an IANA name\nlike Europe/Istanbul; empty is the control plane's own.", Nested: ""},
 		{Key: "eval_dir", Type: "string", Doc: "EvalDir is where quality suites are read from by name, for `llmgw ctl\neval MODEL --suite NAME`, a model's eval gate and the console. The\nsuites the binary carries (arithmetic, json-format) are found when it\nhas none of the name; a suite here of the same name replaces one.", Nested: ""},
 		{Key: "enabled", Type: "bool", Doc: "Enabled runs the control plane even when configuration declares no\nmodels.\n\nWithout it, a deployment whose catalog lives entirely in the database\ncannot start: control plane mode is inferred from the config file, so an\nempty models block means \"router only\", the process refuses to start for\nwant of anything to serve, and the models it would have loaded are never\nread. That is a cluster that cannot be managed at runtime because it is\nmanaged at runtime. AgentListen cannot carry this signal — it has a\ndefault, so every deployment would become a control plane.", Nested: ""},
-		{Key: "lease_ttl", Type: "time.Duration", Doc: "LeaseTTL is how long this control plane's claim to be the one placing\nwork stands without being renewed.\n\nOnly meaningful with a shared store, where a second control plane can\nsee the claim. Long enough to survive a slow query or a brief network\nstall, short enough that a standby takes over before anyone has finished\nreading the alert. Zero takes the default.", Nested: ""},
+		{Key: "lease_ttl", Type: "time.Duration", Doc: "LeaseTTL is how long this control plane's claim to be the one placing\nwork stands without being renewed.\n\nOnly meaningful with a shared store, where a second control plane can\nsee the claim. Long enough to survive a slow query or a brief network\nstall, short enough that a standby takes over before anyone has finished\nreading the alert. Zero takes the default, 10s.", Nested: ""},
 	}},
 	{Package: "catalog", Name: "CustomNode", Title: "CustomNode", Doc: "", Fields: []Field{
 		{Key: "repo", Type: "string", Doc: "Repo is the repository, https only.", Nested: ""},
@@ -125,11 +126,16 @@ var Reference = []Block{
 		{Key: "url", Type: "string", Doc: "URL is the provider's base address, without /v1: https://api.openai.com.", Nested: ""},
 		{Key: "model", Type: "string", Doc: "Model is what the provider calls it; requests are rewritten to it.", Nested: ""},
 		{Key: "api_key_file", Type: "string", Doc: "APIKeyFile holds the provider's key, on the control plane. A file\nrather than the key itself, so the key is in neither the catalog, the\nstore nor the audit log; empty for a provider that asks for none.", Nested: ""},
+		{Key: "api_key_files", Type: "[]ExternalKey", Doc: "APIKeyFiles are several keys for the provider, in place of\nAPIKeyFile: one endpoint each (external:MODEL#1, #2…), so a key that\nanswers 429 or 401 is passed over while its breaker is open and the\nrequest goes to another. A provider's limits are per key.", Nested: ""},
 		{Key: "peer", Type: "string", Doc: "Peer names the federated llmgw cluster this model is offered by, for\na model that federation added (`llmgw ctl federation add`) rather\nthan one written by hand. Such a model is named PEER/MODEL, comes and\ngoes with the peer's own list, and is sent only while the peer is up.", Nested: ""},
 		{Key: "api", Type: "string", Doc: "API is what the provider speaks: OpenAI's, unless this says comfyui —\na ComfyUI server, asked for pictures at /v1/images/generations and\nsent the workflow below with the request's prompt in it. Model is then\nthe checkpoint file the workflow loads, as ComfyUI lists it.", Nested: ""},
 		{Key: "workflow", Type: "string", Doc: "Workflow is the ComfyUI workflow, in its API format: a built-in's name\n(flux-schnell, the default, or flux-dev) or a JSON file on the control\nplane.", Nested: ""},
 		{Key: "output", Type: "string", Doc: "Output is what it makes: pictures, or meshes (see ComfyUI.Output).", Nested: ""},
 	}},
+	{Package: "catalog", Name: "ExternalKey", Title: "ExternalKey", Doc: "", Fields: []Field{
+		{Key: "file", Type: "string", Doc: "File holds the key, on the control plane, as APIKeyFile does.", Nested: ""},
+		{Key: "weight", Type: "float64", Doc: "Weight is its share of the requests against the others'; zero is 1.", Nested: ""},
+	}},
 	{Package: "config", Name: "Facility", Title: "Facility", Doc: "", Fields: []Field{
 		{Key: "budgets", Type: "[]FacilityBudget", Doc: "Budgets are the domains with a power cap.", Nested: ""},
 		{Key: "margin", Type: "float64", Doc: "Margin is the share of every cap kept free, 0.1 for ten percent. Zero\nkeeps none, for caps already given derated.", Nested: ""},
@@ -183,6 +189,22 @@ var Reference = []Block{
 		{Key: "min_blocks", Type: "int", Doc: "MinBlocks is the fewest leading blocks a replica must hold to be\npreferred for them; fewer is coincidence — a chat template's opening\ntokens — rather than a prefix worth following. Zero takes 4, which is\n64 tokens at vLLM's usual block size of 16.", Nested: ""},
 		{Key: "max_blocks", Type: "int", Doc: "MaxBlocks bounds how many of a prompt's blocks are hashed and looked\nup. Beyond it a longer match still helps, but the difference no longer\ndecides anything. Zero takes 4096.", Nested: ""},
 	}},
+	{Package: "config", Name: "LDAP", Title: "LDAP", Doc: "", Fields: []Field{
+		{Key: "urls", Type: "[]string", Doc: "URLs are the directory's servers, tried in turn: ldaps:// (636), or\nldap:// (389) with StartTLS.", Nested: ""},
+		{Key: "start_tls", Type: "bool", Doc: "StartTLS upgrades an ldap:// connection before anything is sent. A\npassword never crosses a connection without TLS: ldap:// without it\nis refused.", Nested: ""},
+		{Key: "ca_file", Type: "string", Doc: "CAFile is the authority the servers' certificates are checked against,\nwhen it is not the system's: an AD Certificate Services root.", Nested: ""},
+		{Key: "bind_dn", Type: "string", Doc: "BindDN and the file holding its password: a service account that may\nread users and groups. Nothing is written to the directory.", Nested: ""},
+		{Key: "bind_password_file", Type: "string", Doc: "", Nested: ""},
+		{Key: "base_dn", Type: "string", Doc: "BaseDN is where people are searched for, subtree included.", Nested: ""},
+		{Key: "group_base_dn", Type: "string", Doc: "GroupBaseDN is where their groups are; empty is BaseDN's domain root.", Nested: ""},
+		{Key: "user_filter", Type: "string", Doc: "UserFilter narrows who may sign in, ANDed with the login match: a\ngroup (memberOf=...) or an OU's people only. Empty is every enabled\nuser object.", Nested: ""},
+		{Key: "label", Type: "string", Doc: "Label is what the form says to sign in with: \"Sign in with your\n<label> account\". Empty is \"Active Directory\".", Nested: ""},
+		{Key: "create_accounts", Type: "bool", Doc: "CreateAccounts makes an account, active, for a person the directory\nvouches for and the gateway does not know. Off, only existing accounts\nsign in this way.", Nested: ""},
+		{Key: "roles", Type: "map[string][]string", Doc: "Roles maps a staff role (viewer, operator, billing, admin) to the\ngroups that give it, by name (CN) or whole DN. Set at every sign-in\nand sync: someone taken out of the group loses the role.", Nested: ""},
+		{Key: "memberships", Type: "map[string]string", Doc: "Memberships maps a group, by CN or DN, to a place in the tree —\norg:NAME, team:ORG/TEAM, project:ORG/TEAM/PROJECT — joined at sign-in\nand kept by the sync, which also takes away a place whose group the\nperson has left.", Nested: ""},
+		{Key: "sync_interval", Type: "time.Duration", Doc: "SyncInterval is how often the leader reads the directory. Zero is\n15m; negative turns the sync off, leaving only sign-in.", Nested: ""},
+		{Key: "timeout", Type: "time.Duration", Doc: "Timeout bounds each round trip to a server. Zero is 10s.", Nested: ""},
+	}},
 	{Package: "config", Name: "Landing", Title: "Landing", Doc: "", Fields: []Field{
 		{Key: "contact", Type: "string", Doc: "Contact is where someone without a key should go — an address, a URL, a\nchannel name. Rendered as a link when it is one, as text otherwise.", Nested: ""},
 		{Key: "notice", Type: "string", Doc: "Notice is an optional line of your own, for whatever the reader needs to\nknow that this page cannot guess.", Nested: ""},
@@ -33,6 +33,7 @@ var Sources = []string{
 	"internal/guard/policy.go",
 	"internal/guard/judge.go",
 	"internal/config/oidc.go",
+	"internal/config/ldap.go",
 	"internal/config/firewall.go",
 	"internal/config/serving.go",
 	"internal/config/presets.go",
@@ -198,25 +198,70 @@ func (j *judge) ask(ctx context.Context, jp *JudgePolicy, user, answer string) (
 	}
 	j.mu.Unlock()

-	err := errNoJudge
-	for _, model := range models {
-		var res judgment
-		res, err = j.askOne(ctx, jp, model, user, answer)
-		if err == nil {
-			j.remember(key, res)
-			return res, nil
+	start := time.Now()
+	for {
+		err := errNoJudge
+		var failed []string
+		var errs []error
+		// fast is every judge failing at once, as one does that is not
+		// there yet: the moment a control plane takes the lead, before
+		// the agents have told it where the judges are.
+		fast := true
+		for _, model := range models {
+			var res judgment
+			t := time.Now()
+			res, err = j.askOne(ctx, jp, model, user, answer)
+			if err == nil {
+				// The judges before it that failed are said to have, as
+				// one on a GPU that is down while the CPUs' answers.
+				j.report(failed, errs)
+				j.remember(key, res)
+				return res, nil
+			}
+			failed, errs = append(failed, model), append(errs, err)
+			if time.Since(t) > judgeFastFailure || errors.Is(err, errJudgeFormat) {
+				fast = false
+			}
+			if ctx.Err() != nil {
+				// The request itself is gone: no judge after this one is wanted.
+				break
+			}
 		}
-		if j.failed != nil {
-			j.failed(model, err)
-		}
-		if ctx.Err() != nil {
-			// The request itself is gone: no judge after this one is wanted.
-			break
+		// Asked again while the budget lasts, rather than refused at once:
+		// with fail: closed, every request in those seconds was a 503.
+		if fast && ctx.Err() == nil && time.Since(start)+judgeRetryEvery < jp.budget() {
+			select {
+			case <-ctx.Done():
+			case <-time.After(judgeRetryEvery):
+			}
+			if ctx.Err() == nil {
+				continue
+			}
 		}
+		// Told once, for the last round: not twenty times in five seconds.
+		j.report(failed, errs)
+		return judgment{}, err
 	}
-	return judgment{}, err
 }

+// report tells of each judge that gave no verdict.
+func (j *judge) report(models []string, errs []error) {
+	if j.failed == nil {
+		return
+	}
+	for i, model := range models {
+		j.failed(model, errs[i])
+	}
+}
+
+// A judge that fails within judgeFastFailure is one that is not there, and
+// is asked again every judgeRetryEvery while the policy's budget lasts. One
+// that is slow, or answers what cannot be read, is not.
+const (
+	judgeFastFailure = time.Second
+	judgeRetryEvery  = 250 * time.Millisecond
+)
+
 // askOne asks one judge, waiting the policy's budget for it.
 func (j *judge) askOne(ctx context.Context, jp *JudgePolicy, model, user, answer string) (res judgment, err error) {
 	start := time.Now()
@@ -222,7 +222,7 @@ func TestJudgesAreAskedInTurn(t *testing.T) {
 	var asked []string
 	gpuDown := errors.New("no replica of gpu-judge is serving")
 	g := gate(t, lib(map[string]Policy{"p": {Fail: "closed",
-		Judge: &JudgePolicy{Models: []string{"gpu-judge", "cpu-judge"}, Input: "block"}}}, "p"))
+		Judge: &JudgePolicy{Models: []string{"gpu-judge", "cpu-judge"}, Input: "block", LatencyBudget: 600 * time.Millisecond}}}, "p"))
 	g.SetJudge(func(_ context.Context, model, _ string, body []byte) ([]byte, error) {
 		asked = append(asked, model)
 		if model == "gpu-judge" {
@@ -317,3 +317,44 @@ func TestALongTextIsJudgedByItsEnds(t *testing.T) {
 		t.Errorf("a short text was cut: %q", got)
 	}
 }
+
+// The moment a control plane takes the lead it knows no judge yet; one that
+// arrives within the budget judges the request, instead of fail: closed
+// refusing it at once. One that is slow is not asked again.
+func TestAJudgeNotThereYetIsWaitedForWithinTheBudget(t *testing.T) {
+	ctx := context.Background()
+	g := gate(t, lib(map[string]Policy{"p": {Fail: "closed",
+		Judge: &JudgePolicy{Model: "guard", Input: "block", LatencyBudget: 2 * time.Second}}}, "p"))
+	arrives := time.Now().Add(400 * time.Millisecond)
+	calls := 0
+	g.SetJudge(func(context.Context, string, string, []byte) ([]byte, error) {
+		calls++
+		if time.Now().Before(arrives) {
+			return nil, errors.New("no replica of guard is serving")
+		}
+		return json.Marshal(map[string]any{"choices": []any{map[string]any{"text": "Safety: Safe\nCategories: None"}}})
+	}, func(string) (string, []string, bool) { return "qwen3guard", nil, true })
+	var alarmed []string
+	g.SetJudgeAlarm(func(model string, _ error) { alarmed = append(alarmed, model) })
+	if v, err := g.Input(ctx, Subject{}, chat("user", "hello")); err != nil || v.Action != Allow {
+		t.Fatalf("refused while the judge was on its way: %+v %v", v, err)
+	}
+	if calls < 2 || len(alarmed) != 0 {
+		t.Errorf("asked %d times, alarms %v", calls, alarmed)
+	}
+
+	// Slow, and failing: given up on after one try, not the whole budget again.
+	calls = 0
+	g.SetJudge(func(ctx context.Context, _, _ string, _ []byte) ([]byte, error) {
+		calls++
+		time.Sleep(1100 * time.Millisecond)
+		return nil, errors.New("overloaded")
+	}, func(string) (string, []string, bool) { return "qwen3guard", nil, true })
+	start := time.Now()
+	if _, err := g.Input(ctx, Subject{}, chat("user", "hello again")); err == nil {
+		t.Error("fail closed served what no judge read")
+	}
+	if calls != 1 || time.Since(start) > 1800*time.Millisecond {
+		t.Errorf("a slow judge was asked %d times over %s", calls, time.Since(start))
+	}
+}
@@ -43,10 +43,15 @@ const (
 	// CanaryRolledBack is a model's canary taken out because it served
 	// worse than the model it was a candidate to replace.
 	CanaryRolledBack = "canary_rolled_back"
+	// ExternalKeyRefused is an outside provider answering 401 to one of a
+	// model's keys: revoked, expired or mistyped. Requests go to its other
+	// keys meanwhile, where it has any.
+	ExternalKeyRefused = "external_key_refused"
 )

 // Kinds are every event there is.
-var Kinds = []string{ModelParked, NodeLost, BudgetSpent, UpdateAvailable, JudgeUnavailable, CanaryRolledBack}
+var Kinds = []string{ModelParked, NodeLost, BudgetSpent, UpdateAvailable, JudgeUnavailable, CanaryRolledBack,
+	ExternalKeyRefused}

 // Event is one thing that happened.
 type Event struct {
@@ -169,9 +169,9 @@ etcd3:
 %[14]s
 bootstrap:
  dcs:
-    ttl: 30
-    loop_wait: 10
-    retry_timeout: 10
+    ttl: %[15]d
+    loop_wait: %[16]d
+    retry_timeout: %[17]d
    maximum_lag_on_failover: 1048576
    postgresql:
      use_pg_rewind: true
@@ -211,7 +211,7 @@ postgresql:
  parameters:
    unix_socket_directories: /var/run/postgresql
 `, Scope, m.Name, m.IP, PatroniPort, strings.Join(hosts, ","), version, s.Superuser, s.Replicator, hbaLines,
-		s.RestAPI, RestUser, sslLines, restTLSLines(tls), etcdTLSLines(tls))
+		s.RestAPI, RestUser, sslLines, restTLSLines(tls), etcdTLSLines(tls), leaderTTL, loopWait, retryTimeout)
 	b.WriteString(`
 tags:
  nofailover: false
@@ -559,3 +559,42 @@ func TestAMemberLeftPendingARestartIsRestartedOnTheNextRun(t *testing.T) {
 		t.Errorf("restarted %v; only the member pending", restarted)
 	}
 }
+
+func TestALostPrimaryIsReplacedWithinTwentySeconds(t *testing.T) {
+	cfg := map[string]any{"ttl": 30, "loop_wait": 10, "retry_timeout": 10}
+	patches := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodGet:
+			_ = json.NewEncoder(w).Encode(cfg)
+		case http.MethodPatch:
+			patches++
+			_ = json.NewDecoder(r.Body).Decode(&cfg)
+		}
+	}))
+	defer srv.Close()
+	u, _ := url.Parse(srv.URL)
+	old := restPort
+	restPort, _ = strconv.Atoi(u.Port())
+	defer func() { restPort = old }()
+	ca, err := tlsconf.NewCA("test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := Setup{DB: []Node{{Member{"m", "127.0.0.1"}, &machine{}}}, CA: ca}
+	for range 2 {
+		if err := s.timings(context.Background(), Secrets{RestAPI: "pw"}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if patches != 1 || cfg["ttl"].(float64) != 20 || cfg["loop_wait"].(float64) != 5 || cfg["retry_timeout"].(float64) != 5 {
+		t.Errorf("patched %d times to %v", patches, cfg)
+	}
+	// Patroni's own rule, or it refuses them.
+	if loopWait+2*retryTimeout > leaderTTL {
+		t.Error("loop_wait + 2*retry_timeout is more than ttl")
+	}
+	if c := Patroni(pg01, []Member{pg01, ctl02}, []Member{pg01, ctl02, ctl}, nil, "16", Secrets{}, false); !strings.Contains(c, "ttl: 20\n    loop_wait: 5\n    retry_timeout: 5\n") {
+		t.Errorf("a new cluster bootstraps with others:\n%s", c)
+	}
+}
@@ -131,6 +131,9 @@ func (s *Setup) Run(ctx context.Context) (string, error) {
 	if err := s.memory(ctx, sec); err != nil {
 		return "", fmt.Errorf("memory: %w", err)
 	}
+	if err := s.timings(ctx, sec); err != nil {
+		return "", fmt.Errorf("failover: %w", err)
+	}
 	if err := s.database(ctx); err != nil {
 		return "", fmt.Errorf("database: %w", err)
 	}
@@ -0,0 +1,60 @@
+package pgha
+
+import (
+	"context"
+	"fmt"
+)
+
+// How soon a lost primary is replaced. Patroni's own defaults — the leader
+// key lives 30 seconds, checked every 10 — had the control planes wait the
+// better part of a minute for a store after a database machine lost its
+// power. Patroni asks that loop_wait + 2*retry_timeout <= ttl, so a lost
+// primary is replaced within ttl and a slow etcd round is not mistaken for
+// one.
+const (
+	leaderTTL    = 20
+	loopWait     = 5
+	retryTimeout = 5
+)
+
+// timingSettings are the shared configuration's keys for them.
+func timingSettings() map[string]any {
+	return map[string]any{"ttl": leaderTTL, "loop_wait": loopWait, "retry_timeout": retryTimeout}
+}
+
+// timings puts them in the cluster's shared configuration, through
+// Patroni's API: a cluster set up with the old ones gets these in place.
+func (s *Setup) timings(ctx context.Context, sec Secrets) error {
+	// As with TLS, changed in place by the machine with the authority: init
+	// has it, and a new cluster has these from its bootstrap already.
+	if s.CA == nil {
+		return nil
+	}
+	var lastErr error
+	for _, d := range s.DB {
+		cfg, err := getConfig(ctx, d.IP)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		want := timingSettings()
+		same := true
+		for k, v := range want {
+			// JSON numbers come back as float64.
+			if n, ok := cfg[k].(float64); !ok || int(n) != v.(int) {
+				same = false
+			}
+		}
+		if same {
+			s.emit("failover", false, "a lost primary is replaced within %d seconds", leaderTTL)
+			return nil
+		}
+		if err := patchConfig(ctx, d.IP, sec.RestAPI, want); err != nil {
+			return fmt.Errorf("Patroni on %s: %w", d.IP, err)
+		}
+		s.emit("failover", true, "a lost primary is replaced within %d seconds (ttl %d, loop_wait %d, retry_timeout %d)",
+			leaderTTL, leaderTTL, loopWait, retryTimeout)
+		return nil
+	}
+	return fmt.Errorf("no member's Patroni answered: %w", lastErr)
+}
@@ -131,7 +131,18 @@ const defaultActivationWait = 45 * time.Second
 // SetNotifier tells the accountant where to say a budget is spent. Nothing
 // without a store, where there are no budgets.
 func (r *Router) SetNotifier(n *notify.Notifier) {
+	r.notifier = n
 	if r.acct != nil {
 		r.acct.SetNotifier(n)
 	}
 }
+
+// keyRefused says that an outside provider answered 401 to one of a model's
+// keys, by its endpoint, which numbers it: never the key.
+func (r *Router) keyRefused(model, endpointID string) {
+	r.log.Warn("an outside provider refused a key", "model", model, "endpoint", endpointID)
+	r.notifier.Notify(notify.ExternalKeyRefused, endpointID,
+		"the provider of "+model+" answered 401 to the key of "+endpointID+
+			": revoked, expired or mistyped; replace its file on the control plane",
+		map[string]any{"model": model, "endpoint": endpointID})
+}
@@ -0,0 +1,112 @@
+package router
+
+import (
+	"cmp"
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"gitea.mynodes.xyz/ilker/llmgw/internal/account"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/config"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/directory"
+	storepkg "gitea.mynodes.xyz/ilker/llmgw/internal/store"
+)
+
+// Sign-in against a directory (auth.ldap), and the accounts kept in step
+// with it by the leader.
+
+// ldapDirectory is auth.ldap as the gateway uses it.
+type ldapDirectory struct {
+	dir    *directory.LDAP
+	keeper *directory.Keeper
+	every  time.Duration
+	label  string
+	log    *slog.Logger
+}
+
+func newLDAPDirectory(cfg config.LDAP, st *storepkg.DB, log *slog.Logger) (*ldapDirectory, error) {
+	dir, err := directory.NewLDAP(cfg)
+	if err != nil {
+		return nil, err
+	}
+	return &ldapDirectory{
+		dir: dir,
+		keeper: &directory.Keeper{St: st, Name: "ldap", CreateAccounts: cfg.CreateAccounts,
+			Mapping: directory.Mapping{Roles: cfg.Roles, Memberships: cfg.Memberships}},
+		every: cfg.Interval(),
+		label: cmp.Or(cfg.Label, "Active Directory"),
+		log:   log,
+	}, nil
+}
+
+// SignIn is account.Directory: the person's name and password checked by
+// the directory, then their account made or kept in step.
+func (d *ldapDirectory) SignIn(ctx context.Context, login, password string) (storepkg.User, error) {
+	id, err := d.dir.Authenticate(ctx, login, password)
+	switch {
+	case errors.Is(err, directory.ErrBadCredentials):
+		return storepkg.User{}, account.ErrBadCredentials
+	case err != nil:
+		d.log.Warn("the directory could not be asked about a sign-in", "err", err)
+		return storepkg.User{}, fmt.Errorf("the directory could not be asked: %w", err)
+	}
+	u, err := d.keeper.SignIn(ctx, id)
+	switch {
+	case errors.Is(err, directory.ErrSuspended):
+		return storepkg.User{}, account.ErrSuspended
+	case errors.Is(err, directory.ErrNoAccount), errors.Is(err, directory.ErrNoEmail):
+		// Said to the log, not the form: the form says what a wrong
+		// password says.
+		d.log.Info("the directory vouched for a person who has no account here", "dn", id.DN, "err", err)
+		return storepkg.User{}, account.ErrBadCredentials
+	case errors.Is(err, directory.ErrNotActive):
+		return storepkg.User{}, account.ErrNotApproved
+	case err != nil:
+		return storepkg.User{}, err
+	}
+	return u, nil
+}
+
+// sync reads the directory every interval, on the leader, and brings the
+// accounts it keeps in step.
+func (d *ldapDirectory) sync(ctx context.Context, leader func() bool) {
+	if d.every <= 0 {
+		return
+	}
+	t := time.NewTicker(d.every)
+	defer t.Stop()
+	for {
+		if leader() {
+			d.syncOnce(ctx)
+		}
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.C:
+		}
+	}
+}
+
+func (d *ldapDirectory) syncOnce(ctx context.Context) {
+	ctx, cancel := context.WithTimeout(ctx, 5*time.Minute)
+	defer cancel()
+	people, err := d.dir.People(ctx, d.keeper.Mapping)
+	if err != nil {
+		d.log.Warn("could not read the directory; accounts left as they are", "err", err)
+		return
+	}
+	rep, err := d.keeper.Sync(ctx, people)
+	if err != nil {
+		d.log.Error("the directory sync stopped", "err", err, "people", len(people))
+		return
+	}
+	for _, where := range rep.Unmapped {
+		d.log.Warn("auth.ldap.memberships maps a group to a place the tree does not have", "place", where)
+	}
+	if rep.Suspended+rep.Reinstated+rep.Updated > 0 {
+		d.log.Info("accounts kept in step with the directory", "people", len(people), "accounts", rep.Seen,
+			"suspended", rep.Suspended, "reinstated", rep.Reinstated, "roles_changed", rep.Updated)
+	}
+}
@@ -6,11 +6,15 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"sync/atomic"
 	"testing"

 	"gitea.mynodes.xyz/ilker/llmgw/internal/config"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/notify"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/notify/notifytest"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/router/breaker"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/router/endpoint"
 )

@@ -87,3 +91,68 @@ func TestAnExternalModelIsNotAModelWithProfiles(t *testing.T) {
 		}
 	}
 }
+
+// Two keys for one provider, one of them at its limit, or refused: every
+// request is answered by the other key, the failing one's breaker opens, and
+// a refused key is said, by its endpoint and never its value.
+func TestAKeyAtItsLimitOrRefusedIsPassedOverForAnother(t *testing.T) {
+	for _, status := range []int{http.StatusTooManyRequests, http.StatusUnauthorized} {
+		provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.Header.Get("Authorization") == "Bearer key-a" {
+				http.Error(w, "no", status)
+				return
+			}
+			w.Header().Set("Content-Type", "application/json")
+			fmt.Fprint(w, `{"model":"m","choices":[{"message":{"content":"ok"}}],"usage":{"prompt_tokens":1,"completion_tokens":1}}`)
+		}))
+		t.Cleanup(provider.Close)
+		cfg := baseConfig()
+		cfg.Models = []catalog.Model{{Name: "cloud", Source: "external",
+			External: &catalog.External{URL: provider.URL, Model: "m"}}}
+		rt := newTestRouter(t, cfg)
+		key := func(id, k string) endpoint.Info {
+			return endpoint.Info{ID: id, URL: provider.URL, Models: []string{"cloud"}, APIKey: k,
+				Engine: endpoint.EngineExternal, Pool: "external", Weight: 1, UpstreamModel: "m"}
+		}
+		rt.SetEndpoints(t.Context(), []endpoint.Info{key("external:cloud#1", "key-a"), key("external:cloud#2", "key-b")})
+		n, events := notifytest.Catch(t)
+		rt.SetNotifier(n)
+
+		// Until the failing key's breaker opens: how many requests the
+		// scheduler sends it before then is its own choice.
+		open := func() bool {
+			for _, s := range rt.reg.Snapshots("cloud") {
+				if s.ID == "external:cloud#1" && s.Breaker != breaker.Closed {
+					return true
+				}
+			}
+			return false
+		}
+		for i := 0; i < 100 && !open(); i++ {
+			if rec := post(t, rt.Handler(), map[string]any{"model": "cloud", "messages": []any{}}, nil); rec.Code != http.StatusOK {
+				t.Fatalf("key-a answering %d: request %d got %d: %s", status, i, rec.Code, rec.Body.String())
+			}
+		}
+		for _, s := range rt.reg.Snapshots("cloud") {
+			if s.ID == "external:cloud#1" && s.Breaker == breaker.Closed {
+				t.Errorf("%d: the failing key's breaker is still closed", status)
+			}
+			if s.ID == "external:cloud#2" && s.Breaker != breaker.Closed {
+				t.Errorf("%d: the good key's breaker opened", status)
+			}
+		}
+		var refused []notify.Event
+		for _, e := range events() {
+			if e.Kind == notify.ExternalKeyRefused {
+				refused = append(refused, e)
+			}
+		}
+		switch {
+		case status == http.StatusTooManyRequests && len(refused) != 0:
+			t.Errorf("a key at its limit was said to be refused: %+v", refused)
+		case status == http.StatusUnauthorized && (len(refused) != 1 || refused[0].Subject != "external:cloud#1" ||
+			strings.Contains(refused[0].Message, "key-a")):
+			t.Errorf("a refused key was said as %+v", refused)
+		}
+	}
+}
@@ -269,3 +269,53 @@ func TestSignInThroughAProviderNeedsNoAPIKey(t *testing.T) {
 		t.Errorf("%d %s", rec.Code, rec.Body.String())
 	}
 }
+
+// One replica of the judge hangs: the other, on another machine, is asked
+// at half the budget and answers within it, rather than the hung one taking
+// the whole budget and the request being refused. Two on one machine are
+// not both asked: they are slow together.
+func TestAJudgeThatHangsIsOvertakenByAnother(t *testing.T) {
+	for _, apart := range []bool{true, false} {
+		hung, quick := newFakeEngine(t, "judge"), newFakeEngine(t, "judge")
+		hung.hang.Store(true)
+		quickURL := quick.srv.URL
+		if apart {
+			// Another host name for the same server: another machine, to
+			// the router.
+			quickURL = strings.Replace(quickURL, "127.0.0.1", "localhost", 1)
+		}
+		cfg := baseConfig(config.Endpoint{ID: "hung", URL: hung.srv.URL, Models: []string{"judge"}},
+			config.Endpoint{ID: "quick", URL: quickURL, Models: []string{"judge"}})
+		judge := catModel("judge", nil)
+		judge.Role, judge.Guard = catalog.RoleGuard, &catalog.GuardModel{Format: "qwen3guard"}
+		cfg.Models = []catalog.Model{judge}
+		rt := newTestRouter(t, cfg)
+		deadline := time.Now().Add(3 * time.Second)
+		for len(rt.reg.Snapshots("judge")) < 2 && time.Now().Before(deadline) {
+			time.Sleep(20 * time.Millisecond)
+		}
+		if n := len(rt.reg.Snapshots("judge")); n != 2 {
+			t.Fatalf("%d replicas of the judge", n)
+		}
+		body := []byte(`{"model":"judge","messages":[{"role":"user","content":"x"}]}`)
+		for i := 0; i < 12 && hung.calls.Load() == 0; i++ {
+			before := quick.calls.Load()
+			ctx, cancel := context.WithTimeout(t.Context(), time.Second)
+			start := time.Now()
+			out, err := rt.Judge(ctx, "judge", "/v1/chat/completions", body)
+			cancel()
+			if hung.calls.Load() == 0 {
+				continue // the quick one was asked first
+			}
+			if apart && (err != nil || !strings.Contains(string(out), `"hi"`) || time.Since(start) > 900*time.Millisecond) {
+				t.Fatalf("apart: no verdict in time (%s): %v", time.Since(start), err)
+			}
+			if !apart && quick.calls.Load() != before {
+				t.Error("together: the other replica on the same machine was asked as well")
+			}
+		}
+		if hung.calls.Load() == 0 {
+			t.Fatal("the hung replica was never asked first")
+		}
+	}
+}
@@ -243,6 +243,9 @@ func (r *Router) Handler() http.Handler {
 			return web.ModelFacts{ContextLength: m.ContextLength, MaxOutput: m.MaxOutput, Tools: m.Capabilities.Tools}
 		})
 		pages.SetPersonalOff(r.personalOff)
+		if r.directory != nil {
+			pages.SetDirectory(r.directory.label)
+		}
 		pages.SetLlamaCppVersion(r.llamaVersion)
 		pages.SetPersonalDefaults(r.personalDefaults)
 		if r.store != nil {
@@ -474,6 +477,11 @@ type parsedRequest struct {
 	// internal is a request the gateway makes of itself — a judge's — which
 	// no guard filters.
 	internal bool
+	// avoid are endpoints this request is not sent to while another will do,
+	// and picked is told the endpoint it is sent to: a judge asked twice
+	// asks two replicas.
+	avoid  []string
+	picked func(endpointID string)
 	// cache is where its answer is kept, when its project reuses answers
 	// and this one may be.
 	cache cacheState
@@ -5,6 +5,9 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"net/url"
+	"sync"
+	"time"

 	"gitea.mynodes.xyz/ilker/llmgw/internal/guard"
 )
@@ -18,6 +21,70 @@ func (r *Router) Judge(ctx context.Context, model, path string, body []byte) ([]
 	if path != "/v1/chat/completions" && path != "/v1/completions" {
 		return nil, fmt.Errorf("a judge is asked at /v1/chat/completions or /v1/completions, not %s", path)
 	}
+	deadline, ok := ctx.Deadline()
+	canonical, _ := r.resolve(model)
+	if !ok || len(r.reg.Snapshots(canonical)) < 2 {
+		return r.judgeOnce(ctx, path, body, nil, nil)
+	}
+
+	// Asked of a second replica too when the first has not answered by half
+	// the budget, and the first answer taken. One replica that hung — busy,
+	// or on a machine that is going — took the whole budget, and the retry
+	// on the other found none left: the request was refused (fail: closed)
+	// though a judge stood idle. The first is not cut short, which on a slow
+	// machine would refuse what it was about to answer.
+	//
+	// Only of a replica on another machine. Two on one machine whose CPUs
+	// are taken are slow together, and asking both doubled the work there:
+	// measured, as many requests failed as before, more of them refused.
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	type answer struct {
+		out []byte
+		err error
+	}
+	answers := make(chan answer, 2)
+	var mu sync.Mutex
+	var first string
+	go func() {
+		out, err := r.judgeOnce(ctx, path, body, nil, func(id string) {
+			mu.Lock()
+			first = id
+			mu.Unlock()
+		})
+		answers <- answer{out, err}
+	}()
+	hedge := time.NewTimer(time.Until(deadline) / 2)
+	defer hedge.Stop()
+	asking := 1
+	var lastErr error
+	for asking > 0 {
+		select {
+		case a := <-answers:
+			asking--
+			if a.err == nil {
+				return a.out, nil
+			}
+			lastErr = a.err
+		case <-hedge.C:
+			mu.Lock()
+			avoid := []string{first}
+			mu.Unlock()
+			if !r.elsewhere(canonical, first) {
+				continue
+			}
+			asking++
+			go func() {
+				out, err := r.judgeOnce(ctx, path, body, avoid, nil)
+				answers <- answer{out, err}
+			}()
+		}
+	}
+	return nil, lastErr
+}
+
+// judgeOnce asks one judge request of the router, as it would a client's.
+func (r *Router) judgeOnce(ctx context.Context, path string, body []byte, avoid []string, picked func(string)) ([]byte, error) {
 	hreq, err := http.NewRequestWithContext(ctx, http.MethodPost, path, bytes.NewReader(body))
 	if err != nil {
 		return nil, err
@@ -30,13 +97,14 @@ func (r *Router) Judge(ctx context.Context, model, path string, body []byte) ([]
 	req.Stream = false
 	req.RequestID = requestID("")
 	req.Header = http.Header{"X-Request-Id": []string{req.RequestID}}
+	req.avoid, req.picked = avoid, picked
 	w := &bufferWriter{header: http.Header{}}
 	res := r.dispatch(ctx, w, req)
 	if res.err != nil {
 		return nil, res.err
 	}
 	if w.status != 0 && w.status != http.StatusOK {
-		return nil, fmt.Errorf("the judge %s answered %d", model, w.status)
+		return nil, fmt.Errorf("the judge %s answered %d", req.Model, w.status)
 	}
 	return w.buf.Bytes(), nil
 }
@@ -84,3 +152,33 @@ func (b *bufferWriter) Write(p []byte) (int, error) {
 	return b.buf.Write(p)
 }
 func (b *bufferWriter) Flush() {}
+
+// elsewhere is whether a model has a replica on another machine than this
+// endpoint's, by the host of its address.
+func (r *Router) elsewhere(model, endpointID string) bool {
+	snaps := r.reg.Snapshots(model)
+	host := ""
+	for _, e := range snaps {
+		if e.ID == endpointID {
+			host = hostOfURL(e.URL)
+		}
+	}
+	if host == "" {
+		return false
+	}
+	for _, e := range snaps {
+		if e.ID != endpointID && hostOfURL(e.URL) != host {
+			return true
+		}
+	}
+	return false
+}
+
+// hostOfURL is an address's host, without its port.
+func hostOfURL(raw string) string {
+	u, err := url.Parse(raw)
+	if err != nil {
+		return ""
+	}
+	return u.Hostname()
+}
@@ -34,6 +34,7 @@ import (
 	"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/control/reconciler"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/guard"
+	"gitea.mynodes.xyz/ilker/llmgw/internal/notify"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/router/admission"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/router/breaker"
 	"gitea.mynodes.xyz/ilker/llmgw/internal/router/endpoint"
@@ -116,6 +117,10 @@ type Router struct {
 	// federation is which cluster this is, to its peers; nil until said.
 	federation atomic.Pointer[federationID]
 	acct       *accounting.Accountant
+	// notifier says what the operator must act on; nil says nothing.
+	notifier *notify.Notifier
+	// directory is auth.ldap's: sign-in and the accounts kept in step.
+	directory *ldapDirectory
 	// guard judges requests and answers; nil judges nothing. guardLibrary
 	// is the policies it was built from, for the pages that show them.
 	guard        guard.Guard
@@ -392,6 +397,14 @@ func New(cfg config.Server, log *slog.Logger) (*Router, error) {
 		r.accounts = account.New(st, account.Config{
 			SignupOpen: cfg.Auth.SignupOpen,
 		}, log)
+		if cfg.Auth.LDAP.Enabled() {
+			d, err := newLDAPDirectory(cfg.Auth.LDAP, st, log)
+			if err != nil {
+				return nil, err
+			}
+			r.directory = d
+			r.accounts.SetDirectory(d)
+		}

 		r.acct = accounting.New(
 			accounting.NewPricing(prices, accounting.Price{
@@ -532,6 +545,9 @@ func (r *Router) Start(ctx context.Context) {
 	if r.threads != nil {
 		go r.pruneThreads(ctx)
 	}
+	if r.directory != nil {
+		go r.directory.sync(ctx, r.leading)
+	}
 	if r.store != nil && r.usageRetention > 0 {
 		go r.pruneUsage(ctx, r.usageRetention)
 	}
@@ -1022,6 +1038,13 @@ func (r *Router) dispatchOne(ctx context.Context, w http.ResponseWriter, req *pa
 		}
 		candidates = visited
 	}
+	if len(req.avoid) > 0 {
+		if rest := slices.DeleteFunc(slices.Clone(candidates), func(e endpoint.Snapshot) bool {
+			return slices.Contains(req.avoid, e.ID)
+		}); len(rest) > 0 {
+			candidates = rest
+		}
+	}
 	if len(candidates) == 0 {
 		// Nothing is serving it. That may be because nothing ever will, or
 		// because it loads when asked and nobody has asked yet — and the second
@@ -1106,6 +1129,9 @@ func (r *Router) dispatchOne(ctx context.Context, w http.ResponseWriter, req *pa
 			candidates = without(candidates, dec.Endpoint.ID)
 			continue
 		}
+		if req.picked != nil {
+			req.picked(dec.Endpoint.ID)
+		}

 		// The replica loads the adapter first if it does not hold it.
 		// Counted against its inflight while it does, so the requests
@@ -1183,6 +1209,12 @@ func (r *Router) dispatchOne(ctx context.Context, w http.ResponseWriter, req *pa
 			// restart. Not relayed; loaded again and tried again.
 			preq.RetryStatus = http.StatusNotFound
 		}
+		// One of an outside provider's several keys refused: the request
+		// is the provider's to answer with another of them, and the key's
+		// breaker counts it. With one key the 401 is the client's to see.
+		if dec.Endpoint.Engine == endpoint.EngineExternal && strings.Contains(dec.Endpoint.ID, "#") {
+			preq.RetryStatus = http.StatusUnauthorized
+		}
 		if dec.Endpoint.Peer != "" {
 			preq.Extra = r.peerHeaders(ctx, dec.Endpoint, req.Header)
 		}
@@ -1199,6 +1231,9 @@ func (r *Router) dispatchOne(ctx context.Context, w http.ResponseWriter, req *pa
 		} else {
 			out, perr = r.px.Do(uctx, w, preq)
 		}
+		if dec.Endpoint.Engine == endpoint.EngineExternal && out.Status == http.StatusUnauthorized {
+			r.keyRefused(model, dec.Endpoint.ID)
+		}
 		releaseAdapter()
 		uspan.SetAttributes(attribute.Int("http.response.status_code", out.Status))
 		endSpan(uspan, perr)
@@ -42,6 +42,8 @@ type fakeEngine struct {
 	last atomic.Value
 	// traceparent is the one the last completion came with.
 	traceparent atomic.Value
+	// hang, when set, has a completion wait until its request is given up.
+	hang atomic.Bool
 }

 func newFakeEngine(t *testing.T, model string) *fakeEngine {
@@ -63,6 +65,10 @@ func newFakeEngine(t *testing.T, model string) *fakeEngine {
 			http.Error(w, "unavailable", code)
 			return
 		}
+		if f.hang.Load() {
+			<-r.Context().Done()
+			return
+		}
 		w.Header().Set("Content-Type", "application/json")
 		fmt.Fprintf(w, `{"model":%q,"choices":[{"message":{"content":"hi"}}],"usage":{"prompt_tokens":4,"completion_tokens":2}}`, model)
 	})
@@ -27,6 +27,8 @@ var copyOrder = []string{
 	"memberships",
 	// After users, which it points at.
 	"user_excluded_licences",
+	// After users, which it points at.
+	"user_directory",
 	"preset_state",
 	"api_keys",
 	"key_claims",
@@ -0,0 +1,92 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"time"
+)
+
+// DirectoryLink is an account kept by an outside directory: which one, the
+// account's id there, and whether the directory's sync is what suspended it.
+type DirectoryLink struct {
+	UserID     string
+	Directory  string // "ldap"
+	ExternalID string // an AD objectGUID
+	// SuspendedBySync is an account suspended because the directory
+	// disabled or lost it, and so reinstated when the directory has it
+	// enabled again. One an administrator suspended is not.
+	SuspendedBySync bool
+	SyncedAt        time.Time
+}
+
+// DirectoryUser is the account a directory knows by that id.
+func (s *DB) DirectoryUser(ctx context.Context, directory, externalID string) (DirectoryLink, error) {
+	var l DirectoryLink
+	var suspended int
+	var synced int64
+	err := s.db.QueryRowContext(ctx,
+		`SELECT user_id, directory, external_id, suspended_by_sync, synced_at FROM user_directory
+		 WHERE directory = ? AND external_id = ?`, directory, externalID).
+		Scan(&l.UserID, &l.Directory, &l.ExternalID, &suspended, &synced)
+	if errors.Is(err, sql.ErrNoRows) {
+		return DirectoryLink{}, ErrNotFound
+	}
+	if err != nil {
+		return DirectoryLink{}, err
+	}
+	l.SuspendedBySync, l.SyncedAt = suspended != 0, directoryTime(synced)
+	return l, nil
+}
+
+// LinkDirectory records that a directory keeps an account, by its id there.
+func (s *DB) LinkDirectory(ctx context.Context, userID, directory, externalID string, at time.Time) error {
+	_, err := s.db.ExecContext(ctx,
+		`INSERT INTO user_directory (user_id, directory, external_id, synced_at) VALUES (?, ?, ?, ?)
+		 ON CONFLICT (user_id) DO UPDATE SET directory = excluded.directory, external_id = excluded.external_id,
+		   synced_at = excluded.synced_at`,
+		userID, directory, externalID, at.UnixMilli())
+	return err
+}
+
+// DirectoryLinks are every account a directory keeps.
+func (s *DB) DirectoryLinks(ctx context.Context, directory string) ([]DirectoryLink, error) {
+	rows, err := s.db.QueryContext(ctx,
+		`SELECT user_id, directory, external_id, suspended_by_sync, synced_at FROM user_directory WHERE directory = ?`,
+		directory)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = rows.Close() }()
+	var out []DirectoryLink
+	for rows.Next() {
+		var l DirectoryLink
+		var suspended int
+		var synced int64
+		if err := rows.Scan(&l.UserID, &l.Directory, &l.ExternalID, &suspended, &synced); err != nil {
+			return nil, err
+		}
+		l.SuspendedBySync, l.SyncedAt = suspended != 0, directoryTime(synced)
+		out = append(out, l)
+	}
+	return out, rows.Err()
+}
+
+// SetSyncSuspended says whether the directory's sync is what has an account
+// suspended, and when it last looked.
+func (s *DB) SetSyncSuspended(ctx context.Context, userID string, suspended bool, at time.Time) error {
+	v := 0
+	if suspended {
+		v = 1
+	}
+	_, err := s.db.ExecContext(ctx,
+		`UPDATE user_directory SET suspended_by_sync = ?, synced_at = ? WHERE user_id = ?`, v, at.UnixMilli(), userID)
+	return err
+}
+
+func directoryTime(ms int64) time.Time {
+	if ms == 0 {
+		return time.Time{}
+	}
+	return time.UnixMilli(ms)
+}
@@ -0,0 +1,14 @@
+-- Ported from the SQLite migration of the same number.
+-- Which directory keeps an account, and its id there: an Active Directory
+-- objectGUID, so a person whose mail changes there is still the same account
+-- here. suspended_by_sync is an account the directory sync suspended,
+-- because it was disabled or gone there; one an administrator suspended
+-- here is not, and is never reinstated by the sync.
+CREATE TABLE user_directory (
+  user_id           TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+  directory         TEXT NOT NULL,
+  external_id       TEXT NOT NULL,
+  suspended_by_sync INTEGER NOT NULL DEFAULT 0,
+  synced_at         BIGINT NOT NULL DEFAULT 0,
+  UNIQUE (directory, external_id)
+);
@@ -0,0 +1,13 @@
+-- Which directory keeps an account, and its id there: an Active Directory
+-- objectGUID, so a person whose mail changes there is still the same account
+-- here. suspended_by_sync is an account the directory sync suspended,
+-- because it was disabled or gone there; one an administrator suspended
+-- here is not, and is never reinstated by the sync.
+CREATE TABLE user_directory (
+  user_id           TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+  directory         TEXT NOT NULL,
+  external_id       TEXT NOT NULL,
+  suspended_by_sync INTEGER NOT NULL DEFAULT 0,
+  synced_at         INTEGER NOT NULL DEFAULT 0,
+  UNIQUE (directory, external_id)
+);
@@ -2,17 +2,46 @@ package store

 import (
 	"context"
-	"database/sql"
 	"fmt"
+	"net"
 	"time"

 	// The pure-Go PostgreSQL driver. Pure-Go is not a preference here: the
 	// whole binary is built with CGO_ENABLED=0 so that it runs on a node whose
 	// libc is older than the builder's, and a cgo driver would take that away
 	// from every deployment, including the ones still on SQLite.
-	_ "github.com/jackc/pgx/v5/stdlib"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/stdlib"
 )

+// How soon a store machine that is gone is given up on. A replicated store's
+// address names every member, and a new connection tries them in order: with
+// no timeout, one to a machine that had lost its power waited for the
+// kernel's own — half a minute and more — before the next member was asked,
+// and every request whose key was not cached waited with it.
+const (
+	// storeConnectTimeout is per member: the next is tried after it.
+	storeConnectTimeout = 3 * time.Second
+	// storeDeadAfter is how long a connection's sent data may go unanswered,
+	// or an idle one's probes, before it is closed: a connection to the
+	// primary that was lost fails, and the next opens to the new one.
+	storeDeadAfter = 10 * time.Second
+)
+
+// failFast gives a connection configuration those limits, where its address
+// gave none of its own.
+func failFast(cfg *pgx.ConnConfig) {
+	if cfg.ConnectTimeout == 0 {
+		cfg.ConnectTimeout = storeConnectTimeout
+	}
+	d := &net.Dialer{
+		KeepAliveConfig: net.KeepAliveConfig{Enable: true, Idle: 5 * time.Second, Interval: time.Second,
+			Count: int((storeDeadAfter - 5*time.Second) / time.Second)},
+		Control: userTimeout(storeDeadAfter),
+	}
+	cfg.DialFunc = d.DialContext
+}
+
 // OpenPostgres opens the store against PostgreSQL.
 //
 // The same queries run here as on SQLite; only the placeholders differ, and
@@ -29,12 +58,14 @@ func OpenPostgres(ctx context.Context, dsn string) (*DB, error) {
 	if dsn == "" {
 		return nil, fmt.Errorf("store: no PostgreSQL address configured")
 	}
-	db, err := sql.Open("pgx", dsn)
+	cfg, err := pgx.ParseConfig(dsn)
 	if err != nil {
 		// Deliberately not wrapped with the DSN: it holds a password, and an
 		// error string ends up in logs, tickets and screenshots.
 		return nil, fmt.Errorf("opening the PostgreSQL store: %w", err)
 	}
+	failFast(cfg)
+	db := stdlib.OpenDB(*cfg)

 	// Sized for a control plane rather than for a fleet of application
 	// servers. The request path barely touches the store — usage is batched,
@@ -0,0 +1,25 @@
+package store
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+func TestAStoreMachineThatIsGoneIsGivenUpOnInSeconds(t *testing.T) {
+	cfg, err := pgx.ParseConfig("postgres://u:p@10.0.0.158:5432,10.0.0.159:5432/llmgw?sslmode=disable&target_session_attrs=read-write")
+	if err != nil {
+		t.Fatal(err)
+	}
+	failFast(cfg)
+	if cfg.ConnectTimeout != storeConnectTimeout || cfg.DialFunc == nil {
+		t.Errorf("timeout %s, dialer set %v", cfg.ConnectTimeout, cfg.DialFunc != nil)
+	}
+	// One the address asks for is its own.
+	cfg, _ = pgx.ParseConfig("postgres://u:p@h:5432/llmgw?sslmode=disable&connect_timeout=12")
+	failFast(cfg)
+	if cfg.ConnectTimeout != 12*time.Second {
+		t.Errorf("the address's own timeout was replaced: %s", cfg.ConnectTimeout)
+	}
+}
@@ -179,10 +179,17 @@ func (s *DB) ApproveUser(ctx context.Context, id, projectID, by string, at time.
 // signup suspended while pending and then reinstated would become active
 // without anybody approving it.
 func (s *DB) SetUserState(ctx context.Context, id string, state UserState) error {
+	// An account nobody approved is approved, not set active: that is what
+	// records who let it in. One an identity provider, SCIM or a directory
+	// made — active from the start, its password kept there ("!oidc",
+	// "!scim", "!ldap"), with no approval to record — is set active again
+	// when its provider reinstates it; refusing that left such accounts
+	// suspended for good.
 	if state == UserActive {
 		var approved sql.NullInt64
-		if err := s.db.QueryRowContext(ctx, `SELECT approved_at FROM users WHERE id = ?`, id).
-			Scan(&approved); err == nil && !approved.Valid {
+		var hash string
+		if err := s.db.QueryRowContext(ctx, `SELECT approved_at, password_hash FROM users WHERE id = ?`, id).
+			Scan(&approved, &hash); err == nil && !approved.Valid && !strings.HasPrefix(hash, "!") {
 			return errors.New("this account was never approved; approve it instead")
 		}
 	}
@@ -0,0 +1,23 @@
+package store
+
+import (
+	"syscall"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+// userTimeout sets TCP_USER_TIMEOUT: data sent and not acknowledged for that
+// long closes the connection, where keepalive probes wait for it to go idle.
+func userTimeout(d time.Duration) func(network, address string, c syscall.RawConn) error {
+	return func(_, _ string, c syscall.RawConn) error {
+		var serr error
+		err := c.Control(func(fd uintptr) {
+			serr = unix.SetsockoptInt(int(fd), unix.IPPROTO_TCP, unix.TCP_USER_TIMEOUT, int(d.Milliseconds()))
+		})
+		if err != nil {
+			return err
+		}
+		return serr
+	}
+}
@@ -0,0 +1,13 @@
+//go:build !linux
+
+package store
+
+import (
+	"syscall"
+	"time"
+)
+
+// userTimeout is Linux's alone; elsewhere the keepalive probes do it, later.
+func userTimeout(time.Duration) func(network, address string, c syscall.RawConn) error {
+	return nil
+}
@@ -86,6 +86,9 @@ type AccountPages struct {
 	hasQuotas bool
 	// oidc is sign-in through an identity provider; nil when there is none.
 	oidc *oidcLogin
+	// directory is the label of the directory that checks passwords
+	// (auth.ldap); empty when there is none.
+	directory string
 	// audit records every change made through these pages; nil records none.
 	audit audit.Sink
 	// hasGuard is set when /admin/guard is registered, and guardLibrary
@@ -250,6 +253,10 @@ func (p *AccountPages) signup(w http.ResponseWriter, r *http.Request) {
 // --- sign in and out ---

 // ssoLabel is what the sign-in button names, or "" without one.
+// SetDirectory says passwords are also checked by a directory, under this
+// label, so the sign-in form takes a username as well as a mail.
+func (p *AccountPages) SetDirectory(label string) { p.directory = label }
+
 func (p *AccountPages) ssoLabel(l *Lang) string {
 	if p.oidc == nil {
 		return ""
@@ -265,13 +272,22 @@ type loginData struct {
 	Version string
 	// SSO is the identity provider's label, when sign-in through one is on.
 	SSO string
+	// Directory is the directory's label when passwords are checked by one
+	// (auth.ldap): the field then takes a username too, not only a mail.
+	Directory string
 	// CSRF is the form's token, matched by a cookie.
 	CSRF string
 }

+// loginPage is what every rendering of the sign-in form carries.
+func (p *AccountPages) loginPage(w http.ResponseWriter, r *http.Request, l *Lang, email string) loginData {
+	return loginData{SSO: p.ssoLabel(l), Directory: p.directory, Email: email, SignupOpen: p.accounts.SignupOpen(),
+		Forgot: p.resets != nil, Version: p.version, CSRF: setLoginToken(w, r)}
+}
+
 func (p *AccountPages) loginForm(w http.ResponseWriter, r *http.Request) {
 	noStore(w)
-	render(w, r, "login", loginData{SSO: p.ssoLabel(langOf(r)), SignupOpen: p.accounts.SignupOpen(), Forgot: p.resets != nil, Version: p.version, CSRF: setLoginToken(w, r)})
+	render(w, r, "login", p.loginPage(w, r, langOf(r), ""))
 }

 func (p *AccountPages) login(w http.ResponseWriter, r *http.Request) {
@@ -281,15 +297,16 @@ func (p *AccountPages) login(w http.ResponseWriter, r *http.Request) {
 	if !loginTokenOK(r) {
 		// Not this site's form: another one posting a visitor into an
 		// account of its choosing, or a form left open past its hour.
-		renderStatus(w, r, http.StatusBadRequest, "login", loginData{SSO: p.ssoLabel(l), Email: email, SignupOpen: p.accounts.SignupOpen(), Version: p.version,
-			Error: l.T("login.err.form_expired"), CSRF: setLoginToken(w, r)})
+		d := p.loginPage(w, r, l, email)
+		d.Error = l.T("login.err.form_expired")
+		renderStatus(w, r, http.StatusBadRequest, "login", d)
 		return
 	}

 	ctx := account.WithClient(r.Context(), clientAddr(r))
 	token, csrf, err := p.accounts.SignIn(ctx, email, r.FormValue("password"))
 	if err != nil {
-		d := loginData{SSO: p.ssoLabel(l), Email: email, SignupOpen: p.accounts.SignupOpen(), Forgot: p.resets != nil, Version: p.version, CSRF: setLoginToken(w, r)}
+		d := p.loginPage(w, r, l, email)
 		switch {
 		case errors.Is(err, account.ErrBadCredentials),
 			errors.Is(err, account.ErrNotApproved),
@@ -309,9 +326,9 @@ func (p *AccountPages) login(w http.ResponseWriter, r *http.Request) {
 	if p.oidc != nil && p.oidc.cfg.NoPasswords {
 		if _, u, err := p.accounts.Resolve(ctx, token); err != nil || !u.IsAdmin {
 			_ = p.accounts.SignOut(ctx, token)
-			renderStatus(w, r, http.StatusForbidden, "login", loginData{SSO: p.ssoLabel(l), Email: email,
-				SignupOpen: p.accounts.SignupOpen(), Version: p.version, CSRF: setLoginToken(w, r),
-				Error: l.T("login.err.passwords_off", p.ssoLabel(l))})
+			d := p.loginPage(w, r, l, email)
+			d.Error = l.T("login.err.passwords_off", p.ssoLabel(l))
+			renderStatus(w, r, http.StatusForbidden, "login", d)
 			return
 		}
 	}
@@ -19,6 +19,8 @@
  "login.title": "Sign in · llmgw",
  "login.heading": "Sign in",
  "login.email": "Email",
+  "login.username": "Username or email",
+  "login.with_directory": "Sign in with your %s account.",
  "login.password": "Password",
  "login.submit": "Sign in",
  "login.with_sso": "Sign in with %s",
@@ -19,6 +19,8 @@
  "login.title": "Giriş yap · llmgw",
  "login.heading": "Giriş yapın",
  "login.email": "E-posta",
+  "login.username": "Kullanıcı adı veya e-posta",
+  "login.with_directory": "%s hesabınızla giriş yapın.",
  "login.password": "Parola",
  "login.submit": "Giriş yap",
  "login.with_sso": "%s ile giriş yap",
@@ -148,8 +148,9 @@ func (p *AccountPages) oidcStart(w http.ResponseWriter, r *http.Request) {
 	pr, err := o.providerFor(r.Context())
 	if err != nil {
 		p.log.Warn("the identity provider did not answer", "issuer", o.cfg.Issuer, "err", err)
-		renderStatus(w, r, http.StatusBadGateway, "login", loginData{SignupOpen: p.accounts.SignupOpen(), Version: p.version,
-			CSRF: setLoginToken(w, r), SSO: o.cfg.Label, Error: langOf(r).T("sso.err.no_answer")})
+		d := p.loginPage(w, r, langOf(r), "")
+		d.Error = langOf(r).T("sso.err.no_answer")
+		renderStatus(w, r, http.StatusBadGateway, "login", d)
 		return
 	}
 	state, nonce, verifier := randomToken(), randomToken(), oauth2.GenerateVerifier()
@@ -172,8 +173,9 @@ func (p *AccountPages) oidcCallback(w http.ResponseWriter, r *http.Request) {
 		if errors.As(err, &ae) {
 			msg = ae.in(l)
 		}
-		renderStatus(w, r, http.StatusForbidden, "login", loginData{SignupOpen: p.accounts.SignupOpen(),
-			Version: p.version, CSRF: setLoginToken(w, r), SSO: o.cfg.Label, Error: msg})
+		d := p.loginPage(w, r, l, "")
+		d.Error = msg
+		renderStatus(w, r, http.StatusForbidden, "login", d)
 	}
 	c, err := r.Cookie(oidcCookie)
 	if err != nil {
@@ -297,7 +299,17 @@ func (p *AccountPages) oidcUser(ctx context.Context, claims map[string]any) (sto
 		return store.User{}, accountError{"sso.err.state", []any{email, string(u.State)}}
 	}

-	groups := claimStrings(claims[or(o.cfg.GroupsClaim, "groups")])
+	claim := or(o.cfg.GroupsClaim, "groups")
+	if groupsOverflowed(claims, claim) {
+		// Read as no groups, this would take an administrator's role away
+		// at their next sign-in: kept as they are instead, and said.
+		p.log.Error("the identity provider left this person's groups out of the token, as Entra ID does past 200 groups; "+
+			"their role and memberships are left as they were. In the app registration's token configuration, "+
+			"emit only the groups assigned to the application, or provision through SCIM",
+			"email", email, "claim", claim)
+		return u, nil
+	}
+	groups := claimStrings(claims[claim])
 	if len(o.cfg.Roles) > 0 {
 		role := ""
 		for _, r := range []string{store.RoleAdmin, store.RoleOperator, store.RoleBilling, store.RoleViewer} {
@@ -333,6 +345,22 @@ func (p *AccountPages) oidcUser(ctx context.Context, claims map[string]any) (sto
 	return u, nil
 }

+// groupsOverflowed is a token whose groups claim was too long to send:
+// Entra ID then names a source to fetch it from (_claim_names), or, in a
+// token from the implicit flow, says only hasgroups.
+func groupsOverflowed(claims map[string]any, claim string) bool {
+	if _, ok := claims[claim]; ok {
+		return false
+	}
+	if names, ok := claims["_claim_names"].(map[string]any); ok {
+		if _, ok := names[claim]; ok {
+			return true
+		}
+	}
+	has, _ := claims["hasgroups"].(bool)
+	return has
+}
+
 // oidcPlace finds org:NAME, team:ORG/TEAM, project:ORG/TEAM/PROJECT.
 func (p *AccountPages) oidcPlace(ctx context.Context, where string) (store.Scope, string, error) {
 	kind, path, _ := strings.Cut(where, ":")
@@ -165,6 +165,15 @@ func TestSigningInThroughAProvider(t *testing.T) {
 		t.Error("no session cookie")
 	}

+	// Past 200 groups Entra ID sends none, only where to fetch them: the
+	// role stays rather than being taken away as if she had no groups.
+	idp.claims = map[string]any{"email": "ann@example.com", "email_verified": true,
+		"_claim_names":   map[string]any{"groups": "src1"},
+		"_claim_sources": map[string]any{"src1": map[string]any{"endpoint": "https://graph.windows.net/t/users/u/getMemberObjects"}}}
+	if rec := signIn(t, mux, idp, false); rec.Code != http.StatusSeeOther || st.roles[u.ID] != "operator" {
+		t.Errorf("an overflowed groups claim: %d, role %q", rec.Code, st.roles[u.ID])
+	}
+
 	// Refused: a state that is not this browser's, an unverified address,
 	// and nobody the gateway knows when it does not make accounts.
 	if rec := signIn(t, mux, idp, true); rec.Code != http.StatusForbidden {
@@ -14,6 +14,7 @@ llm.example.com {
 		max_size 32MB
 	}

+	# One control plane. With more than one, see the end of this file.
 	reverse_proxy 127.0.0.1:8080 {
 		# Tokens are written the moment they are generated. Without this a
 		# streamed reply can arrive in bursts, and a client measuring time to
@@ -39,3 +40,36 @@ llm.example.com {
 	# Access log to stderr, which under systemd is the journal.
 	log
 }
+
+# More than one control plane (server init --standbys, server add): one of
+# them leads, the others stand by. Name them all and send to the one that
+# leads — /leader is 200 there and 503 on a standby. Not /ready: that is 503
+# on a leader with no model running yet, and would take the portal away with
+# it. A standby would pass a request on to the leader anyway, but not while
+# there is none, and the hop is for nothing.
+#
+# With a floating address (--vip) the address already follows the leader:
+# give reverse_proxy that one address instead, and keep the rest as above.
+#
+# llm.example.com {
+# 	request_body {
+# 		max_size 32MB
+# 	}
+# 	reverse_proxy 10.0.0.157:8080 10.0.0.158:8080 10.0.0.159:8080 {
+# 		# The first that is healthy: the leader, whichever it is.
+# 		lb_policy first
+# 		health_uri /leader
+# 		health_interval 2s
+# 		health_timeout 2s
+# 		# While leadership moves — a few seconds when a leader is lost —
+# 		# none is healthy; a request waits that long for one rather than
+# 		# failing at once.
+# 		lb_try_duration 15s
+# 		lb_try_interval 250ms
+# 		flush_interval -1
+# 		transport http {
+# 			response_header_timeout 15m
+# 		}
+# 	}
+# 	log
+# }
@@ -38,7 +38,9 @@
 {{if .Error}}<p class="error">{{.Error}}</p>{{end}}
 <form method="post" autocomplete="on">
  <input type="hidden" name="csrf" value="{{.CSRF}}">
-  <label>{{t "login.email"}}<input type="email" name="email" value="{{.Email}}" required autocomplete="email"></label>
+  {{if .Directory}}<p class="sub">{{t "login.with_directory" .Directory}}</p>
+  <label>{{t "login.username"}}<input type="text" name="email" value="{{.Email}}" required autocomplete="username" autocapitalize="none" spellcheck="false"></label>
+  {{else}}<label>{{t "login.email"}}<input type="email" name="email" value="{{.Email}}" required autocomplete="email"></label>{{end}}
  <label>{{t "login.password"}}<input type="password" name="password" required autocomplete="current-password"></label>
  <button type="submit">{{t "login.submit"}}</button>
 </form>
Author	SHA1	Message	Date
Ilker ManapandClaude Opus 5.5	2005cea326	v0.14.8: changelog and README CI / test (push) Successful in 9m12s Details Release / build (push) Successful in 4m20s Details Release / notes (push) Successful in 3s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-18 11:00:28 +02:00
Ilker ManapandClaude Opus 5.5	f27d722111	People sign in with their Active Directory account auth.ldap checks a username and password against the domain controllers over LDAPS or StartTLS: found with a service account, checked by binding as the person. Groups, nested ones included, give staff roles and places in the tree. Accounts are tied to the objectGUID; the leader reads the directory every 15 minutes, suspends whom it disabled or removed and reinstates them after, and refuses a sync that would suspend most. Entra ID sends no groups for someone in more than 200, only where to fetch them; that was read as none and took an administrator's role away. It is now left as it was, and logged. An account made by SCIM or OIDC can be reinstated again. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-18 10:59:50 +02:00
Ilker ManapandClaude Opus 5.5	fe310576e7	Several keys for one outside provider CI / test (push) Successful in 8m52s Details An external model takes api_key_files, each a file and an optional weight, in place of api_key_file. Each key is an endpoint of its own (external:MODEL#1, #2), so the router's scoring, retries and breakers work per key. A key answering 429 is passed over while its breaker is open. A key answering 401 is passed over too, and external_key_refused is sent, naming the endpoint and never the key; with a single key the 401 is still the client's. A key whose file cannot be read is left out, and usage records which key answered by its endpoint. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-17 08:56:30 +02:00
Ilker ManapandClaude Opus 5.5	688b205604	What llmgw adds to a request, measured: ctl bench overhead CI / test (push) Successful in 8m56s Details An engine that answers at once and the gateway in front of it, in one process on loopback, given the same load straight and through the gateway: bare, with authentication and accounting, and with the guardrails' pattern checks. It reports p50 and p99, what the gateway added, and a rough CPU per thousand requests. On an Apple M5 at 100 to 2,000 requests a second (10 s a step, 72,000 requests, none failed), the gateway added 0.05–0.42 ms at p50 and at most 0.49 ms at p99. That is now in the README, with how it was measured and why the CPU figure is rough. CI runs a one-second version. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-17 00:23:26 +02:00
Ilker ManapandClaude Opus 5.5	35ccabac28	modelserve: a job's request is set under the lock Get reads it with CI / test (push) Successful in 8m49s Details CI run 394, on a commit that changed only BACKLOG.md, failed with a data race in TestAVisionModelIsServedWithItsProjectorBesideIt. The serve job's goroutine wrote j.Request without the lock (since `efffdb6`, which sized embedding slots), while Get's snapshot read the job under it. Every other write to a running job holds the lock. It did not reproduce in 30 runs here; the race detector's trace names this write and that read. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 22:40:09 +02:00
Ilker ManapandClaude Opus 5.5	2545fca174	An upgrade refits the judge an earlier server init installed CI / test (push) Successful in 8m53s Details A v0.14.6 install on fewer than eight cores refused every request until its judge was given cores by hand, and upgrading did not change that. The judge keeper, on the leader, now finds a judge whose entry is exactly what init before v0.14.7 wrote: one llama.cpp CPU profile, an 8192 context and nothing else, 2 or 4 GB, none to two cores. It gives the judge 2 GB, --cache-ram 0 and cores by init's rule through modelsvc.SetProfiles, then restarts its ready replicas. The replica count is left as it is. A judge whose entry differs is left alone, and the log says so once. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 22:06:56 +02:00
Ilker ManapandClaude Opus 5.5	b8274d6278	A restart is not refused for room another restart is giving back CI / test (push) Successful in 8m51s Details On a 4-core single-machine install, `ctl model resources` was run on the judge (to two cores) and on the starter (to none), then both restarted. The judge's restart was refused: its replacement fit on no node even with its old replica stopped, because the starter still held its two cores. A restart now waits for other restarts under way (queued, retiring or draining) when their going would make room, up to DrainGrace. A drained replica was also kept until its model had enough live replicas, and a replica being restarted that still answers did not count. So with replicas restarted one after another, each drained one waited out the five-minute grace, holding its room. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 21:33:20 +02:00
Ilker ManapandClaude Opus 5.5	8164260e3b	Backlog: test VMs removed, Apertus on demand CI / test (push) Failing after 6m12s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 21:18:46 +02:00
Ilker ManapandClaude Opus 5.5	fbb5df05b8	Backlog: what is open, in order; J, what the HA and single-machine tests found CI / test (push) Successful in 8m59s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 21:07:57 +02:00
Ilker ManapandClaude Opus 5.5	af942aca27	v0.14.7: changelog and README Release / build (push) Successful in 5m33s Details Release / notes (push) Successful in 4s Details CI / test (push) Successful in 10m30s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 20:11:26 +02:00
Ilker ManapandClaude Opus 5.5	3e7dd20bad	One machine runs one judge, on up to four cores CI / test (push) Successful in 9m1s Details A second judge replica on the same machine shares its cores and is lost with it, so it bought nothing but half the speed of each. On a 4-core, 8 GB single-machine install, one judge on four cores passed 20 of 20 requests at about 3.5 s each, judged in and out. Two judges on two cores each had passed 19 of 20. server init now serves one judge when this machine is the only node, and two, on two cores each and spread over the nodes, where there will be others (HA setups, or a control plane that is not a node). --judge-replicas and the setup's Copies still choose. install.md gives the measured times in place of "half a second". Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 19:35:42 +02:00
Ilker ManapandClaude Opus 5.5	f8206c3540	A judge reserves two cores and 2 GB, with no prompt cache CI / test (push) Successful in 9m1s Details Checked by a single-machine install of v0.14.6 on a 4-core, 8 GB VM. The second judge fitted nowhere: v0.14.6 reserved 4 GB a judge, a figure from one replica that grew to 3.2 GB through llama.cpp's prompt cache (up to 8 GB by default), which a judge never reuses. Once it fitted, every judgment timed out. v0.14.6 gave a judge one core below 8 CPUs, and a judgment of about 280 tokens takes 8.0 s on one core, 4.2 s on two and 2.3 s on four, against a 5 s budget: 0 of 20 requests went through. A judge now runs with --cache-ram 0, uses about 1.6 GB and reserves 2, and reserves two cores (one only below four CPUs). On the same VM, 19 of 20 went through. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 19:22:33 +02:00
Ilker ManapandClaude Opus 5.5	0def6eaba1	CI: run on maas-packer, the runner that serves this Gitea, given 8 cores and 32 GB CI / test (push) Successful in 9m1s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 18:15:58 +02:00
Ilker ManapandClaude Opus 5.5	645be2d278	CI: run again on the runner given 8 cores and 32 GB CI / test (push) Canceled after 12s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 17:49:44 +02:00
Ilker ManapandClaude Opus 5.5	25c4ec9f2a	CI: a package that hangs says which test it hung in CI / test (push) Failing after 30m4s Details Every test run since `c22528c` ended at the job's 30-minute deadline with nothing after internal/release, while the same tests pass with -race on Linux, as a user and as root, in 5 minutes. A 12-minute test timeout makes the hang name itself. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 16:54:48 +02:00
Ilker ManapandClaude Opus 5.5	7eb50c5eb6	v0.14.6: changelog and README CI / test (push) Failing after 30m6s Details Release / build (push) Successful in 17m32s Details Release / notes (push) Successful in 4s Details Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 13:33:13 +02:00
Ilker ManapandClaude Opus 5.5	b8fc1de822	Backlog I: what other gateways do that llmgw does not CI / test (push) Failing after 30m6s Details From a comparison with Bifrost: answers to similar questions, the customer's MCP servers behind llmgw, the gateway's overhead measured, and several keys for one outside provider. H9's /mcp item is done. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-16 13:29:20 +02:00
Ilker ManapandClaude Opus 5.5	63b2c6d9a4	The judges and the starter divide a machine's CPUs instead of each taking all CI / test (push) Failing after 30m7s Details Measured on the three-VM cluster with ha1's CPUs loaded: 38 of 60 requests refused with both judges and the starter on ha1, each engine on all four cores. With the judges moved to a 4-core, 32 GB node at 2 cores each, 2 of 60 were refused, both the first after the judges started. init now reserves cores by this machine's count: one per judge replica under 8 CPUs and two from 8, and the rest, up to 8, for the starter on CPU. The starter reserves nothing when nothing is left, so it still fits. Judges bound for nodes not yet known get two each. A judge reserves 4 GB; it uses about 3.2. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 13:00:39 +02:00
Ilker ManapandClaude Opus 5.5	0b984a92bc	A judge is asked again only on another machine CI / test (push) Failing after 30m3s Details Measured under CPU load on the three-VM cluster, with both judge replicas on ha1: 37 of 60 requests failed with the hedge, 38 of 60 without it. Two replicas on one saturated machine are slow together, and the second question doubled the work there. The hedge now goes only to a replica whose address names another host. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 10:27:50 +02:00
Ilker ManapandClaude Opus 5.5	bc4c5d5ac9	A judge replica that hangs is overtaken by another at half the budget On the three-VM cluster about one answer in twenty-five came back as content_filter: both judge replicas timed out within the same millisecond. The tries shared the policy's 5 s budget, so the first replica, busy on an oversubscribed machine, used it all and the retry on the second had nothing left. A judge request now goes to a second replica too when the first has not answered by half the budget, and the first answer is taken. The first is not cut short. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-16 08:35:28 +02:00
Ilker ManapandClaude Opus 5.5	b09922b29b	Leadership stays put while the store's primary is replaced CI / test (push) Failing after 30m3s Details Measured again after the store fixes. Cutting the store primary's power no longer hung requests, but leadership moved anyway: the lease had lapsed for everyone while Patroni promoted the standby, and a standby asked first. The new leader then spent about 25 s without its nodes, and so without its judges. A standby that saw the store out of reach now leaves the lease alone for one renew round after the store returns. The default lease is 10 s, and a node detects a control plane that died silently in 8 s (5 s idle, 3 s ping) rather than 15. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-15 23:17:58 +02:00
Ilker ManapandClaude Opus 5.5	5a4b022dcd	A lost store machine is given up on in seconds, and a new leader waits for its judge CI / test (push) Failing after 30m6s Details Measured on three VMs: cutting the store primary's power cost about 45 s of hanging requests. New connections tried the dead member first with no connect timeout, and Patroni kept its 30 s leader key. Cutting the leader of both cost a further 17 s of 503s while the new leader knew no judge. The store dials each member for 3 s and closes connections to a machine that is gone within about 10 s (keepalive, TCP_USER_TIMEOUT). Patroni runs with ttl 20, loop_wait 5 and retry_timeout 5, applied in place to existing clusters through its API. Judges that all fail at once are asked again every 250 ms while the policy's budget lasts, and reported once. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-15 20:33:13 +02:00
Ilker ManapandClaude Opus 5.5	eeaffd764d	A floating address keeps to its own network, and Caddy follows the leader CI / test (push) Failing after 30m3s Details Found by a three-machine install on fresh VMs. The second standby's run asked for the floating address's interface with `ip route get <vip>`. The machine already held the address, so that answered lo, and keepalived would not start. The interface now comes from the route to the address's network. Every cluster's VRRP router id was 51, so the PoC's two control planes and the new three on one LAN each logged the other's adverts as an invalid password; the id now comes from the address. The Caddyfile, deploy/ha and install.md send clients to the control plane whose /leader is 200, not /ready: /ready is 503 on a leader with no model yet and would take the portal away with it. Setup no longer hides a key file's path as if it were a password, and the starter's text no longer says it runs elsewhere when this machine is a node. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-15 17:35:10 +02:00
Ilker ManapandClaude Opus 5.5	94401e21e6	Setup lets every part be chosen, each with its settings; three machines each run the gateway CI / test (push) Failing after 30m4s Details The setup screens list the parts of an install: control plane, store, model mirror, this machine as a node, starter model, pictures and 3D, the judge, firewall, notifications, limits, on-demand turns and an offline bundle. Each says what it is or what is missing without it. Space turns a part on or off; Enter opens its settings in a dialog that explains it. A plan page lists what is installed and what is left out, and the same install as a command. Every setting is a server init flag too, written into server.yaml when init writes it. With three machines, the two database machines become control planes too, standing by (server add's steps), with an optional floating address. The mirror's management API answers all three control planes, so a standby that comes to lead can still fetch models. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-15 11:22:36 +02:00
Ilker Manap	733e20924c	Merge remote-tracking branch 'origin/mcp-wait' into sd-dedupe CI / test (push) Failing after 30m3s Details	2026-10-15 07:53:22 +02:00
Ilker ManapandClaude Opus 5.5	fc60481e40	Every control plane lists the others alike to Prometheus 140 named 150 a store member, 150 named itself a control plane: Prometheus asking both scraped 150 twice and counted its every series twice, and asked of 140 alone while 150 led it lost every node. Each control plane now lists all of them as control planes before the store's members, so two answers agree and a target is scraped once. The shipped prometheus.yml says to scrape and ask every control plane. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-15 07:53:22 +02:00