pillarz 0.1.0__tar.gz

pillarz-0.1.0/CHANGELOG.md

@@ -0,0 +1,536 @@
+# Changelog
+
+Alle nennenswerten Änderungen an pillarz. Dieses CHANGELOG richtet sich an **App-Entwickler**
+(Breaking Changes, neue Hooks, Upgrade-Hinweise), nicht an Endnutzer. Format nach
+[Keep a Changelog](https://keepachangelog.com/de/1.1.0/), Versionen nach SemVer (ADR 0002): vor 1.0
+darf sich die öffentliche API zwischen 0.x-Versionen ohne Deprecation-Frist ändern, jede solche
+Änderung steht unter „Breaking“. Abschnitte: Added, Changed, Deprecated, Removed, Fixed, Security,
+Breaking, Upgrade.
+
+## [Unreleased]
+
+## [0.1.0] — 2026-10-30
+
+**0.1.0 – Fundament.** Gegenüber 0.1.0.dev1 (Gerüst, Datenbank, Migrationen, Web-Rahmen, i18n) kommen
+Sitzungen und Passwort-Anmeldung, die Ersteinrichtung, Konten mit Rollen und Events, Admin-Oberfläche und
+Kontoseite, Einstellungen, authentik (OIDC) mit Verknüpfung und RP-Logout sowie die App-Hooks dazu. Damit deckt
+pillarz ab, was labelz heute in `security.py`, `oidc.py`, `linking.py`, `events.py`, `themes.py`, im allgemeinen
+Teil von `settings.py` und in den Konten-/Admin-Teilen von `api/` hat. Nachweis: `examples/minimal` und die
+Referenz-Umstellung `tests/adoption/labelz/` (siehe Upgrade). Breaking-Abschnitt in zwei Teilen: gegenüber
+0.1.0.dev1 und gegenüber dem heutigen Verhalten von labelz.
+
+### Added
+
+**Sitzungen und Passwort (ADR 0005)**
+- Serverseitige Sitzungen in `pz_sessions`: Cookie `__Host-<name>` bei reinem HTTPS (sonst `<name>`), `HttpOnly`,
+  `SameSite=Lax`, 256 Bit Zufall, in der Datenbank nur der SHA-256. Eine Abfrage je Request (statische Dateien
+  ohne), absolute Dauer `SESSION_DAYS`, optionaler Leerlauf `IDLE_TIMEOUT_MINUTES` (0 = aus, sonst mindestens 5;
+  endet nie zu früh, höchstens eine Minute zu spät), `last_seen_at` höchstens 1×/60 s; Anfragen mit
+  `X-PZ-Background: 1` (`api(…, {background: true})`) verlängern nicht. Neue Sitzung bei jeder Anmeldung
+  (Fixation), gesperrte Konten sind sofort abgemeldet.
+- **Aufräumen beim Start** (P-43): abgelaufene und wegen Leerlauf ungültige Sitzungen, abgelaufene Flows, alte
+  Bremsen-Einträge und erledigte Einmal-Tokens (> 30 Tage) werden gelöscht – still, `user.signed_out` mit
+  `reason="expired"` folgt mit 0.2.
+- Fremde oder ungültige Cookie-Werte unter dem Cookienamen (z. B. labelz' Starlette-Cookie `labelz`, Müll,
+  gelöschte/abgelaufene Sitzungen) werden still verworfen: anonym, Antwort löscht das Cookie, kein
+  Protokolleintrag (P-106).
+- `pillarz.web.session_id(request)`: öffentliche, stabile Kennung der Sitzung (`pz_sessions.public_id`, nicht
+  der Token-Hash), neu nach jeder Anmeldung, `None` ohne Sitzung (P-104).
+- Seiten `GET/POST /login`, `POST /logout`, `GET/POST /setup` (ohne JavaScript) und JSON `POST
+  /api/pz/me/password`, `POST /api/pz/me/logout-all` (`{"keep_current": true}`), `POST /api/pz/me/reauth`,
+  `GET /api/pz/me/sessions`, `DELETE /api/pz/me/sessions/{session_id}`. `/api/pz/me/*` nimmt nur Sitzungen an.
+  `/login`, `/logout`, `/setup`, `/auth/` und `/api/pz/` sind `no-store` (Referrer-Policy wie überall
+  `same-origin`).
+- Kopfzeile für Abgemeldete: „Anmelden“ bzw. „Einrichten“, solange `/setup` offen ist (auch auf Fehlerseiten,
+  nicht auf `/login`/`/setup` selbst).
+- Protokoll auf der Konsole: hat niemand Logging eingerichtet (root-Logger ohne Handler, z. B. nur uvicorn),
+  schreibt pillarz die Einträge von `pillarz` und dem App-Logger ab INFO einzeilig auf stderr – so sieht der
+  Betreiber im Container z. B. die Warnung „Einrichtung offen“. Mit eigener Logging-Konfiguration nicht.
+- Passwortregeln K-4 (10–200 Zeichen, nicht gleich dem Benutzernamen, kein Platzhalter, App-Liste
+  `Pillarz(weak_passwords=…)`); scrypt wie labelz mit Rehash schwächerer Parameter bei der Anmeldung.
+- **Anmeldebremse in der Datenbank** (`pz_throttle`, über alle Worker/Container): 5 Fehlversuche je IP
+  (IPv6 je /64) und je Benutzername in 10 min, 100 insgesamt; für Anmeldung, Passwortwechsel, `reauth`.
+  `pillarz.web.throttled(key, limit, window_seconds)` und `hit(key)` für eigene Bremsen der App (eigener
+  Namensraum, Fenster ≤ 24 h).
+- Schritt-hoch (Server-Teil): `reauth_at` je Sitzung, frisch für 5 min nach Anmeldung oder `POST
+  /api/pz/me/reauth`; pillarz-Aktionen antworten sonst 403 mit `reauth` (Methoden). Für App-Routen noch nicht
+  öffentlich.
+- Geräteliste: Gerät aus dem User-Agent („Firefox auf Linux“), Methode, angemeldet seit, zuletzt aktiv, IP,
+  „dieses Gerät“.
+- Kurzlebiger Vorab-Zustand für Anmeldeabläufe (`pz_flows`, Cookie `<name>_flow`, einmalig, 10 min).
+
+**Ersteinrichtung (ADR 0015)**
+- `/setup` ist offen nur ohne `ADMIN_PASSWORD`, mit Methode `password` und ohne Konten; `/login` leitet dann
+  dorthin, danach antwortet `/setup` 404 und leitet nach dem Anlegen auf `/admin`. Atomar über
+  `pz_meta.setup_done` (zwei gleichzeitige Versuche → ein Admin, der zweite 409). Optional `SETUP_TOKEN`
+  (konstante Zeit, gebremst). Startwarnung (Stufe Warnung) und stündliche Wiederholung, solange offen;
+  Warnhinweis auf der Seite bei `https://`-Adresse ohne Token.
+- Erstes Admin-Konto aus `ADMIN_USERNAME`/`ADMIN_PASSWORD` beim Start (nur leere Datenbank).
+
+**Konten, Rollen, Events (ADR 0006)**
+- Rollen `admin`, `user`, `guest`. `pillarz.accounts` (lesend): `User`, `get_user`, `find_user`, `list_users`,
+  `count_active_admins`. `require_member` (user + admin) für normale App-Seiten, `require_user` lässt auch Gäste
+  durch; `require_admin`/`is_admin` rechnen mit der wirksamen Rolle (befristete authentik-Admin-Rechte der
+  Sitzung, Deckel `max_role` eines Authenticators).
+- `pz.on(event, order=…)`: tx-Events `user.created`, `user.updated`, `user.deactivating`, `user.reactivated`,
+  `user.deleting` (in der pillarz-Transaktion, `ev.conn`; `ev.veto(text)` bei created/deactivating/deleting →
+  409, alles zurückgerollt, auch Schreibzugriffe anderer Handler), Nach-Commit-Events `user.deleted` (`result`),
+  `user.signed_in` (`session_id`, `method`), `user.signed_out` (`session_ids`, `reason`) – Fehler dort werden
+  protokolliert und geschluckt (K-8). `user.created` mit `source` = `admin`, `setup`, `env`, `cli`, `oidc`.
+  `user.delete_preview` (Hinweiszeilen, `ev.block(text)`; läuft beim Löschen ein zweites Mal in der
+  Lösch-Transaktion – rein lesend halten). Nutzlasten in `pillarz.events` (`READ_EVENTS` exportiert). Derselbe
+  Handler zweimal für dasselbe Event → `ValueError`.
+- `connect()` in einem tx-Event-Handler liefert auf demselben Thread die laufende Transaktion (auch
+  verschachtelt). Threads in tx-Handlern sind verboten: andere Threads warten höchstens `TX_WAIT_SECONDS` (10 s)
+  und bekommen dann `pillarz.db.TxThreadError` statt zu verklemmen.
+- `pz.delete_input(DeleteInput(key, kind="user|choice|bool|text", label, required, default, help, options,
+  on_self, self_default, max_length, visible))` – Zusatzangaben im Löschdialog, serverseitig geprüft, als
+  `ev.inputs` (`MappingProxyType`). `kind="user"` wird bei Selbstlöschung nie abgefragt und braucht dann
+  `self_default` (Wert oder `fn(user, conn)`), sonst bricht `create_app()` ab; `visible=fn(user, conn)` fragt
+  nur, wenn es etwas zu entscheiden gibt.
+- **Konto selbst löschen** (F-3): `Pillarz(self_delete=True)` (Standard), `GET /api/pz/me/delete`, `DELETE
+  /api/pz/me` mit `{"inputs", "confirm": <benutzername>}` – Schritt-hoch, letzter aktiver Admin gesperrt, Cookie
+  gelöscht, Ziel `/login?hint=account-deleted` (bzw. RP-Logout). `self_delete=False` → Abschnitt fehlt,
+  Endpunkte 404.
+
+**Admin-Oberfläche und Kontoseite**
+- `/admin` mit Reitern Konten (anlegen, bearbeiten, Rolle, sperren, Passwort setzen, Sitzungen beenden,
+  Löschdialog mit Zusatzangaben, Vorschau und „Stattdessen sperren“), authentik-Links, Geräte, Themes,
+  Einstellungen, Protokoll (Filter Bereich, Konto, nur Probleme, Blättern); Hash-Routing `/admin#<key>[-<id>]`.
+  `pz.admin_tab(AdminTab(key, label, order, icon, template, module, visible))` – ES-Modul mit `init(panel, ctx)`;
+  belegte Schlüssel: `users`, `links`, `sessions`, `themes`, `settings`, `log`.
+- `/account` (alle Rollen): Profil, Darstellung (Theme, hell/dunkel/auto), Sprache, Anmeldung (Passwort,
+  authentik), Geräte, Konto löschen; `pz.account_section(AccountSection(…))` mit `init(section, ctx)`. Abschnitte
+  inaktiver Methoden fehlen, ihre Endpunkte antworten 404. `GET/PATCH /api/pz/me`, `GET /api/pz/themes`.
+- Admin-API unter `/api/pz/admin/…` (Konten, Sitzungen, Themes, Einstellungen, Protokoll); `GET
+  /api/pz/admin/users` liefert `elevated_only`, `…/users/{id}/delete` `reauth` (`{needed, methods}`).
+
+**Einstellungen**
+- `pz.setting(Setting(key, default, kind="text|int|bool|choice|custom", label, help, ui, validate, options,
+  required, max_length, min, max))`; `kind="custom"` verlangt `validate`. Öffentlich
+  `pillarz.settings.get/all/update` (`SettingError` mit `key`). pillarz-Schlüssel `site_name`, `default_theme`,
+  `default_locale` wirken im Seitenrahmen (Zwischenspeicher je Prozess, höchstens 5 s alt). Meldungen am Feld,
+  Werte werden nie still gekappt; „alt → neu“ im Protokoll.
+- `pz.settings_section(SettingsSection(key, label, order, keys, template, module))` – App-Abschnitt im Reiter
+  „Einstellungen“, speichert über `ctx.save()` (`PATCH /api/pz/admin/settings`, 422 mit `field`); ein Schlüssel
+  in zwei Abschnitten oder ein nicht angemeldeter Schlüssel → Startabbruch.
+
+**authentik / OIDC (ADR 0008)**
+- Anmeldung über `/auth/login` → `/auth/callback` (Authorization Code + PKCE, `state`/`nonce` in `pz_flows`,
+  ID-Token mit den Verfahren der Discovery – HS256 nur, wenn der Anbieter es meldet –, Userinfo). **Kontozuordnung
+  nur über die verknüpfte `sub`, nie über die E-Mail-Adresse** (Leitung 2026-10-30); unbekannte `sub` → Anlage
+  bei Gruppe (Adresse aus authentik, wenn frei; bestätigt nur bei `email_verified`) → sonst 403. Gruppen
+  `OIDC_USER_GROUPS` (`user`), **neu** `OIDC_GUEST_GROUPS` (`guest`), `OIDC_ADMIN_GROUPS` (befristete
+  Admin-Rechte je Sitzung, `OIDC_ADMIN_HOURS`; die Rolle am Konto ändert die Anmeldung nie). Knopf „Mit
+  <OIDC_LABEL> anmelden“, `#boot.auth` (`{"password": bool, "oidc": {"enabled", "label"}}`).
+- pillarz-Migration `0003_users_oidc_origin`: `users.created_via` (Quelle der Anlage wie `user.created`
+  `source`; `NULL` = vorher/übernommen = lokal) und `users.oidc_unlinked_sub` (private Spalten).
+- **RP-initiated Logout:** `POST /logout` einer authentik-Sitzung leitet zu `end_session_endpoint` mit
+  `id_token_hint`, `client_id` und `post_logout_redirect_uri=<PUBLIC_URL>/login?hint=logged-out`; JSON-Antworten von
+  `DELETE /api/pz/me` (`hint=account-deleted`) und `DELETE /api/pz/me/sessions/{id}` für die **aktuelle** Sitzung
+  tragen das Ziel in `redirect`. GET, weil authentik POST mit 403 (CSRF) ablehnt; Restrisiko ADR 0008. Schalter
+  `OIDC_LOGOUT` (Standard 1). „Überall abmelden“ und fremde Sitzungen beenden bleibt lokal.
+- **Schritt-hoch per authentik:** `/auth/login?reauth=1&next=…` mit `prompt=login`, `max_age=300` (authentik 2026.8
+  wertet `max_age=0` nicht aus und erzwingt `prompt=login` nur einmal je Sitzung, ADR 0008); frisch nur bei `auth_time`
+  ≤ 5 min (+ 60 s Spielraum) und demselben Konto – eine jüngere authentik-Anmeldung reicht ohne neue Abfrage. Hat ein
+  Konto Passwort und authentik, bietet der Dialog beide Wege („Mit <OIDC_LABEL> bestätigen“).
+- **Falscher `OIDC_ISSUER` ist auffindbar:** Discovery-Prüfung beim Start im Hintergrund (Timeout 5 s, hält den Start
+  nicht auf, bricht ihn nicht ab, nicht im Testmodus). Jeder Fehlschlag steht mit Adresse und Status im Protokoll,
+  getrennt nach falsch eingerichtet (404, anderer Issuer, kein Discovery-Dokument, Zertifikat) und nicht erreichbar
+  (Verbindung, Timeout, 5xx), je Ursache höchstens einmal pro Minute. `/admin` zeigt dazu einen Hinweis; `/auth/login`
+  meldet bei falscher Einstellung „nicht eingerichtet“ statt „nicht erreichbar“.
+- Kontenliste: Chip „Admin, befristet bis HH:MM“ für Nutzer und Gäste mit laufenden befristeten Admin-Rechten; neues
+  Feld `elevated_until` in `GET /api/pz/admin/users`.
+- **Zertifikate:** Die OIDC-Abrufe vertrauen dem Zertifikatsspeicher des Systems statt dem certifi-Bündel von httpx,
+  `OIDC_CA_FILE` kommt zusätzlich dazu.
+- **Verknüpfung** (labelz E-35–E-37): Admin-Einmal-Link (`pz_tokens`, Art `oidc_link`, 7 Tage, nur im Fragment
+  `/auth/link#…`, optional erwarteter Benutzername), Einlöse-Seite, `POST /api/pz/link/info|start`, `POST/DELETE
+  /api/pz/admin/users/{id}/oidc-link`, `PATCH …/users/{id}` mit `oidc_unlink`; Selbst verknüpfen/lösen auf der
+  Kontoseite (`POST /api/pz/me/oidc-link|oidc-unlink` mit Passwort). Beide Verknüpfungswege verlangen bei authentik
+  eine neue Anmeldung (`prompt=login`, `max_age=60`). **Über authentik entstandene Konten (`created_via = 'oidc'`) lassen sich
+  nicht lösen** – 409, die UI bietet es nicht an („Zugang entziehen = Konto sperren“); `oidc_created` in den
+  Konto-JSONs. Nach dem Lösen legt dieselbe `sub` kein neues Konto an, bis sie wieder verknüpft ist.
+
+**Hooks für Apps**
+- **`pz.context(fn)`** (P-9): `fn(request, user) -> dict` liefert Werte für den Template-Kontext jeder Seite
+  und für Routen über `pillarz.web.request_context(request)` (danach auch `request.state.app_context`) – z. B.
+  Navigations-Badges wie labelz' `nav_answers`. Nur für Angemeldete, höchstens einmal je Request und erst bei
+  Bedarf (erstes `render()`/`request_context()`). Mehrere Haken in Anmeldereihenfolge, `render(**ctx)` hat
+  Vorrang; von pillarz belegte Schlüssel → Fehler. Eine Ausnahme im Haken ergibt 500 mit Fehlerseite und
+  Protokolleintrag.
+- **Request-Authenticators** (P-99): `@pz.request_authenticator(name, max_role="user", methods=("GET","HEAD"))`
+  mit Rückgabe `None`, Konto-ID oder `pillarz.web.AuthResult(user_id, context)`; `pillarz.web.auth_context(request)`.
+  Läuft vor dem Gate, nur ohne Sitzung, sieht den Pfad; Rolle gedeckelt, pillarz-Seiten und `/api/pz/*` → 403,
+  keine Nebenwirkungen (keine Sitzung, kein Cookie, kein `last_seen`, kein `user.signed_in`).
+- `pz.secret_user_column(name)` (S-N6): Spalte von `users` als geheim melden – sie erscheint nie in Kontozeile,
+  Templates oder JSON.
+- `pillarz.db`: `scalar`, `execute`, `TxThreadError`; jedes Symbol in `__all__` mit Docstring (P-100).
+- `ui.js`: `numProblem(input)`, `fieldError(input, text)`/`clearFieldError(input)` (mit `aria-invalid`,
+  `aria-describedby`), `validationMessage(input)` (`data-msg-required|pattern|type`), `clearToasts(type)`;
+  `ui.dialog()` meldet ungültige Felder am ersten Feld. Theme-Token `--pz-input-line` (≥ 3:1) und
+  `--pz-accent-text` (≥ 4,5:1), `/themes.css` liefert `--t-accent-text` je Theme und Modus.
+
+**Testkit, Beispiel, Referenz-Umstellung, CI**
+- `pillarz.testing.make_user()` (liefert `User`), `login()` (echter `POST /login`), `login_as()` (Sitzung direkt
+  in der Datenbank, echte `Set-Cookie`-Antwort), `PASSWORD`; `FakeIdP` (simulierter authentik: Discovery, JWKS,
+  Token, Userinfo, `end_session_endpoint` mit Prüfung von `id_token_hint` (POST → 403 wie authentik), `auth_time`;
+  `max_age` und `prompt=login` entscheidet er wie authentik 2026.8 (`markers`, `login_ids`, `logins`);
+  prüft `response_type`, `scope`, `code_challenge_method`; Schalter `algs`, `auth_time`,
+  `registered_post_logout`, `end_session_post`; `idp.env()`, `idp.install()`, `idp.serve()`),
+  `oidc_login(client, idp, claims, next=…, reauth=…)`, `oidc_callback(…)`.
+- `examples/minimal`: `require_member`, `/password`, `/notes`, Events mit Zusatzangabe `heir` (nur bei
+  freigegebenen Designs), Vorschau und Veto, App-Reiter „Designs“, Einstellungs-Abschnitt „Notizen“,
+  App-Einstellungen `greeting` und `designs_per_page`, `auth_methods=("password", "oidc")`.
+- **Referenz-Umstellung labelz, Schritt 1** (P-84) in `tests/adoption/labelz/`: synthetische labelz-0.13-
+  Datenbank, Vorlage der App-Migration (`migration.py`) und eine Mini-App mit labelz' Andockpunkten; läuft auf
+  SQLite und PostgreSQL (siehe Upgrade).
+- CI: zusätzlicher Testlauf mit **Python 3.13** (SQLite, gleiche Hash-Pins; 3.12 bleibt Hauptversion für Locks,
+  PostgreSQL-Job und Build), Build wartet auf ihn (P-87).
+- `python -m tests.browser_smoke`: Ersteinrichtung, Anmelden, Kontoseite, Admin-Reiter, Nutzer-Sicht,
+  Selbstlöschung, Passwort ändern, Abmelden per Tastatur; zweite Instanz mit authentik gegen `FakeIdP`
+  (RP-Logout, Admin-Dialoge Link erstellen/zurückziehen/Verknüpfung lösen).
+
+### Changed
+- `require_*`, `current_user`, `is_admin`, `via` arbeiten auf der echten Sitzung (in 0.1.0.dev1 waren sie
+  Hüllen ohne Anmeldung) – siehe Breaking.
+- HTML-Formulare (Nicht-GET außerhalb `/api/` mit `Accept: text/html`) bekommen bei Ablehnung oder Fehler die
+  Fehlerseite statt JSON – auch bei frühen Ablehnungen des Guards (CSRF, Größe); 401 → `/login`. `fetch` mit
+  `Accept: application/json` und `/api/` bleiben JSON.
+- Fehlerseiten: eigener Titel je Code („Kein Zugriff“, „Seite nicht gefunden“, „Gerade nicht erreichbar“),
+  Erklärung mit nächstem Schritt statt Standardmeldung (eigene Meldungen der App bleiben); angemeldet zeigen
+  403/404 die Navigation.
+- Toasts: gleiche Texte zusammengefasst (×N), höchstens zwei, Erfolg 4 s; Fehler am Feld entfernen offene
+  Erfolgsmeldungen.
+- Die einmalige Rückmeldung (Flash) wird erst verbraucht, wenn eine Seite mit Rahmen sie zeigt.
+- Protokolltexte der Anmeldung enthalten die IP nicht mehr; sie steht nur in der Spalte `ip`.
+- Leeres `PUBLIC_URLS` warnt im Testmodus nicht mehr (gemischt http/https weiterhin immer).
+- `env.example` vollständig für 0.1.0 (Test: jede gelesene Variable steht dort).
+
+### Fixed
+- Firefox/Zen über http zu einer Nicht-localhost-Adresse: Anmelden und Einrichten scheiterten mit „Anfrage von
+  fremder Seite abgelehnt.“ – `Referrer-Policy: no-referrer` auf no-store-Seiten ließ Firefox beim Formular-POST
+  `Origin: null` senden (ohne `Sec-Fetch-Site`). Diese Seiten haben jetzt `same-origin`;
+  `testing.assert_security_headers` verlangt `same-origin`.
+- `pillarz.db.reset()` (nur Tests) scheiterte auf SQLite an App-Schemata mit mehrstufigen Fremdschlüsseln auf
+  `users` („no such table: main.users“, z. B. labelz) – löscht jetzt ohne Fremdschlüsselprüfung.
+
+### Security
+- Gleiche Meldung und Antwortzeit für „falsch“, „unbekannt“ und „gesperrt“ (Dummy-Hash mit aktuellen
+  Parametern); gesperrtes Konto + richtiges Passwort → dasselbe 401, Grund nur im Protokoll (S-N5).
+- Bremse ohne Wettlauf: Versuche werden vor scrypt atomar reserviert (SQLite `BEGIN IMMEDIATE`, PG
+  `pg_advisory_xact_lock`), 40 parallele Fehlversuche ergeben höchstens 5 Prüfungen. scrypt höchstens viermal
+  gleichzeitig je Prozess; sind alle Plätze > 2 s belegt: 503 mit `Retry-After` (zählt nicht als Fehlversuch).
+- Kein Aussperren durch Fremde: Passwortbestätigungen angemeldeter Sitzungen zählen unter `confirm:<user_id>`;
+  Bremsschlüssel nur aus gültigen Benutzernamen; greift ein Konto- oder der globale Schlüssel, warnt das
+  Protokoll.
+- Passwortwechsel rotiert das Sitzungstoken und beendet die anderen Sitzungen in einer Transaktion; ein erstes
+  eigenes Passwort (Konto ohne Passwort) verlangt eine frische Sitzung.
+- Rollenwechsel erhöht `session_epoch`; wer zum Admin befördert wird, verliert alle Sitzungen.
+- Admin-Aktionen „Admin-Rolle vergeben“, „Passwort/E-Mail eines Admin-Kontos ändern“ und „Konto löschen“
+  brauchen Schritt-hoch (403 mit `reauth`). **Befristete Admins** (nur authentik-Gruppe) dürfen keine
+  Admin-Konten anlegen, befördern, herabstufen, sperren, entsperren, löschen oder deren Verknüpfung ändern – Rolle
+  und Sperre eines Admin-Kontos auch dann nicht, wenn es gesperrt ist (403, Warnung im Protokoll).
+- Letzter aktiver Admin: Herabstufen, Sperren und Löschen (auch selbst) gesperrt, gezählt mit Sperre in der
+  Transaktion. K-9: eigenes Passwort, eigene E-Mail und eigene Verknüpfung nicht über `/api/pz/admin/…` (403).
+- **Keine authentik-Zuordnung über die E-Mail-Adresse** (authentiks Standard-Mapping meldet `email_verified`
+  immer `true` – sonst Übernahme fremder Konten, auch von Admins). Link-Prüfung gebremst (10 / 10 min je IP,
+  IPv6 je /64), Link-Anlage 20 / min je Admin.
+- ID-Token: nur Verfahren aus `id_token_signing_alg_values_supported` (ohne Angabe nur RS256), `azp` geprüft,
+  wenn vorhanden, `nbf` mit Spielraum, `iat` Pflicht; kaputtes JWKS und Nicht-String-Token → 400 statt 500. In
+  `pz_sessions` liegt es AES-256-GCM-verschlüsselt (Schlüssel per HKDF aus `SECRET_KEY`).
+- `/auth/callback` verbraucht einen Flow nur bei passendem `state`; ohne passenden Flow kein Angreifertext im
+  Protokoll (eine feste, entprellte Zeile), Anbieter-`error` erst nach gültigem Flow. Flows gebremst je IP (/64)
+  und insgesamt (3000 / 10 min). Einlösen, Selbst-Verknüpfen und Lösen mit `BEGIN IMMEDIATE` (kein 500 bei
+  Wettlauf). Selbst-Lösen nimmt der laufenden Sitzung befristete Admin-Rechte und das ID-Token.
+- `OIDC_ISSUER` mit `http://` nur für localhost, sonst Startabbruch.
+- IDs > 2⁶³−1 in Pfad, Query und `DeleteInput(kind="user")` → 404/422 statt 500.
+- Anmeldemethode `password` aus: `POST /login`, `/api/pz/me/password`, `/api/pz/me/reauth` → 404.
+
+### Breaking
+
+**Gegenüber 0.1.0.dev1**
+- `current_user()` / `request.state.user` ist ein `pillarz.accounts.User` (eingefrorene Datenklasse der
+  öffentlichen Spalten: `user.id`, `user.username`, `user.role`, `user.is_guest` …) statt eines dicts – ebenso
+  die Rückgabe von `require_*`, `user` in Templates, `NavItem.visible/badge`, `pz.boot(request, user)`. Keine
+  internen Spalten (`theme`, `mode`, `oidc_*`, `password_hash`).
+- pillarz-Migration `0003_users_oidc_origin` ergänzt `users.created_via` und `users.oidc_unlinked_sub` (privat,
+  additiv) – App-Code, der `SELECT * FROM users` 1:1 in eigene Strukturen kopiert, sieht zwei Spalten mehr.
+- `ui.readNum` begrenzt und rundet nicht mehr still: Werte außerhalb von `min`/`max` oder (bei `int`) mit
+  Nachkommastellen ergeben `NaN`; den Grund liefert `numProblem(input)`.
+
+**Gegenüber labelz (für die Umstellung)**
+- **K-4:** neue Passwörter brauchen 10–200 Zeichen (labelz: 8). Bestehende kürzere melden sich weiter an und
+  bekommen einmal den Hinweis „bitte ändere es“.
+- **K-15:** ein schwaches `ADMIN_PASSWORD` (oder ungültiger `ADMIN_USERNAME`) bei leerer Datenbank bricht den
+  Start ab (Exit-Code ≠ 0); labelz legte dann nur kein Konto an. Ohne `ADMIN_PASSWORD` ist bei leerer Datenbank
+  `/setup` offen.
+- **K-8:** `user.signed_out` läuft **nach** dem Commit; ein Fehler im Handler verhindert das Abmelden nicht
+  (labelz räumte im Logout-Request selbst auf).
+- **Alle Sitzungen enden beim Umstieg einmal:** labelz' Cookie-Sitzungen gelten nicht, das alte Cookie wird
+  verworfen und gelöscht.
+- Gesperrtes Konto + richtiges Passwort → 401 wie ein falsches Passwort (labelz: 403 „gesperrt“).
+- Rollen statt `is_admin`: `users.role` (`admin|user|guest`); `is_admin` liest pillarz nicht.
+- **Keine authentik-Zuordnung per E-Mail mehr** (labelz: bestätigte Adresse, `OIDC_TRUST_EMAIL`).
+  `OIDC_TRUST_EMAIL` entfällt (gesetzt → Startwarnung, keine Wirkung). Konten ohne verknüpfte `sub` verbindet nur
+  noch ein Admin-Link oder die Selbst-Verknüpfung; bis dahin endet ihre authentik-Anmeldung mit 403 (oder – mit
+  Gruppe – in einem neuen Konto).
+- Durch authentik-Anmeldung entstandene Konten lassen sich nicht entkoppeln (labelz: mit Passwort möglich);
+  nach dem Lösen legt dieselbe `sub` kein neues Konto an (labelz: Neuanlage per Gruppe).
+- Verknüpfen verlangt bei authentik eine neue Anmeldung (`prompt=login`, `max_age=60`); RP-Logout statt nur lokal abmelden.
+
+### Upgrade
+- **Von 0.1.0.dev1:** `user["x"]` → `user.x`; ob ein Konto ein Passwort hat, liefert `GET /api/pz/me`
+  (`has_password`). Eigene `kind="custom"`-Einstellungen mit `validate=` anmelden. Preview-Handler rein lesend
+  halten; Texte von Vorschau und `DeleteInput.label` mit `lazy()` und Katalogeintrag der App. Ob die Rolle eines
+  Erben passt, prüft die App im `user.deleting`-Handler.
+- **authentik:** Das Image braucht `ca-certificates`; eine eigene CA dort einspielen oder über `OIDC_CA_FILE` angeben.
+  `OIDC_TRUST_EMAIL` aus der Umgebung entfernen. Am Provider je `PUBLIC_URLS`-Eintrag die Redirect-URI `<url>/auth/callback` und die
+  Post-Logout-Redirect-URIs `<url>/login?hint=logged-out` und `<url>/login?hint=account-deleted` eintragen;
+  ohne `PUBLIC_URLS` keine authentik-Anmeldung (Startwarnung). Apps, die authentik anbieten, nehmen `"oidc"` in
+  `auth_methods` auf.
+- **Ersteinrichtung:** neue Instanzen ohne `ADMIN_*` erst einrichten, dann öffentlich erreichbar machen – oder
+  `SETUP_TOKEN` bzw. `ADMIN_*` setzen (`env.example`).
+- **labelz (Vorlage `tests/adoption/labelz/migration.py`, Architektur §5.4):** App-Migrationen
+  `0001_legacy` (bisheriges `create_schema()`) und `0002_pillarz_adoption`: `is_admin = 1` → `role = 'admin'`
+  (Spalte bleibt stehen), `oidc_links` → `pz_tokens` (`kind='oidc_link'`, `data.expected_username` über
+  `json_object_sql`, dann `DROP TABLE`), `themes` → `pz_themes`, `meta['settings']` → `pz_settings`
+  (`site_name`, `default_theme` + registrierte App-Settings; `meta` selbst bleibt), `events` der letzten 30 Tage
+  → `pz_log`. pillarz' `0001_initial` übernimmt `users` additiv (nie neu gebaut), setzt `email_confirmed = 1` für
+  vorhandene Adressen und `setup_done`. Die Vorlage setzt `created_via = 'oidc'` für reine authentik-Konten
+  (verknüpft, ohne Passwort) – diese Annahme trifft das App-Team. Der Test beweist auf SQLite und PostgreSQL: alte Passwörter (auch 8 und
+  9 Zeichen, alte scrypt-Parameter) melden sich an, authentik-Konten per `sub` (nie per Adresse), offene Links
+  bleiben einlösbar,
+  verbrauchte/abgelaufene nicht, Admin aus `is_admin`, `/setup` zu, Themes/Einstellungen/Protokoll übernommen,
+  alle Zeilen der Fachtabellen und alle Fremdschlüssel unverändert, Trockenlauf ändert nichts. Eigene geheime
+  Altspalten mit `pz.secret_user_column(name)` melden.
+- Apps, die bisher eigene Sitzungs-Cookies unter `<name>` setzen, verlieren diese Sitzungen einmal.
+
+## [0.1.0.dev1] — 2026-10-29
+
+### Added
+- Paket und Auslieferung: `pyproject.toml` (setuptools, Version aus `pillarz.__version__`), Laufzeit-
+  Abhängigkeiten als Bereiche, exakte Locks mit Hashes (`requirements.txt`, `requirements-dev.txt`,
+  erzeugt von `scripts/lock-deps.sh`). CI baut bei jedem Push Wheel + Sdist und lädt sie bei `v*`-Tags
+  öffentlich nach **pypi.org** hoch (nur PyPI, keine Forgejo-Registry). Lizenz **`AGPL-3.0-or-later`**
+  (`LICENSE` in Repo, sdist und Wheel; SPDX-Ausdruck nach PEP 639), Kurzbeschreibung `README.md`.
+- `pillarz.Pillarz(name=…, title=…, version=…, package_dir=…, migrations=…, auth_methods=…,
+  weak_passwords=…)` mit `create_app()`, `on_startup()`, `on_shutdown()`, `migrate()` und `config`.
+  Genau eine Instanz je Prozess; Registrieren nach `create_app()` wirft `RuntimeError`. Datenklassen
+  `NavItem`, `AdminTab`, `AccountSection`, `DeleteInput`, `Setting`, `Theme` vorerst nur als Hüllen
+  (Felder folgen mit 0.1-Paketen B–F).
+- `pillarz.config.Config.from_env()`: alle 0.1-Variablen (siehe `env.example`), gelesen beim Erzeugen
+  von `Pillarz`, nicht beim Import. Startabbruch (`ConfigError`) bei `SECRET_KEY` < 32 Zeichen,
+  `SETUP_TOKEN` < 16 Zeichen, ungültigen `PUBLIC_URLS` oder ohne aktive Anmeldemethode; harmlose
+  Fehler als Warnung in `Config.warnings` (beim Start protokolliert).
+- `pillarz.db`: `Conn`/`connect()` aus labelz (`?`-Platzhalter, dict-Zeilen, eine Transaktion je
+  `connect()`), DDL-Platzhalter `ddl()` (`{pk}`, `{blob}`, `{bigint}`), `now()`/`now_plus()`/`stamp()`
+  über eine zentrale Uhr, Migrations-Helfer `has_table`, `has_column`, `add_column`, `create_index`,
+  `json_object_sql`, `upsert_sql`, `applied_migrations`, dazu `IntegrityError`, `ping`, `reset`
+  (nur Tests) und die labelz-Grundbausteine `all_rows`/`one`/`insert`/`update`/`delete`/`get` mit
+  ID-Grenzen.
+- PostgreSQL-Verbindungspool je Prozess (`PG_POOL_SIZE`, Standard 5, `0` = ohne Pool).
+- Versionierte Migrationen je Komponente (`pz_migrations`): pillarz zuerst, dann die App; eine
+  Transaktion je Schritt, Sperre gegen parallele Worker, Startabbruch bei Fehlern und bei unbekannten
+  (neueren) Einträgen. `python -m pillarz migrate [--dry-run|--status] <modul:objekt>`.
+- `python -m pillarz create-admin <modul:objekt>`: erstes Admin-Konto interaktiv anlegen (nur bei leerer
+  Datenbank, Passwortregeln K-4: 10–200 Zeichen, nicht gleich dem Benutzernamen, kein Platzhalter).
+- pillarz-Migration `0001_initial`: Tabelle `users` (öffentliche Spalten `id, username, name, email,
+  role, active, locale, region, created_at, last_login, session_epoch`) und private Tabellen
+  `pz_sessions`, `pz_flows`, `pz_throttle`, `pz_tokens`, `pz_settings`, `pz_themes`, `pz_log`, `pz_meta`.
+- `pillarz.testing`: `configure()`, `clock` (`freeze`/`advance`), `reset_runtime()` – Grundstock des
+  Testkits.
+- `pillarz.i18n` (ADR 0011): `_`, `ngettext`, `pgettext`, `lazy`, `current_locale()` und der
+  Kontextmanager `use_locale(sprache)`. msgids sind deutsch; Kataloge
+  `<package_dir>/locale/<sprache>/LC_MESSAGES/<name>.po` (Python + Jinja) und `<name>-js.po` (JS)
+  werden ohne `.mo` direkt aus den `.po` geladen. Kette **App → pillarz → Quelltext**: eine App kann
+  pillarz-Texte mit gleicher msgid umformulieren und weitere Sprachen liefern. `fuzzy`/leere Einträge
+  zählen als fehlend. `lazy("…")` liefert ein Objekt, das erst bei `str()`/im Template übersetzt (für
+  JSON vorher `str()`).
+- Sprachwahl je Request: Konto (`users.locale`) → `Accept-Language` → `DEFAULT_LOCALE`, jeweils nur
+  unterstützte Sprachen. Unterstützt sind `de` plus die Sprachen der App-Kataloge – hat die App keine
+  Kataloge, die von pillarz (`en`). Ohne Request (Start, Jobs) gilt die Standardsprache.
+- Jinja: `_`, `gettext`, `ngettext`, `pgettext`, `npgettext` und `{% trans %}` in allen Templates
+  (`newstyle`: Werte als Schlüsselwörter, `{{ _("Hallo %(name)s", name=…) }}` – escaped; ein
+  wörtliches `%` als `%%`).
+- JavaScript: `/static/pillarz/js/i18n.js` mit `t(msgid, params)`, `nt(singular, plural, n, params)`,
+  `pt(kontext, msgid, params)`; Platzhalter `{name}`, bei `nt` ist `{n}` automatisch gesetzt. Die
+  Texte kommen aus dem JSON-Block `<script type="application/json" id="i18n">` der Seite (nur die
+  JS-Domänen der aktuellen Sprache, CSP-konform); Pluralregeln aus dem Katalog, ohne `eval`.
+- `scripts/i18n.sh extract|update|init <sprache>|check` (Babel) – auch als Vorlage für Apps
+  (`PACKAGE_DIR`, `DOMAIN`). Schlüsselwörter: Python `_`, `gettext`, `ngettext`, `pgettext`,
+  `npgettext`, `lazy`, `_l`; JS `t`, `nt`, `pt`; Übersetzerhinweise mit `# TRANSLATORS:`.
+- Englischer Katalog für alle pillarz-Texte (`pillarz/locale/en/LC_MESSAGES/pillarz.po`).
+- `pillarz.testing.check_catalogs(package_dir=None, name=None, *, locales=None)`: Liste fehlender,
+  `fuzzy` oder leerer Übersetzungen, fehlender Pluralformen, unpassender `%(…)`-Platzhalter und
+  fehlender Kataloge (ohne Argumente: die aktuelle App). `pillarz.testing.untranslated()`: sammelt
+  Texte, die in einer anderen Sprache als Deutsch unübersetzt angezeigt wurden.
+- `examples/minimal`: kleinste App mit einer App-Migration.
+- Web-Rahmen (0.1-Paket B): `create_app()` setzt Guard (reine ASGI-Middleware: Request-ID, CSRF über
+  `Sec-Fetch-Site`/`Origin`, Body-Grenzen 1 MiB bzw. Upload-Registry, 411 ohne Länge), das Gate
+  **„default deny“** (globale Dependency: jede Route ohne `Depends(pillarz.web.public)` bzw.
+  `@pillarz.web.public_route` verlangt eine Anmeldung – anonym 401, bei HTML-GET `303 /login?next=…`),
+  Sicherheits-Header auf jede Antwort (`nosniff`, `Referrer-Policy: same-origin`, CSP, HSTS nur wenn alle
+  `PUBLIC_URLS` https sind, `X-Request-ID`, `Vary: Cookie`), Fehler-Handler wie labelz (JSON für `/api/…`
+  und Nicht-GET, Fehlerseite für 403/404, Pfad-Validierung → 404, `UnicodeEncodeError` → 422,
+  `psycopg_pool.PoolTimeout` → 503 mit `Retry-After: 5`), Static mit `no-cache` + ETag unter `/static/`
+  (App) und `/static/pillarz/`, die öffentlichen Seiten `/healthz` und `/themes.css`.
+- Neue Registrierungen an `Pillarz`: `nav(NavItem)`, `csp(**direktiven)` (nur Ergänzungen; `'unsafe-*'`
+  außer `'wasm-unsafe-eval'`, `*`, reine Schemata in `script-src`/`default-src` und Änderungen an
+  `object-src`/`base-uri`/`frame-ancestors` → `ValueError` beim Start), `upload_limit(pfad|re, bytes)`,
+  `no_store(pfad|re)`, `boot(fn)`, `log_source(logger, bereich, label)`, `theme(Theme)`, `icons(pfad)`.
+  Pfadregeln: String mit `/` am Ende = Präfix, sonst exakt; `re.compile(…)` muss den ganzen Pfad treffen.
+- `NavItem(key, href, label, icon=None, order=100, visible=None, badge=None, badge_href=None,
+  badge_label=None)` und `Theme(id, name, light, dark)` mit Feldern.
+- `pillarz.web`: `public`, `public_route`, `render`, `fail`, `csp_extend`, `read_form`, `client_ip`,
+  `base_url`, `current_user`, `is_admin`, `via`, `require_user`, `require_member`, `require_admin`,
+  `require_role(*rollen)`. Bis Paket D gibt es keine Sitzungen: `require_*` antworten anonym immer 401;
+  `throttled`/`hit` sind Hüllen (`NotImplementedError`).
+- `pillarz.text`: `oneline`, `multiline`, `required_line`, `safe_next`, `to_json` (aus labelz).
+- Templates `pillarz/base.html` (Blöcke `title`, `head`, `body_class`, `main_class`, `content`,
+  `footer_extra`, `scripts`, `icons`, dazu `topbar` und `footer`), `pillarz/error.html`,
+  `pillarz/plain.html` (Karte ohne Navigation, Blöcke `card`, `card_class`), Icon-Sprite
+  `pillarz/icons.svg` (Lucide, ISC). Template-Kette App → pillarz; Namen unter `pillarz/…` kommen immer
+  aus pillarz. Kontext: `user`, `is_admin`, `site_name`, `app_name`, `version` (anonym nur ein
+  Cache-Buster), `themes_rev`, `theme_id`, `mode`, `locale`, `region`, `nav`, `nav_items`, `flash`,
+  `boot`, `page`, `help`, `i18n`, `_`/`ngettext`/`pgettext` (Jinja-i18n, newstyle).
+- Static: `/static/pillarz/css/base.css` (alles in `@layer pillarz`, Tokens `--pz-*` aus `--t-*`,
+  Komponenten `.btn`, `.icon-btn`, `.field`, `.banner-*`, `.card`, `.chip`, `.tabs`, `.tbl`, `.menu`,
+  `.dlg`, `.toasts`, `.topbar` …), `js/api.js` (`api`, `upload`, `postQuietly`, `ApiError`), `js/ui.js`
+  (`boot`, `pageData`, `region`, `readJson`, `h`, `icon`, `button`, `iconButton`, `toast`, `showError`,
+  `trapFocus`, `dialog`, `confirmDialog`, `promptDialog`, `field`, `numInput`, `readNum`, `selectEl`,
+  `checkbox`, `parseNum`, `fmtNum`, `fmtNumber`, `fmtDate`, `relTime`, `debounce`, `closeMenu`,
+  `menuIsOpen`, `attachMenu`, `menuButton`), `js/i18n.js` (`t`, `nt`, `pt`), `favicon.svg`.
+- Themes: labelz' fünf eingebaute (Papier, Wald, Meer, Schiefer, Beere) + `pz.theme()` + eigene aus
+  `pz_themes`; `/themes.css` nur aus geprüften Hex-Werten, Akzentschrift nach WCAG-Kontrast.
+- Protokoll: Einträge der Logger `pillarz` und `<name>` ab INFO in `pz_log`, mit `request_id`,
+  `actor_id` und `ip` aus dem Request (K-13); `extra={"pz_actor": id}` setzt das Konto selbst.
+  Aufbewahrung `LOG_RETENTION_DAYS` (neu, Standard 90) und höchstens 20 000 Einträge (K-14).
+- `pillarz.testing.route_audit(app)` (jede nicht öffentliche Route anonym → 401/303→`/login`/404,
+  dazu Routen auf von pillarz belegten URLs und doppelte Routen) und `assert_security_headers(resp)`.
+- `tests/browser_smoke.py`: manueller Browser-Smoke mit Playwright (Konsolen-/CSP-Fehler, Überlauf bei
+  360 px, Screenshots); `playwright` steht in `requirements-dev.txt`.
+- i18n im Web-Rahmen (Paket C in B): der Guard setzt die Sprache je Request – vor CSRF/Body-Prüfung aus
+  `Accept-Language`, nach der Identität mit der Kontosprache (`user["locale"]`) – und setzt sie bewusst
+  nicht zurück, damit auch der 500er-Handler in der Sprache des Requests antwortet. Alle Templates
+  bekommen `_`, `gettext`, `ngettext`, `pgettext`, `npgettext`, `{% trans %}` und `current_locale()`;
+  `#i18n` enthält die JS-Texte der Sprache (`{"locale", "plural", "messages"}`). Kataloge werden beim
+  Start geladen (kaputte `.po` → Startabbruch). Englische Texte für alle Seiten und Meldungen aus B.
+- **Protokoll in der Standardsprache:** `pz_log`-Einträge stehen immer in `DEFAULT_LOCALE`, nicht in
+  der Sprache des auslösenden Requests. Log-Texte als `lazy("…")` mit `%`-Argumenten loggen
+  (`log.warning(lazy("Import von %s fehlgeschlagen"), name)`) – dann sind sie extrahierbar, und der
+  Protokoll-Handler übersetzt sie beim Schreiben unter `use_locale(None)`. Andere Handler (Konsole)
+  formatieren in der aktuellen Sprache. `Config.warnings` sind weiterhin `str` mit dem deutschen
+  Quelltext und werden beim Protokollieren übersetzt.
+- `tests/browser_smoke.py --locales de,en` (Standard): je Sprache `<html lang>`, `#i18n`-Block und
+  Übersetzung durch `i18n.js` unter der CSP.
+- `pillarz.db.requires_fk_off` (Dekorator für Migrationsschritte) und
+  `pillarz.db.rebuild_table_sqlite(conn, table, create_sql, columns=None)` (ADR 0003): Tabellenumbau auf
+  SQLite nach dem 12-Schritte-Verfahren. Markierte Schritte laufen auf SQLite mit
+  `PRAGMA foreign_keys = OFF` (vor `BEGIN` gesetzt) und `PRAGMA foreign_key_check` vor dem Commit –
+  Verstöße rollen zurück (`MigrationError`). Ohne die Markierung verweigert `rebuild_table_sqlite` den
+  Umbau, weil `DROP TABLE` sonst `ON DELETE CASCADE` in Kindtabellen auslöst. Auf PostgreSQL hat die
+  Markierung keine Wirkung; `rebuild_table_sqlite` gibt es dort nicht (`ALTER TABLE` nutzen).
+- `pillarz.testing.is_test_dir(pfad)`.
+- Beim Start: Fehler im Protokoll, wenn es Konten, aber kein aktives Admin-Konto gibt und
+  `OIDC_ADMIN_GROUPS` leer ist (Aussperrung nach der Übernahme einer Datenbank sichtbar machen).
+- **Seiten ohne Rahmen** (P-98): `render(request, template, page=…, chrome=False)` mit einem Template,
+  das `pillarz/bare.html` erweitert (Blöcke `title`, `head`, `body_class`, `content`, `scripts`; JSON
+  `#page`, `#i18n`; `data-theme`/`data-mode`/`data-version` am `<html>`). Gleiche Header und CSP wie
+  jede Seite, aber ohne Navigation, Badges, Topbar, Fuß, Flash, Toasts, Hilfe, `#boot` und ohne
+  pillarz-CSS/-JS (`base.css` bei Bedarf selbst im Block `head`). Falscher Rahmen (`base.html` mit
+  `chrome=False`, `bare.html` ohne, gar kein Rahmen mit `chrome=False`) → `RuntimeError` beim Rendern.
+  Beispiel: `/print` in `examples/minimal` (auch im Browser-Smoke).
+- **Protokoll: App-Quelle** (P-107): Logger unter `<name>` ohne eigene `pz.log_source()`-Zuordnung
+  landen in der Quelle `<name>` (Anzeigename = `title`) statt in `system`; bildet die App `<name>`
+  selbst ab, gilt ihre Zuordnung.
+- `pz.public_mount(pfad)`: eine eingehängte Unter-App (`app.mount`) ohne Anmeldung erreichbar machen.
+- **WebSockets** (FastAPI-`@router.websocket`): Gate und Guard gelten auch dort – `Origin` muss zum
+  `Host` passen (fehlender `Origin` = kein Browser, erlaubt), Identität wie bei HTTP
+  (`websocket.state.user`), ohne Anmeldung bzw. bei fremdem Origin Schließen mit 1008. `public`
+  funktioniert wie bei HTTP-Routen.
+- `HEAD` wird für alle Routen wie `GET` beantwortet (ohne Inhalt), z. B. `HEAD /healthz`.
+- `pillarz.testing.flush_log()`: wartet, bis das Protokoll geschrieben ist (vor dem Lesen von `pz_log`).
+- `route_audit()` prüft WebSocket-Routen (anonym → 1008) und meldet Mounts (außer Static und
+  `pz.public_mount`), `Host`- und Starlette-Routen (`Route`/`WebSocketRoute`), an denen der Gate nicht
+  läuft. Eingebundene Router werden mit der ganzen Kette ausgewertet.
+
+### Changed
+- **`pillarz.testing.configure()` erzwingt ein frisches temporäres `DATA_DIR`** (`<tmp>/pillarz-test-*`,
+  ein gesetztes `DATA_DIR` wird überschrieben, `DB_PATH` entfernt) und leert `POSTGRES_*` – außer bei
+  `PZ_TEST_PG=1`. Apps, die ihre Tests gegen PostgreSQL fahren, setzen `PZ_TEST_PG=1` und eine
+  Datenbank, deren Name `test` als Wortteil trägt (`labelz_test`, `pillarz_test_…`).
+  `pillarz.db.reset()` verweigert sonst (SQLite: Datei außerhalb eines Testverzeichnisses).
+  Unterprozesse eines Testlaufs übernehmen das Verzeichnis des Elternprozesses.
+- `python -m pillarz migrate --status|--dry-run` legen keine fehlende SQLite-Datei mehr an (Meldung,
+  alle Schritte offen); `migrations.status()`/Trockenlauf ohne Datenbank → `MigrationError`.
+- Wartet eine Migration auf SQLite länger als 120 s auf die Dateisperre, gibt es einen
+  `MigrationError` mit klarer Meldung statt `sqlite3.OperationalError`.
+- `.secret_key` entsteht bei mehreren gleichzeitig startenden Prozessen genau einmal (Temp-Datei 0600 +
+  `os.link`); eine für Gruppe/andere lesbare Schlüsseldatei ergibt eine Warnung.
+- **Protokoll schreibt im Hintergrund:** der Handler ist ein `QueueHandler`, ein eigener Thread schreibt
+  die Einträge stapelweise. Loggen blockiert weder den Event-Loop noch eine offene Transaktion
+  (vorher auf SQLite 5 s Sperre, verlorener Eintrag und danach „database is locked“; auf PG eine zweite
+  Pool-Verbindung). Einträge sind unabhängig von der Transaktion des Aufrufers (bleiben bei Rollback).
+  Beim Herunterfahren wird die Warteschlange geleert; Tests lesen `pz_log` nach `testing.flush_log()`.
+- Protokoll-Obergrenze 20 000 Einträge gilt getrennt für `auth`/`admin` und alle übrigen Quellen.
+- `log_once` drosselt nach festen Schlüsseln (Routen-Template statt Pfad) und verdrängt bei Überlauf
+  die ältesten Schlüssel, statt alle zu vergessen.
+- HTML-GET mit unerwartetem Fehler bekommt die Fehlerseite (500) statt JSON.
+- Templates: `autoescape` für alle Templates (unabhängig von der Endung).
+- Body-Grenzen gelten für alle Methoden (auch `GET`/`HEAD`/`OPTIONS`); ein `Content-Length` ohne
+  gültige Zahl ergibt 411.
+
+### Fixed
+- Validatoren (Benutzername, Mail, SQL-Bezeichner, Migrationsnamen, App-/Navigations-/Theme-Kennungen,
+  Farben, CSP-Quellen, Sprachcode) ließen ein abschließendes `\n` durch (`re.match` mit `$`) – jetzt
+  `fullmatch`.
+- PostgreSQL-Pool: kam nach einer toten Verbindung kein Ersatz (`PoolTimeout`), wurde die tote
+  Verbindung ein zweites Mal an den Pool zurückgegeben (bei gesunden Verbindungen ein `ValueError`, der
+  den `PoolTimeout` überdeckt).
+- Ersteinrichtung auf SQLite mit mehreren Prozessen: „database is locked“ → `SetupClosed`.
+- `scripts/release.sh`: mit `SKIP_TESTS=1` fehlte der Interpreter für den Build-Schritt.
+
+### Security
+- `SECRET_KEY` aus der Umgebung: bekannte Vorlagenwerte (`replace-with-…`, `changeme`, `example` …) und
+  Werte mit weniger als 10 verschiedenen Zeichen brechen den Start ab.
+- Passwörter mit einzelnen UTF-16-Surrogaten lehnt `password_problem` ab (nicht kodier-/hashbar).
+- CI: Versionsnummer aus dem Tag erst gegen PEP 440 prüfen und nie in Python-Quelltext einsetzen;
+  PyPI-Token (`PYPI_TOKEN`) nur über die Umgebung an `twine`, nie in der Kommandozeile;
+  probe-install installiert von pypi.org und vergleicht den Hash dort mit dem im publish-Job
+  hochgeladenen Wheel; pip-audit auch über `requirements-dev.txt`; kein Cache-Speichern aus
+  Pull-Requests.
+- Review Paket B: Mounts, `Host`- und Starlette-Routen liefen am Gate vorbei – der Guard weist anonyme
+  Anfragen an sie jetzt ab (401 bzw. `303 /login`), außer pillarz' Static und `pz.public_mount()`.
+- `public` zählt nur noch als direkte Abhängigkeit der Route bzw. eines Routers der Kette – eine
+  Hilfs-Dependency, die intern `Depends(public)` nutzt, macht Routen nicht mehr öffentlich. Umgekehrt
+  wird `public` an verschachtelt eingebundenen Routern (`include_router(…, dependencies=[…])`) erkannt.
+- WebSocket-Verbindungen liefen am Guard vorbei (kein Origin-Check, keine Identität).
+- CSP-Ergänzungen: `javascript:` überall abgelehnt; `worker-src`/`child-src` nur `'self'`/`blob:`; Hosts
+  bei reinem HTTPS nur `https://` (`connect-src` zusätzlich `wss://`), `ws(s)://` nur in `connect-src`;
+  Hashes in `style-src` abgelehnt (sie schalteten `'unsafe-inline'` still ab).
+- Pfade in Logzeilen einzeilig und gekürzt (`oneline(…)[:200]`, keine Log-Injection auf stdout).
+- `PoolTimeout`/`HTTPException` aus der Identitätsauflösung im Guard → 503 mit `Retry-After` bzw. die
+  passende Fehlerantwort statt 500.
+- Template-Namensraum: `./pillarz/…` und ähnliche Schreibweisen umgingen den Schutz der
+  pillarz-Templates; ein App-Ordner `templates/pillarz/` bricht den Start jetzt ab.
+
+### Upgrade
+- **Default deny:** Routen einer App sind ab 0.1-Paket B ohne Anmeldung gesperrt. Öffentliche Routen
+  (Webhooks, Startseite ohne Login …) brauchen `Depends(pillarz.web.public)` bzw. `@public_route`;
+  `pillarz.testing.route_audit(app)` im Testlauf der App zeigt vergessene Stellen.
+- App-Ordner `static/pillarz/` ist verboten (`create_app()` bricht ab); `static/logo.svg` und
+  `static/favicon.svg` der App ersetzen Marke bzw. Favicon von pillarz.
+- App-Ordner `templates/pillarz/` ist ebenso verboten (`create_app()` bricht ab).
+- `render(**ctx)` lehnt von pillarz belegte Kontextschlüssel ab (`user`, `boot`, `nav_items`, `i18n`,
+  `version`, `help`, `flash`, `_` … → `ValueError`).
+- Eigene Mounts (`app.mount`) sind anonym gesperrt; öffentliche Unter-Apps mit `pz.public_mount(pfad)`
+  freigeben. `app.add_route()` statt FastAPI-Routen meldet `route_audit()`.
+- Tests, die `pz_log` lesen, vorher `pillarz.testing.flush_log()` aufrufen.
+- Eine vorhandene `users`-Tabelle (z. B. labelz 0.12) wird übernommen: `0001_initial` ergänzt fehlende
+  Spalten (`role`, `email_confirmed`, `locale`, `region`, `updated_at` …), setzt `email_confirmed = 1`
+  für Konten mit Adresse und `pz_meta.setup_done`, wenn es Konten gibt. Datenumbau (`is_admin` →
+  `role`, `oidc_links` → `pz_tokens`, `themes` → `pz_themes`, `meta.settings` → `pz_settings`) ist
+  Sache einer App-Migration, die nach `0001_initial` läuft (Architektur §5.4).
+- Installation in einer App: normal von pypi.org, exakter Pin mit Hash (`pillarz==X.Y.Z
+  --hash=sha256:…` im Lock der App), Installation mit `--require-hashes` – kein zusätzlicher Index, kein
+  Token im Image-Build.