fix: Skripte lagen ohne Ausfuehrungsrecht im Repository

Die Anleitung sagt "./scripts/update.sh" - auf Linux kam dort "Permission denied". Die drei .sh-Dateien lagen mit Modus 644 statt 755 im Index. Ursache ist der Entwicklungsrechner: Unter Windows steht core.filemode=false, git nimmt ein fehlendes Ausfuehrungsrecht dort gar nicht wahr. Gemeldet hat es der Betrieb, nicht der Bau. Wer von 1.1.0 oder aelter kommt, braucht einmalig "bash scripts/update.sh" - das alte Skript ist ja noch das nicht ausfuehrbare. Steht jetzt in README und Installationsanleitung. Zusaetzlich setzt update.sh nach dem Umschalten selbst ein chmod +x auf scripts/*.sh. Das faengt den Fall ab, dass jemand Dateien von Hand kopiert und das Recht dabei verliert - genau so kam man bisher an dieses Skript, bevor es in der laufenden Fassung existierte. Neu: tests/skripte.test.ts prueft nicht Verhalten, sondern Verpackung - Ausfuehrungsrecht im Index, Shebang, scripts/ im Docker-Abbild, die Sicherungsskripte in der Compose-Datei. Es ist der zweite Fehler dieser Art (vorher fehlte scripts/ ganz im Abbild, 1.0.1); beide Male war der Code richtig und kein Test sah hin, wie die Dateien beim Server ankommen. Gegenprobe gemacht: mit zurueckgesetztem Recht schlaegt er fehl und nennt die Datei. Nebenbei aufgefallen: scripts/version.mjs datierte in UTC. Diese Fassung waere um 00:08 deutscher Zeit auf den Vortag datiert worden. Rechnet jetzt in Europe/Berlin.
feat: Anmelden mit Passkey
2026-08-23 00:13:05 +02:00 · 2026-08-22 18:44:56 +02:00 · 2026-08-22 15:10:40 +02:00 · 2026-08-22 15:09:01 +02:00 · 2026-08-22 14:36:18 +02:00 · 2026-08-22 14:22:38 +02:00
38 changed files with 4120 additions and 151 deletions
@@ -19,18 +19,38 @@ AUTH_URL=http://localhost:3000
 # Hinter einem Reverse Proxy auf true setzen.
 AUTH_TRUST_HOST=true

-# --- Erreichbarkeit ---------------------------------------------------------
-# Auf welcher Adresse und welchem Port horcht die Anwendung?
+# --- Erreichbarkeit: HIER MUSST DU DICH ENTSCHEIDEN -------------------------
 #
-# Proxy auf DEMSELBEN Server:  127.0.0.1 (Standard, nichts zu tun)
-# Proxy auf einem ANDEREN:     die Adresse des privaten Netzes bzw. des
-#                              WireGuard-Tunnels, z.B. 10.0.0.5
+# Auf welcher Adresse soll die Anwendung erreichbar sein? Das haengt davon
+# ab, WO dein Reverse Proxy laeuft. Waehl genau eine Zeile aus:
 #
-# 0.0.0.0 nur, wenn eine Firewall den Port ausschliesslich fuer die IP des
-# Proxy-Servers oeffnet. Die Anwendung beendet kein TLS.
+#   Proxy auf DEMSELBEN Server
+#       APP_BIND=127.0.0.1
+#       Von aussen kommt niemand heran, nur der Proxy nebenan. Sicherste
+#       Variante - aber ein Proxy auf einem anderen Rechner erreicht die
+#       Anwendung damit NICHT.
+#
+#   Proxy auf einem ANDEREN Server, privates Netz oder WireGuard vorhanden
+#       APP_BIND=10.0.0.5        <- die Adresse DIESES Servers in dem Netz
+#       Erste Wahl, wenn der Proxy woanders steht.
+#
+#   Proxy auf einem ANDEREN Server, kein privates Netz
+#       APP_BIND=0.0.0.0
+#       Nur zusammen mit einer Firewallregel, die den Port ausschliesslich
+#       fuer die IP des Proxy-Servers oeffnet:
+#           ufw allow from <IP-des-Proxys> to any port 3000 proto tcp
+#           ufw deny 3000/tcp
+#
+# Zwischen Proxy und Anwendung laeuft unverschluesseltes HTTP - die
+# Anwendung beendet kein TLS. Dieser Weg darf nie durchs offene Netz gehen.
+# Einzelheiten: docs/INSTALLATION.md, Schritt 7.
 APP_BIND=127.0.0.1
 APP_PORT=3000

+# Die Konsole des mitgelieferten Objektspeichers. Nur noetig, wenn auf dem
+# Server schon etwas auf 9001 laeuft.
+MINIO_KONSOLE_PORT=9001
+
 # --- Anwendungsseitige Feldverschluesselung ---------------------------------
 # AES-256-GCM. 32 Bytes, base64. OHNE DIESEN SCHLUESSEL SIND DIE VERSCHLUESSELTEN
 # FELDER UNWIEDERBRINGLICH VERLOREN - unbedingt getrennt vom Backup sichern!
@@ -26,6 +26,298 @@ Wiederherstellung*.

 _Noch nichts._

+## [1.1.1] – 2026-08-23
+
+### Behoben
+
+- **`./scripts/update.sh` endete in „Permission denied".** Die
+  Shell-Skripte lagen ohne Ausführungsrecht im Repository (Modus 644 statt
+  755). Die Anleitung sagt `./scripts/update.sh` — auf Linux ging genau
+  das nicht.
+
+  Ursache ist der Entwicklungsrechner: Unter Windows steht
+  `core.filemode=false`, dort merkt git von einem fehlenden
+  Ausführungsrecht nichts. Aufgefallen ist es erst auf dem Server.
+
+  **Wer von 1.1.0 oder älter kommt**, braucht einmalig den Umweg — das
+  alte Skript ist ja noch das nicht ausführbare:
+
+  ```bash
+  bash scripts/update.sh
+  ```
+
+  Danach stimmt das Recht, und der Punktschrägstrich funktioniert.
+
+- **`update.sh` setzt das Recht nach dem Umschalten selbst.** Wer Dateien
+  von Hand kopiert hat — etwa um an das Skript zu kommen, bevor es in der
+  laufenden Fassung existierte —, verliert es dabei. Ein `chmod +x` nach
+  dem Umschalten fängt das ab.
+
+- **Das Versionsskript datierte in UTC.** Eine Veröffentlichung nach
+  22 Uhr deutscher Sommerzeit bekam im Changelog das Datum des Vortages —
+  diese Fassung hier war der erste Fall. Es rechnet jetzt in
+  `Europe/Berlin`, wie alles andere in dieser Anwendung auch.
+
+### Geprüft
+
+- Vier neue Prüfungen (`tests/skripte.test.ts`) sehen sich nicht das
+  Programm an, sondern die **Verpackung**: Liegt jedes `.sh` ausführbar im
+  Index? Hat es eine Shebang-Zeile? Kommt `scripts/` ins Docker-Abbild?
+  Sind die Sicherungsskripte in der Compose-Datei eingehängt?
+
+  Das ist der zweite Fehler dieser Art — vorher fehlte `scripts/` ganz im
+  Abbild (1.0.1). Beide Male war der Code richtig und kein Test schlug an,
+  weil keiner hinsah, wie die Dateien beim Server ankommen. Jetzt tut es
+  einer. Die Gegenprobe ist gemacht: Mit zurückgesetztem Recht schlägt er
+  fehl und nennt die Datei.
+
+## [1.1.0] – 2026-08-22
+
+### Hinzugefügt
+
+- **Anmelden mit Passkey.** Auf der Anmeldeseite steht jetzt unter dem
+  Formular ein zweiter Weg: *Mit Passkey anmelden*. Ein Fingerabdruck, ein
+  Blick in die Kamera oder die Geräte-PIN — keine E-Mail, kein Passwort,
+  kein abgetippter Code.
+
+  **Der Passkey ersetzt den zweiten Faktor, er kommt nicht zusätzlich.**
+  Das ist kein Nachlassen: Ein Passkey verlangt den Besitz des Geräts
+  *und* dessen Entsperrung, das sind dieselben zwei Faktoren wie vorher.
+  Die Anwendung fordert die Nutzerverifikation ausdrücklich an und weist
+  eine Antwort ohne sie zurück. Ein Gerät, das auf blosses Antippen hin
+  signiert, kommt nicht herein.
+
+  In einem Punkt ist er dem bisherigen Weg sogar überlegen: Ein Passkey
+  ist an die Adresse gebunden, unter der er eingerichtet wurde. Auf einer
+  nachgebauten Anmeldeseite funktioniert er nicht — und Phishing ist der
+  übliche Weg, an einen TOTP-Code zu kommen.
+
+  **Die Authenticator-App muss trotzdem eingerichtet sein**, bevor sich
+  ein Passkey anlegen lässt. Ein Passkey hängt an einem Gerät. Ginge das
+  verloren und wäre er der einzige Weg hinein, käme niemand mehr an die
+  Akte — und darin stehen Unterlagen, die eine betreute Person braucht.
+  Der Passkey ist die bequeme Tür, nicht die einzige.
+
+  Verwaltet werden sie unter **Mein Konto → Passkeys**: einrichten,
+  benennen, entfernen. Die Liste zeigt, wann ein Gerät zuletzt benutzt
+  wurde und ob der Schlüssel gesichert ist (iCloud, Google, Bitwarden)
+  oder nur auf diesem einen Gerät liegt. Einrichten und Entfernen stehen
+  im Protokoll, jede Anmeldung nennt den verwendeten Passkey namentlich.
+
+- **Bestätigen mit Passkey.** Export, endgültiges Löschen und die
+  Benutzerverwaltung verlangen eine frische Anmeldung. Auch die geht jetzt
+  mit dem Passkey. Geprüft wird zusätzlich, dass er zum angemeldeten
+  Zugang gehört — sonst liesse sich mit dem eigenen Finger eine fremde,
+  offen stehende Sitzung freischalten. Genau der Fall, gegen den diese
+  Zwischenfrage gebaut ist.
+
+### Zu beachten
+
+- **Passkeys brauchen `https`.** Der Browser gibt das Verfahren nur in
+  einem sicheren Kontext frei. Läuft die Anwendung ohne TLS, erscheint der
+  Knopf gar nicht erst, statt beim Klick mit einer kryptischen Meldung
+  abzubrechen.
+
+- **`AUTH_URL` muss stimmen — jetzt noch mehr als vorher.** Aus ihr wird
+  die Kennung abgeleitet, an die der Authenticator den Schlüssel bindet.
+  Steht dort eine andere Adresse als die im Browser, lässt sich zwar ein
+  Passkey einrichten, aber nie wieder verwenden.
+
+  **Ein Wechsel der Domain macht alle Passkeys unbrauchbar.** Das ist
+  keine Panne, sondern der Phishingschutz. Nach einem Umzug richtet man
+  sie neu ein; die Anmeldung mit Passwort und Code bleibt währenddessen
+  offen.
+
+- **Eine Datenbank-Migration ist nötig** (`20260822160000_passkey_anmeldung`).
+  Sie läuft beim Start des Behälters automatisch mit. Bestehende Zugänge
+  sind nicht betroffen: Ohne eingerichteten Passkey ändert sich nichts.
+
+### Geprüft
+
+- 21 neue Prüfungen (`tests/passkey.test.ts`), vor allem für die Herleitung
+  von Kennung und Herkunft aus `AUTH_URL`: Port, Schrägstrich am Ende,
+  Unterdomain, `http` gegen `https`, `localhost`. Das ist die Stelle, an
+  der eine Installation still kaputtginge — dieselbe Fehlerklasse wie
+  seinerzeit bei `APP_BIND` und `ENC_KEY_V2`.
+- Drei End-to-End-Tests gegen einen echten Browser (`e2e/passkey.spec.ts`),
+  mit Chromiums virtuellem Authenticator: einrichten, abmelden, mit Passkey
+  anmelden, Benutzung vermerkt, entfernen. Dazu die Bestätigung vor dem
+  Vollexport und der Fall, dass ein Gerät ohne Nutzerverifikation nicht
+  hereinkommt.
+
+## [1.0.5] – 2026-08-22
+
+### Hinzugefügt
+
+- **`scripts/update.sh`** — aktualisiert die Anwendung mit einem Befehl.
+
+  ```bash
+  ./scripts/update.sh              # auf die neueste Fassung
+  ./scripts/update.sh --pruefen    # nur nachsehen, nichts ändern
+  ./scripts/update.sh v1.2.0       # auf eine bestimmte Fassung
+  ```
+
+  Es nimmt die Schritte ab, die man von Hand vergisst: Sicherung
+  anstoßen und bei Misserfolg **abbrechen**, den Changelog zwischen altem
+  und neuem Stand anzeigen, umschalten, neu bauen, warten bis die
+  Anwendung antwortet, **die beiden SQL-Skripte ausführen** und zum
+  Schluss prüfen, ob wirklich die neue Fassung läuft.
+
+  Zwei Eigenschaften, die dabei zählen:
+
+  **Bis zur Rückfrage wird nichts verändert.** Bricht etwas vorher ab —
+  Server nicht erreichbar, falsche Versionsangabe — findest du alles so
+  vor wie zuvor. Kein Halbzustand.
+
+  **Eigene Änderungen an versionierten Dateien blockieren nicht.** Im
+  Betrieb passt man die `docker-compose.yml` an, bis etwas läuft; genau
+  diese Anpassungen sind später oft schon eingearbeitet. Das Skript legt
+  sie vor dem Umschalten mit `git stash` beiseite und sagt, wie man sie
+  zurückholt. Mit `--verwerfen` werden sie stattdessen weggeworfen. Die
+  `.env` bleibt immer unangetastet — sie ist nicht versioniert.
+
+  Schlägt der Bau fehl, nennt das Skript den Weg zurück auf den
+  vorherigen Stand.
+
+### Behoben
+
+- **Der Port der MinIO-Konsole ließ sich nicht ändern.** Er stand fest auf
+  `9001`; lief dort schon etwas, startete der ganze Stapel nicht
+  (`port is already allocated`). Jetzt über `MINIO_KONSOLE_PORT` in der
+  `.env` einstellbar — dieselbe Möglichkeit, die `APP_PORT` schon hatte.
+
+## [1.0.4] – 2026-08-22
+
+### Behoben
+
+- **Die Ersteinrichtung ließ sich nicht abschließen.** Schritt 3 meldete
+  „Bitte prüfe die markierten Felder" — markierte aber keines. Man kam an
+  dieser Stelle nicht weiter.
+
+  Ursache: Das kurze Formular der Ersteinrichtung schickt neun Felder, das
+  vollständige unter *Stammdaten* alle. Beide gehen durch dasselbe Schema,
+  und die optionalen Felder waren zwar `nullable`, aber nicht `optional` —
+  ein Feld, das gar nicht abgeschickt wurde, ist `undefined`, nicht
+  `null`. Beanstandet wurden also zwei Dutzend Felder, die auf dem
+  Bildschirm nie standen.
+
+- **Eine Meldung ohne zugehöriges Feld kann nicht mehr unsichtbar
+  bleiben.** Beanstandet die Prüfung ein Feld, das das Formular gar nicht
+  gesendet hat, sagt die Anwendung das jetzt ausdrücklich und schreibt es
+  ins Serverlog — statt es als Eingabefehler auszugeben, den niemand
+  finden kann. Das ist ein Fehler im Programm, und er soll auch so
+  aussehen.
+
+- **Eine betreute Person ließ sich nicht endgültig löschen.** Beim Löschen
+  setzt Postgres den Verweis im Audit-Log auf NULL (`ON DELETE SET NULL`),
+  und genau dieses UPDATE hat der Unveränderlichkeits-Trigger abgewiesen.
+  Betroffen war damit auch das Leeren des Papierkorbs nach 30 Tagen und
+  das Entfernen des Demofalls.
+
+  Der Trigger erlaubt jetzt genau eine Ausnahme: das Nullen der beiden
+  Fremdschlüssel `betreuteId` und `userId`. Jede andere Änderung bleibt
+  verboten, auch das Setzen eines Fremdschlüssels auf einen **anderen**
+  Wert. Der Nachweis bleibt vollständig — Zeitpunkt, Aktion, Bezeichnung,
+  die verschlüsselte Änderung und die Momentaufnahmen von Name und
+  E-Mail sind unberührt. Es verschwindet nur der Verweis auf einen
+  Datensatz, den es nicht mehr gibt.
+
+  **Beim Update nötig:** das SQL-Skript erneut ausführen, sonst bleibt der
+  alte Trigger stehen.
+
+  ```bash
+  docker compose exec app node node_modules/prisma/build/index.js db execute     --schema prisma/schema.prisma --file prisma/sql/audit-schutz.sql
+  ```
+
+### Geprüft
+
+- Sieben neue Tests (`tests/stammdaten.test.ts`) prüfen genau die
+  Formularinhalte der Ersteinrichtung, dazu das vollständige Formular mit
+  leeren Feldern und die weiterhin verlangten Pflichtangaben.
+- Der Ablauf ist zusätzlich im Browser durchgespielt worden: Anmeldung,
+  zweiter Faktor, Schritt 3, Landung auf dem Dashboard — und die daraus
+  abgeleiteten Pflichtfristen samt Ausschlussfrist für die
+  Aufwandspauschale.
+- Der geänderte Trigger ist gegen eine laufende Datenbank geprüft:
+  Löschen gelingt, Fälschen und Löschen von Einträgen scheitert weiterhin.
+
+## [1.0.3] – 2026-08-22
+
+Keine Änderung am Programm — nur an der Konfigurationsvorlage und der
+Anleitung. Ein Neubau des Abbilds ist nicht nötig.
+
+### Behoben
+
+- **`.env.example` band die Anwendung stillschweigend an `127.0.0.1`.**
+  Der Wert stand dort als fertig ausgefüllte Zeile zwischen lauter anderen
+  fertigen Zeilen. Wer die Datei kopiert hat und seinen Reverse Proxy auf
+  einem **anderen** Server betreibt, kam nicht an die Anwendung heran —
+  und der Fehler sah aus, als läge es am Proxy.
+
+  Jetzt steht dort eine Entscheidung mit drei benannten Fällen statt eines
+  Vorgabewerts. Der sichere Standard bleibt `127.0.0.1`; er wird nur nicht
+  mehr als „schon erledigt" präsentiert.
+
+  Für bestehende Installationen genügt eine Zeile in der `.env`:
+
+  ```bash
+  APP_BIND=10.0.0.5      # Adresse, über die der Proxy diesen Server erreicht
+  docker compose up -d
+  ```
+
+### Geändert
+
+- **`docs/INSTALLATION.md`** nennt `APP_BIND` jetzt schon in Schritt 3, wo
+  die `.env` ausgefüllt wird — nicht erst in Schritt 7, wo der Proxy
+  drankommt. Dazu ein eigener Abschnitt in der Fehlersuche: „Der Proxy
+  erreicht die Anwendung nicht", mit den zwei `curl`-Proben, die den
+  Unterschied zwischen falscher Bindeadresse und Firewall zeigen.
+
+## [1.0.2] – 2026-08-22
+
+### Behoben
+
+- **Die Einrichtung des zweiten Faktors brach mit einem Serverfehler ab**
+  („Application error: a server-side exception has occurred"). Im
+  Serverlog stand `Umgebungsvariable ENC_KEY_V2 fehlt` — obwohl niemand
+  einen zweiten Schlüssel wollte.
+
+  Ursache: `docker-compose.yml` reicht `ENC_KEY_V2` immer an den Behälter
+  durch, mit **leerem Wert**, wenn in der `.env` keiner steht. Die
+  Anwendung erkannte Schlüssel aber am Variablennamen statt am Inhalt,
+  fand also ein leeres `ENC_KEY_V2` und brach ab. Leere
+  Schlüsselvariablen werden jetzt übersprungen.
+
+  Betroffen war jede Stelle, die verschlüsselte Felder schreibt oder
+  liest — also praktisch alles außer der reinen Anmeldung. Die Anmeldung
+  ging durch, weil sie ohne Verschlüsselung auskommt; der Fehler trat
+  deshalb erst auf der nächsten Seite auf.
+
+- **Die Meldung beim Schlüsselwechsel** nennt jetzt, welche Versionen
+  tatsächlich vorhanden sind, und die richtige Reihenfolge: erst den
+  neuen Schlüssel eintragen, dann `ENC_KEY_AKTIV` umstellen.
+
+### Hinzugefügt
+
+- **`scripts/anmeldung-pruefen.mjs`** — beantwortet die Frage, warum eine
+  Anmeldung nicht klappt. Das Formular sagt bewusst nicht, woran es lag,
+  sonst ließe sich daran ablesen, welche Adressen es gibt. Auf dem Server
+  darf man es wissen: Jeder Versuch wird mit Grund protokolliert, und das
+  Skript liest ihn vor — dazu den Zustand des Zugangs, den Stand der
+  Login-Sperre und die eingestellte `AUTH_URL`.
+
+  ```bash
+  docker compose exec app node scripts/anmeldung-pruefen.mjs deine@adresse.de
+  ```
+
+  Es ändert nichts, es liest nur.
+
+### Geprüft
+
+- Sieben neue Tests (`tests/umgebung.test.ts`) decken die
+  Schlüsselauswertung ab, darunter genau die Konstellation aus dem
+  Fehlerbericht: gesetztes `ENC_KEY_V1`, leeres `ENC_KEY_V2`.
+
 ## [1.0.1] – 2026-08-22

 ### Behoben
@@ -219,6 +511,12 @@ Was davon wann angegangen wird, steht in [`docs/ROADMAP.md`](docs/ROADMAP.md).

 ---

-[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.1...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.1...HEAD
+[1.1.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.0...v1.1.1
+[1.1.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.5...v1.1.0
+[1.0.5]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.4...v1.0.5
+[1.0.4]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.3...v1.0.4
+[1.0.3]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.2...v1.0.3
+[1.0.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.1...v1.0.2
 [1.0.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.0...v1.0.1
 [1.0.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/releases/tag/v1.0.0
@@ -177,12 +177,28 @@ existiert.
 ### Aktualisieren

 ```bash
-git pull
-docker compose up -d --build
+./scripts/update.sh
 ```

-Die Migrationen laufen beim Start des Anwendungsbehälters mit. **Vorher ein
-Backup anstoßen** (siehe unten) — eine Migration lässt sich nicht zurückrollen.
+> **Kommst du von 1.1.0 oder älter?** Dort lag `update.sh` ohne
+> Ausführungsrecht im Repository — `./scripts/update.sh` endet dann in
+> „Permission denied". Einmalig hilft:
+>
+> ```bash
+> bash scripts/update.sh
+> ```
+>
+> Ab 1.1.1 ist das Recht gesetzt und der Punktschrägstrich funktioniert.
+
+Das Skript sichert zuerst, zeigt den Changelog zwischen altem und neuem
+Stand, fragt nach, schaltet um, baut neu und führt danach die beiden
+SQL-Skripte aus. Schlägt die Sicherung fehl, wird nicht aktualisiert.
+
+`--pruefen` sieht nur nach, ohne etwas zu ändern. Eigene Änderungen an
+versionierten Dateien werden vor dem Umschalten beiseite gelegt
+(`git stash`), die `.env` bleibt unangetastet.
+
+Einzelheiten und der Weg von Hand: [`docs/INSTALLATION.md`](docs/INSTALLATION.md).

 ---

@@ -287,6 +303,15 @@ entscheiden kann. Was dafür umgesetzt ist:
 - Passwörter mit **Argon2id** (19 MiB, t=2, p=1 — OWASP-Empfehlung).
 - **Zweiter Faktor ist Pflicht** und lässt sich nicht abschalten. TOTP nach
  RFC 6238, kompatibel mit Aegis, 2FAS, Bitwarden, 1Password.
+- **Passkeys** (WebAuthn/FIDO2) als zweiter Anmeldeweg — auch für die
+  erneute Bestätigung vor sensiblen Aktionen. Sie *ersetzen* den zweiten
+  Faktor, statt zu ihm hinzuzukommen: Nutzerverifikation wird verlangt
+  (`userVerification: 'required'`) und serverseitig nachgeprüft, ein
+  Schlüssel ohne sie wird abgewiesen. Damit sind es dieselben zwei
+  Faktoren — Besitz des Geräts und dessen Entsperrung —, nur an die Domain
+  gebunden und deshalb nicht abphishbar. TOTP muss trotzdem eingerichtet
+  sein, bevor sich ein Passkey anlegen lässt: Er hängt an einem Gerät und
+  darf nicht der einzige Weg hinein sein.
 - **Rate-Limiting** am Login, nach E-Mail *und* nach Anschluss. Die Sperre
  wird geprüft, bevor Argon2 überhaupt rechnet.
 - Die Antwortzeit ist auf eine Mindestdauer gestreckt, damit sie nicht
@@ -553,14 +578,17 @@ Fehler, die während des Baus aufgefallen sind.

 ## Stand

-| | |
-|---|---:|
-| Zeilen TypeScript/TSX | 71.051 |
-| Prisma-Modelle | 24 |
-| Seiten | 46 |
-| Unit-Tests (Vitest) | 458 |
-| End-to-End-Tests (Playwright) | 34 |
-| TypeScript-Fehler | 0 |
+| | | nachzuzählen mit |
+|---|---:|---|
+| Zeilen TypeScript/TSX | 72.080 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
+| Prisma-Modelle | 33 | `grep -c '^model ' prisma/schema.prisma` |
+| Seiten | 79 | `find src/app -name page.tsx \| wc -l` |
+| Unit-Tests (Vitest) | 500 | `npm test` |
+| End-to-End-Tests (Playwright) | 37 | `npm run test:e2e` |
+| TypeScript-Fehler | 0 | `npm run typecheck` |
+
+Die Befehle stehen dabei, weil die Zahlen sonst altern, ohne dass es
+jemandem auffällt — bei den Modellen und Seiten war genau das passiert.

 Alle acht Etappen sind umgesetzt. Der Produktionsbuild ist gegen den
 fertigen Standalone-Server geprüft: strenge CSP aktiv, keine
@@ -66,7 +66,10 @@ services:
    ports:
      # Nur an die Loopback-Adresse gebunden. Die Konsole erreichst du
      # ueber einen SSH-Tunnel oder ueber deinen vorhandenen Proxy.
-      - '127.0.0.1:9001:9001'
+      #
+      # Laeuft auf dem Server schon etwas auf 9001, weich in der .env aus:
+      #     MINIO_KONSOLE_PORT=9011
+      - '${MINIO_KONSOLE_BIND:-127.0.0.1}:${MINIO_KONSOLE_PORT:-9001}:9001'
    networks: [intern]

  app:
@@ -91,7 +94,9 @@ services:
      AUTH_URL: ${AUTH_URL:?AUTH_URL fehlt in der .env}
      AUTH_TRUST_HOST: 'true'
      ENC_KEY_V1: ${ENC_KEY_V1:?ENC_KEY_V1 fehlt in der .env - ohne ihn sind die verschluesselten Felder nicht lesbar}
-      ENC_KEY_V2: ${ENC_KEY_V2:-}
+      # Bleibt leer, solange nicht rotiert wird. Die Anwendung ueberspringt
+      # leere Schluesselvariablen - siehe src/lib/env.ts.
+      # ENC_KEY_V2: ${ENC_KEY_V2:-}
      ENC_KEY_AKTIV: ${ENC_KEY_AKTIV:-1}
      INDEX_KEY: ${INDEX_KEY:?INDEX_KEY fehlt in der .env}
      SESSION_MAX_AGE: ${SESSION_MAX_AGE:-1800}
@@ -57,6 +57,10 @@ Anschreiben wieder auf.
 **Zum Schluss:** Geh auf **Fristen** und klicke einmal auf
 *Pflichtfristen ableiten*. Danach stehen deine gesetzlichen Termine drin.

+Und wenn du magst: Richte unter **Mein Konto → Passkeys** einen Passkey
+ein. Dann meldest du dich künftig mit dem Finger an, statt drei Felder
+auszufüllen. Wie das geht, steht gleich im nächsten Abschnitt.
+
 ---

 ## Der Morgen: die Seite „Heute"
@@ -328,6 +332,86 @@ Anwendung jederzeit verlassen. Verlangt eine erneute Anmeldung.

 ---

+## Anmelden mit dem Finger: Passkeys
+
+Drei Felder auszufüllen, nur um kurz eine Frist nachzusehen, ist lästig —
+und lästige Sicherheit wird umgangen. Ein Passkey macht daraus einen
+Handgriff.
+
+### Einrichten
+
+**Mein Konto → Passkeys.** Gib dem Gerät einen Namen, an dem du es später
+wiedererkennst („iPhone", „Laptop Büro"), und klicke auf *Passkey
+einrichten*. Dein Gerät fragt nach Fingerabdruck, Gesicht oder PIN —
+fertig.
+
+Mach das auf **jedem Gerät**, mit dem du arbeitest. Sie stören sich nicht
+gegenseitig.
+
+### Anmelden
+
+Auf der Anmeldeseite steht unter dem Formular *Mit Passkey anmelden*. Ein
+Klick, ein Finger, drin. Keine E-Mail, kein Passwort, kein Code.
+
+### Warum das nicht unsicherer ist
+
+Es sieht nach weniger aus, ist aber dasselbe — zweimal:
+
+| | Bisher | Mit Passkey |
+|---|---|---|
+| Erster Faktor | Passwort (Wissen) | Das Gerät selbst (Besitz) |
+| Zweiter Faktor | Code aus der App (Besitz) | Fingerabdruck, Gesicht oder PIN |
+
+Der entscheidende Zusatz: **Ein Passkey ist an die Adresse gebunden**,
+unter der du ihn eingerichtet hast. Landest du auf einer nachgebauten
+Anmeldeseite, funktioniert er dort schlicht nicht — er lässt sich nicht
+abtippen und nicht weitergeben. Genau das ist der übliche Weg, an einen
+Code aus der Authenticator-App zu kommen.
+
+Ein Gerät, das den Passkey ohne Fingerabdruck oder PIN freigibt, wird
+abgewiesen. Das wäre nur ein Faktor, und dafür ist hier zu viel zu
+verlieren.
+
+### Die Authenticator-App bleibt
+
+Du kannst sie nicht abschaffen, und das ist Absicht. **Ein Passkey hängt
+an einem Gerät.** Geht das Handy in der Donau baden und wäre der Passkey
+der einzige Weg hinein, käme niemand mehr an die Akte — auch der Bezirk
+nicht, auch das Gericht nicht.
+
+Deshalb: erst Authenticator-App und Wiederherstellungscodes, dann Passkeys.
+Die Anmeldung mit E-Mail, Passwort und Code bleibt daneben immer offen.
+
+### Was in der Liste steht
+
+Unter **Mein Konto → Passkeys** siehst du zu jedem Gerät, wann es
+eingerichtet und wann es zuletzt benutzt wurde. **Sieh da gelegentlich
+hinein.** Ein Eintrag, den du nicht zuordnen kannst, gehört sofort
+entfernt — und danach das Passwort gewechselt.
+
+Steht bei einem Eintrag *gesichert*, wird der Schlüssel vom Anbieter
+mitgesichert (iCloud-Schlüsselbund, Google, Bitwarden) und taucht auf
+einem neuen Gerät von selbst wieder auf. Ohne diesen Vermerk liegt er nur
+auf diesem einen Gerät.
+
+### Wenn ein Gerät verloren geht
+
+1. Auf einem anderen Gerät mit E-Mail, Passwort und Code anmelden.
+2. **Mein Konto → Passkeys**, den Eintrag des verlorenen Geräts entfernen.
+3. Fertig — der Schlüssel auf dem Gerät ist damit wertlos.
+
+Ein Passkey allein reicht ohnehin niemandem, der das Gerät findet: Ohne
+Fingerabdruck oder PIN gibt das Gerät ihn nicht heraus.
+
+### Wenn der Knopf gar nicht erscheint
+
+Dann bietet der Server Passkeys nicht an — das Verfahren verlangt eine
+verschlüsselte Verbindung (`https`). Oder der Browser ist zu alt. Melde
+dich mit E-Mail, Passwort und Code an; alles andere funktioniert
+unverändert.
+
+---
+
 ## Am Handy

 Die Anwendung ist am Telefon vollwertig bedienbar — sie ist dafür gebaut,
@@ -131,14 +131,14 @@ cd /opt/betreuungs-cockpit

 # Auf die letzte veröffentlichte Fassung wechseln,
 # nicht auf den laufenden Entwicklungsstand
-git checkout v1.0.0
+git checkout v1.1.1
 ```

 ### Kontrolle

 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.0.0
+git describe --tags                              # v1.1.1
 ```

 ---
@@ -205,6 +205,14 @@ S3_SECRET_ACCESS_KEY=<aus Schritt 2>

 # --- Sicherung ---
 SICHERUNG_PASSWORT=<aus Schritt 2>
+
+# --- Erreichbarkeit ---
+# Steht dein Proxy auf einem ANDEREN Server, muss hier die Adresse hinein,
+# ueber die er diesen Server erreicht. Bleibt es bei 127.0.0.1, kommt er
+# NICHT heran - und der Fehler sieht aus, als sei der Proxy schuld.
+# Welcher Wert der richtige ist, steht in Schritt 7a.
+APP_BIND=127.0.0.1
+APP_PORT=3000
 ```

 > **`AUTH_URL` muss exakt der Adresse entsprechen**, unter der du die
@@ -212,6 +220,12 @@ SICHERUNG_PASSWORT=<aus Schritt 2>
 > Steht dort etwas anderes, wird das Sitzungs-Cookie für die falsche
 > Herkunft gesetzt: Die Anmeldung landet stumm wieder auf dem Formular,
 > ohne Fehlermeldung. Das ist der Fehler, den man am längsten sucht.
+>
+> Seit 1.1.0 hängt noch mehr daran: Aus dieser Adresse wird die Kennung
+> abgeleitet, an die Passkeys gebunden werden. Steht sie falsch, lässt
+> sich zwar ein Passkey einrichten, aber nie wieder verwenden. Und ein
+> späterer Wechsel der Domain macht alle vorhandenen Passkeys
+> unbrauchbar — das ist kein Fehler, sondern der Phishingschutz.

 **Läuft auf dem Server schon etwas auf Port 3000?** Dann weich aus:

@@ -285,7 +299,7 @@ betreuungs-cockpit-sicherung-1  Up
 ```bash
 # Antwortet die Anwendung? (Port anpassen, falls du APP_PORT gesetzt hast)
 curl -s http://127.0.0.1:3000/api/gesundheit
-# {"status":"bereit","version":"1.0.0","commit":"..."}
+# {"status":"bereit","version":"1.1.1","commit":"..."}
 ```

 Kommt hier nichts, sieh in die Logs:
@@ -635,7 +649,7 @@ Erst **vom Proxy-Server aus** — kommt er überhaupt an?

 ```bash
 curl -s http://10.0.0.5:3000/api/gesundheit
-# {"status":"bereit","version":"1.0.0",...}
+# {"status":"bereit","version":"1.1.1",...}
 ```

 Kommt hier nichts, liegt es an 7a: falsche `APP_BIND`, Firewall, oder der
@@ -686,7 +700,7 @@ Zum Schluss: **Fristen → Pflichtfristen ableiten**.
 - Du kommst mit E-Mail, Passwort und dem Code aus der App herein.
 - Unter **Fristen** stehen Einträge mit Paragraphenbezug.
 - Unter **Protokoll** siehst du deine eigene Anmeldung.
- Unten links in der Seitenleiste steht `Version 1.0.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.1.1 · <commit>`.

 ---

@@ -824,27 +838,90 @@ Denk an die letzten Pflichten:

 ## Aktualisieren

+```bash
+cd /opt/betreuungs-cockpit
+./scripts/update.sh
+```
+
+> **Kommst du von 1.1.0 oder älter?** Dort lag `update.sh` ohne
+> Ausführungsrecht im Repository — `./scripts/update.sh` endet dann in
+> „Permission denied". Einmalig hilft:
+>
+> ```bash
+> bash scripts/update.sh
+> ```
+>
+> Ab 1.1.1 ist das Recht gesetzt und der Punktschrägstrich funktioniert.
+
+Das war es. Das Skript nimmt dir die Schritte ab, die man von Hand
+vergisst:
+
+1. Prüft Verzeichnis, git, docker und `.env`
+2. Holt die Fassungen und zeigt, was zwischen deinem Stand und dem neuen
+   im Changelog steht
+3. Fragt nach
+4. **Stößt eine Sicherung an** — und bricht ab, wenn sie nicht klappt
+5. Legt eigene Änderungen an versionierten Dateien beiseite, schaltet um,
+   baut neu
+6. Wartet, bis die Anwendung antwortet
+7. Führt die **beiden SQL-Skripte** aus (Volltextsuche, Audit-Schutz)
+8. Prüft, ob wirklich die neue Fassung läuft
+
+**Bis Schritt 3 wird nichts verändert.** Bricht etwas vorher ab, findest du
+alles so vor wie zuvor.
+
+### Aufrufmöglichkeiten
+
+| Aufruf | Wirkung |
+|---|---|
+| `./scripts/update.sh` | auf die neueste veröffentlichte Fassung |
+| `./scripts/update.sh v1.2.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh --pruefen` | nur nachsehen, nichts ändern |
+| `./scripts/update.sh --ja` | ohne Rückfrage (für cron) |
+| `./scripts/update.sh --verwerfen` | eigene Änderungen wegwerfen statt beiseitelegen |
+| `./scripts/update.sh --ohne-sicherung` | Sicherung überspringen — sehr gut überlegen |
+
+### Eigene Änderungen an der docker-compose.yml
+
+Das ist der Normalfall: Man passt etwas an, bis es läuft. Das Skript legt
+solche Änderungen vor dem Umschalten mit `git stash` beiseite und sagt,
+wie man sie zurückholt:
+
+```bash
+git stash list      # was liegt da
+git stash pop       # zurückholen
+git stash drop      # wegwerfen
+```
+
+Sind deine Anpassungen inzwischen im Projekt eingearbeitet — wie
+`APP_BIND` oder `MINIO_KONSOLE_PORT` —, brauchst du sie nicht
+zurückzuholen. Dann setz die Werte einfach in der `.env`.
+
+> **Die `.env` wird nie angefasst.** Sie ist nicht versioniert; weder
+> `git checkout` noch das Skript rühren sie an.
+
+### Von Hand, wenn du lieber selbst steuerst
+
 ```bash
 cd /opt/betreuungs-cockpit

 # 1. IMMER zuerst sichern - eine Migration lässt sich nicht zurückrollen
 docker compose exec sicherung /bin/sh /sicherung.sh

-# 2. Was ändert sich? Lies den Changelog, bevor du ziehst
+# 2. Was ändert sich?
 git fetch --tags
 git log --oneline HEAD..origin/main

-# 3. Auf die neue Fassung wechseln
-git checkout v1.1.0
+# 3. Umschalten
+git checkout v1.1.1

 # 4. Neu bauen und starten
-GIT_COMMIT=$(git rev-parse --short HEAD) \
-BUILD_ZEIT=$(date -Iseconds) \
-docker compose up -d --build
-```
+GIT_COMMIT=$(git rev-parse --short HEAD) BUILD_ZEIT=$(date -Iseconds) docker compose up -d --build

-Die Migrationen laufen beim Start mit. **Sagt der Changelog, dass sich ein
-SQL-Skript geändert hat, führ die beiden Befehle aus Schritt 5 erneut aus.**
+# 5. Die beiden SQL-Skripte - sie laufen NICHT mit den Migrationen mit
+docker compose exec app node node_modules/prisma/build/index.js db execute   --schema prisma/schema.prisma --file prisma/sql/volltextsuche.sql
+docker compose exec app node node_modules/prisma/build/index.js db execute   --schema prisma/schema.prisma --file prisma/sql/audit-schutz.sql
+```

 ### Kontrolle

@@ -854,7 +931,21 @@ curl -s https://cockpit.deine-domain.de/api/gesundheit
 ```

 Steht dort noch die alte Version, läuft der alte Behälter weiter — dann
-hat der Bau nicht durchgezogen. Sieh in `docker compose logs app`.
+hat der Bau nicht durchgezogen:
+
+```bash
+docker compose up -d --build --force-recreate app
+```
+
+### Zurück auf den vorherigen Stand
+
+```bash
+git checkout v1.0.4
+docker compose up -d --build
+```
+
+Hat die neue Fassung die Datenbank migriert, reicht das nicht — dann muss
+auch die Sicherung zurück (siehe Schritt 9).

 ---

@@ -875,6 +966,41 @@ Fehlt eine Umgebungsvariable, sagt die Anwendung beim Start, welche.
 Die `.env` liegt nicht neben der `docker-compose.yml`, oder die Zeile ist
 leer. Prüf mit dem Befehl aus Schritt 3.

+### Der Proxy erreicht die Anwendung nicht („502", „Connection refused")
+
+Fast immer steht in der `.env` noch `APP_BIND=127.0.0.1`, während der
+Proxy auf einem anderen Server läuft. Dann horcht die Anwendung nur auf
+der Loopback-Adresse — erreichbar ausschließlich vom Anwendungsserver
+selbst.
+
+Prüf, worauf sie tatsächlich horcht:
+
+```bash
+docker compose ps
+# unter PORTS muss die Adresse stehen, die der Proxy erreicht,
+# NICHT 127.0.0.1
+```
+
+Und ob sie überhaupt antwortet — erst lokal, dann vom Proxy-Server aus:
+
+```bash
+# auf dem Anwendungsserver
+curl -s http://127.0.0.1:3000/api/gesundheit
+
+# auf dem Proxy-Server
+curl -s http://<APP_BIND-Adresse>:3000/api/gesundheit
+```
+
+Antwortet der erste, aber nicht der zweite, ist `APP_BIND` falsch oder
+eine Firewall dazwischen. Setz den richtigen Wert (Schritt 7a) und
+
+```bash
+docker compose up -d
+```
+
+Ein Neubau des Abbilds ist dafür **nicht** nötig — es ist nur eine
+Umgebungsänderung, der Behälter wird neu erzeugt.
+
 ### Port 3000 ist schon belegt

 ```bash
@@ -914,6 +1040,46 @@ timedatectl
 docker compose exec app date
 ```

+### Der Knopf „Mit Passkey anmelden" erscheint nicht
+
+Passkeys brauchen einen sicheren Kontext. Die Anwendung bietet sie nur an,
+wenn `AUTH_URL` auf `https://` steht (oder auf `localhost`) — sonst
+erscheint der Knopf bewusst gar nicht erst, statt beim Klick mit einer
+kryptischen Browsermeldung abzubrechen.
+
+```bash
+docker compose exec app printenv AUTH_URL    # muss mit https:// beginnen
+```
+
+Steht dort `http://`, korrigiere die `.env` und starte neu:
+
+```bash
+docker compose up -d
+```
+
+Erscheint der Knopf weiterhin nicht, kann der Browser kein WebAuthn — das
+betrifft praktisch nur sehr alte Fassungen.
+
+### Ein Passkey lässt sich einrichten, aber nicht zum Anmelden benutzen
+
+Fast immer stimmt die Adresse nicht überein. Der Schlüssel ist an den
+Hostnamen aus `AUTH_URL` gebunden; der Browser vergleicht ihn mit dem, was
+in der Adresszeile steht.
+
+```bash
+docker compose exec app printenv AUTH_URL
+# muss exakt die Adresse sein, die du im Browser eintippst
+```
+
+Typische Ursachen: `AUTH_URL` zeigt auf `cockpit.example.de`, aufgerufen
+wird aber `www.cockpit.example.de` — oder umgekehrt. Ein Passkey für die
+eine Adresse gilt auf der anderen nicht.
+
+**Nach einem Wechsel der Domain** müssen alle Passkeys neu eingerichtet
+werden. Die alten Einträge lassen sich unter *Mein Konto → Passkeys*
+entfernen. Die Anmeldung mit E-Mail, Passwort und Code funktioniert in der
+Zwischenzeit unverändert — man sperrt sich damit also nicht aus.
+
 ### Die Texterkennung findet nichts

 ```bash
@@ -9,7 +9,7 @@ Zeit spart. Er steht weit unten, wenn er nur schön wäre.
 Diese Datei ist eine Absichtserklärung, kein Vertrag. Was sich im Betrieb
 als wichtiger herausstellt, rutscht nach oben.

-Stand: 22.08.2026 · Aktuelle Fassung: **1.0.0** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.1.1** ([CHANGELOG](../CHANGELOG.md))

 ---

@@ -136,6 +136,31 @@ Jahresbericht und bei einer Höherstufung gebraucht.

 ---

+## 1.2b — Passkeys abrunden
+
+Der Grundstock steht seit 1.1.0. Was noch fehlt, ist Bequemlichkeit, nicht
+Sicherheit.
+
+### Passkey direkt im Anmeldefeld anbieten
+
+Browser können einen Passkey im Ausfüllvorschlag des E-Mail-Feldes
+anbieten (*conditional UI*), statt hinter einem eigenen Knopf. Ein Schritt
+weniger. Braucht einen zweiten Challenge-Weg und sorgfältiges Abbrechen,
+wenn stattdessen doch das Passwort getippt wird.
+
+### Passkey umbenennen
+
+Heute geht nur anlegen und entfernen. Wer sein Gerät „Handy" genannt hat
+und inzwischen zwei hat, muss den Passkey neu einrichten.
+
+### Warnen, wenn der letzte Passkey nur auf einem Gerät liegt
+
+Die Liste sagt bereits, ob ein Schlüssel gesichert ist. Wer ausschließlich
+ungesicherte Passkeys hat und dazu keine Wiederherstellungscodes mehr,
+sollte das deutlicher zu sehen bekommen als in einer Zeile Kleingedrucktem.
+
+---
+
 ## 1.3 — Belastbarkeit

 **Ziel:** Die Stellen absichern, die bisher nur unter Laborbedingungen
@@ -164,6 +189,14 @@ Monat automatisch durchspielt — Sicherung zurückspielen, Diagnosen im
 Klartext prüfen, Testdatenbank verwerfen — wäre der Beweis statt der
 Absichtserklärung.

+### Passkey-Ablehnung ohne Browser nachstellen
+
+Die Prüfung „Passkey ohne Nutzerverifikation wird abgewiesen" ist im Code
+doppelt abgesichert und im Browsertest belegt — dort weist allerdings
+schon der Browser ab, der Server kommt gar nicht dran. Ein Test, der die
+Antwort von Hand baut und den Browser umgeht, würde den serverseitigen
+Rückhalt tatsächlich beweisen.
+
 ### Barrierefreiheits-Durchgang mit einem Screenreader

 Semantik, Fokusreihenfolge und Kontraste sind beim Bauen beachtet und in
@@ -0,0 +1,188 @@
+import { expect, test } from '@playwright/test'
+import type { BrowserContext, CDPSession, Page } from '@playwright/test'
+import { anmelden, fehlversucheLoeschen } from './hilfen'
+
+/**
+ * Passkeys gegen einen echten Browser.
+ *
+ * WebAuthn laesst sich nicht sinnvoll mit Einheitstests pruefen: Was zaehlt,
+ * passiert zwischen Browser und Authenticator. Chromium bringt dafuer einen
+ * virtuellen Authenticator mit, der ueber das Debugprotokoll gesteuert wird -
+ * er signiert echt, nur ohne Fingerabdrucksensor.
+ *
+ * Damit laesst sich der Ablauf vollstaendig durchspielen: einrichten,
+ * abmelden, mit Passkey anmelden, entfernen. Und, wichtiger, der Fall, den
+ * die Zusage dieser Anwendung traegt - ein Geraet OHNE Nutzerverifikation
+ * darf nicht hereinkommen.
+ */
+
+type VirtuellerAuthenticator = {
+  cdp: CDPSession
+  id: string
+}
+
+async function authenticatorAnlegen(
+  kontext: BrowserContext,
+  seite: Page,
+  verifiziert = true,
+): Promise<VirtuellerAuthenticator> {
+  const cdp = await kontext.newCDPSession(seite)
+  await cdp.send('WebAuthn.enable')
+
+  const { authenticatorId } = await cdp.send('WebAuthn.addVirtualAuthenticator', {
+    options: {
+      protocol: 'ctap2',
+      // "internal" = im Geraet verbaut, wie Face ID oder Windows Hello.
+      transport: 'internal',
+      // Auffindbarer Schluessel - Voraussetzung fuer die Anmeldung ohne
+      // vorherige Eingabe der E-Mail-Adresse.
+      hasResidentKey: true,
+      hasUserVerification: true,
+      isUserVerified: verifiziert,
+      automaticPresenceSimulation: true,
+    },
+  })
+
+  return { cdp, id: authenticatorId }
+}
+
+async function passkeyEinrichten(seite: Page, name: string): Promise<void> {
+  await seite.goto('/konto')
+  await seite.getByLabel('Neues Gerät').fill(name)
+  await seite.getByRole('button', { name: 'Passkey einrichten' }).click()
+  await expect(seite.getByText(`„${name}“ ist eingerichtet.`)).toBeVisible()
+}
+
+test.describe('Passkey', () => {
+  test.beforeEach(async () => {
+    await fehlversucheLoeschen()
+  })
+
+  test('richtet einen Passkey ein und meldet sich anschliessend damit an', async ({
+    page,
+    context,
+  }) => {
+    const authenticator = await authenticatorAnlegen(context, page)
+
+    // --- 1. Auf dem gewoehnlichen Weg herein --------------------------------
+    await anmelden(page)
+
+    // --- 2. Passkey einrichten ---------------------------------------------
+    await passkeyEinrichten(page, 'Testgerät')
+
+    // Er steht in der Liste, mit Datum und dem Hinweis "noch nicht benutzt".
+    const eintrag = page.locator('li', { hasText: 'Testgerät' })
+    await expect(eintrag).toBeVisible()
+    await expect(eintrag).toContainText('noch nicht benutzt')
+
+    // --- 3. Abmelden --------------------------------------------------------
+    await context.clearCookies()
+    await page.goto('/anmelden')
+    await expect(page.getByRole('button', { name: 'Mit Passkey anmelden' })).toBeVisible()
+
+    // --- 4. Mit Passkey anmelden -------------------------------------------
+    await Promise.all([
+      page.waitForURL((url) => !url.pathname.startsWith('/anmelden'), { timeout: 45_000 }),
+      page.getByRole('button', { name: 'Mit Passkey anmelden' }).click(),
+    ])
+
+    // Kein zweiter Schritt: Der Passkey IST der zweite Faktor. Wer hier auf
+    // der Einrichtungsseite fuer TOTP landet, hat einen Fehler im Ablauf.
+    expect(new URL(page.url()).pathname).not.toContain('/zwei-faktor')
+
+    // --- 5. Die Benutzung ist vermerkt -------------------------------------
+    await page.goto('/konto')
+    await expect(page.locator('li', { hasText: 'Testgerät' })).toContainText('zuletzt benutzt')
+
+    // --- 6. Wieder entfernen, damit der naechste Lauf sauber startet -------
+    await page.locator('li', { hasText: 'Testgerät' }).getByRole('button').click()
+    await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
+    await expect(page.getByText('„Testgerät“ wurde entfernt.')).toBeVisible()
+
+    await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
+      authenticatorId: authenticator.id,
+    })
+  })
+
+  test('laesst ein Geraet ohne Nutzerverifikation nicht herein', async ({ page, context }) => {
+    // Das ist die Zusage, auf der alles steht: Ein Passkey darf den zweiten
+    // Faktor nur ersetzen, wenn das Geraet den Benutzer wirklich verifiziert
+    // hat - Fingerabdruck, Gesicht oder PIN. Ein Schluessel, der auf blosses
+    // Antippen hin signiert, ist ein Faktor, kein zweiter.
+    //
+    // Was dieser Test belegt: Die Anforderung erreicht das Geraet, und ein
+    // Geraet ohne Verifikation kommt nicht herein. Abgewiesen wird dabei
+    // schon vom Browser - im Protokoll steht deshalb kein fehlgeschlagener
+    // Versuch. Die Pruefung auf dem Server (requireUserVerification und die
+    // ausdrueckliche Abfrage von userVerified in anmeldungPruefen) ist der
+    // Rueckhalt fuer den Fall, dass jemand die Antwort von Hand baut und den
+    // Browser umgeht. Der laesst sich hier nicht nachstellen.
+    const authenticator = await authenticatorAnlegen(context, page, true)
+
+    await anmelden(page)
+    await passkeyEinrichten(page, 'Ungesichertes Gerät')
+
+    // Jetzt die Verifikation abschalten - so verhaelt sich ein Geraet ohne
+    // eingerichtete Bildschirmsperre.
+    await authenticator.cdp.send('WebAuthn.setUserVerified', {
+      authenticatorId: authenticator.id,
+      isUserVerified: false,
+    })
+
+    await context.clearCookies()
+    await page.goto('/anmelden')
+    await page.getByRole('button', { name: 'Mit Passkey anmelden' }).click()
+
+    // Entscheidend ist nicht der Wortlaut, sondern: Es geht nicht herein.
+    await expect(page.getByRole('alert')).toBeVisible({ timeout: 30_000 })
+    await page.waitForTimeout(1000)
+    expect(new URL(page.url()).pathname).toBe('/anmelden')
+
+    // Aufraeumen: wieder verifizieren, anmelden, Passkey entfernen.
+    await authenticator.cdp.send('WebAuthn.setUserVerified', {
+      authenticatorId: authenticator.id,
+      isUserVerified: true,
+    })
+    await fehlversucheLoeschen()
+    await anmelden(page)
+    await page.goto('/konto')
+    await page.locator('li', { hasText: 'Ungesichertes Gerät' }).getByRole('button').click()
+    await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
+    await expect(page.getByText('„Ungesichertes Gerät“ wurde entfernt.')).toBeVisible()
+
+    await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
+      authenticatorId: authenticator.id,
+    })
+  })
+
+  test('bestaetigt eine sensible Aktion mit dem Passkey statt mit Passwort und Code', async ({
+    page,
+    context,
+  }) => {
+    const authenticator = await authenticatorAnlegen(context, page)
+
+    await anmelden(page)
+    await passkeyEinrichten(page, 'Bestätigungsgerät')
+
+    // Der Vollexport verlangt eine frische Anmeldung.
+    await page.goto('/berichte/export')
+    await page.waitForURL(/\/(bestaetigen|berichte)/)
+
+    if (new URL(page.url()).pathname === '/bestaetigen') {
+      await Promise.all([
+        page.waitForURL((url) => url.pathname !== '/bestaetigen', { timeout: 45_000 }),
+        page.getByRole('button', { name: 'Mit Passkey bestätigen' }).click(),
+      ])
+      expect(new URL(page.url()).pathname).toContain('/berichte/export')
+    }
+
+    await page.goto('/konto')
+    await page.locator('li', { hasText: 'Bestätigungsgerät' }).getByRole('button').click()
+    await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
+    await expect(page.getByText('„Bestätigungsgerät“ wurde entfernt.')).toBeVisible()
+
+    await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
+      authenticatorId: authenticator.id,
+    })
+  })
+})
@@ -1,12 +1,12 @@
 {
  "name": "betreuungs-cockpit",
-  "version": "0.1.0",
+  "version": "1.0.5",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "betreuungs-cockpit",
-      "version": "0.1.0",
+      "version": "1.0.5",
      "hasInstallScript": true,
      "dependencies": {
        "@aws-sdk/client-s3": "3.735.0",
@@ -18,6 +18,8 @@
        "@radix-ui/react-label": "2.1.1",
        "@radix-ui/react-slot": "1.1.1",
        "@react-pdf/renderer": "4.1.6",
+        "@simplewebauthn/browser": "13.3.0",
+        "@simplewebauthn/server": "13.3.2",
        "archiver": "7.0.1",
        "class-variance-authority": "0.7.1",
        "clsx": "2.1.1",
@@ -1573,6 +1575,12 @@
      "integrity": "sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww==",
      "license": "MIT"
    },
+    "node_modules/@hexagon/base64": {
+      "version": "1.1.28",
+      "resolved": "https://registry.npmjs.org/@hexagon/base64/-/base64-1.1.28.tgz",
+      "integrity": "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw==",
+      "license": "MIT"
+    },
    "node_modules/@humanfs/core": {
      "version": "0.19.2",
      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
@@ -2161,6 +2169,12 @@
        "@jridgewell/sourcemap-codec": "^1.4.14"
      }
    },
+    "node_modules/@levischuck/tiny-cbor": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@levischuck/tiny-cbor/-/tiny-cbor-0.2.11.tgz",
+      "integrity": "sha512-llBRm4dT4Z89aRsm6u2oEZ8tfwL/2l6BwpZ7JcyieouniDECM5AqNgr/y08zalEIvW3RSK4upYyybDcmjXqAow==",
+      "license": "MIT"
+    },
    "node_modules/@napi-rs/lzma-linux-x64-gnu": {
      "version": "1.5.1",
      "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
@@ -2706,6 +2720,207 @@
        "pako": "^1.0.10"
      }
    },
+    "node_modules/@peculiar/asn1-android": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-android/-/asn1-android-2.9.4.tgz",
+      "integrity": "sha512-SYHm4SoWSI0nRCoos6jpGusIqhPH9bbGBqv7ohlZ+H6BunrDzzQPk2ePgDuEUzV82OdvbLgtW4twUDwhU9P3YQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-cms": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.9.4.tgz",
+      "integrity": "sha512-cben7oxmQsUGZqotus7yt0srYdncOT6RNWcTQ77T2RFOXejYVYkXadrfePdRcrVpO9K95IRLKKglG2k38jKXuw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-attr": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-csr": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.9.4.tgz",
+      "integrity": "sha512-xd4YN4vpRjkDAQWVfZZkeu12IEND7DOpkqaHSIHxZl1uggUNa9Ju0QxY2jHvDAS9pP0zhRBytg8ifsnGo3V0jw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-ecc": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.9.4.tgz",
+      "integrity": "sha512-JJXefFshRAuVAjWQo/39bkg1ywc1VaiO44S8RRC+Ykvf/u2KDmYffoDb0ZBPCR5uJy4AGKQhl8mX+Q8ShcWaXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pfx": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.9.4.tgz",
+      "integrity": "sha512-khuGzHTzNzk4GDlIBEILyIs6Lce0yn0ZBdoI9v93kmNncfZRhD+AQ5ODFqdhvoE8cMJF/JMTQ8yA+t1D14kqCw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-rsa": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs8": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.9.4.tgz",
+      "integrity": "sha512-duRdotlUx9eDZe6QrQpQKl61RbWykCHBCkKayP8V8XdEFwlKHZ8qGGDMyS6Pye7OX7nLFttTTpRkJeet78ckwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs9": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.9.4.tgz",
+      "integrity": "sha512-kaL4cNxBpdQE2dKlyZBqz4ygCrwffO+8wfoxTEqM1Z8RadvCeELBRzcv0dzM8aY9azHMwODO5nxU65zXmhToOQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-pfx": "^2.9.4",
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-attr": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-rsa": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.9.4.tgz",
+      "integrity": "sha512-pZ96eD1PptovcWQ/GSmuNFXd/7EQJNlKfDaNCyE2rx3W0v6QFelkzquVqRSRyyDXXCYD69ZXJDzZ8GhIiQzKoA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-schema": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.9.4.tgz",
+      "integrity": "sha512-GjzePcT9Iw8NzeOPf73iNS9xM+TBhd/FilAfP+RQGkTMQJTVWtytN3JHJACCjf/ABNau5S7mS3g+DcuxmRgYEg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.9.4.tgz",
+      "integrity": "sha512-CxhBo/RdEbMMob7T31ZdQjGuoyRFLVwrDzTn25bihzBasRg9kRm/0IxIPvhgQtcK/9dNcO1XQL2fuPugwELL0Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509-attr": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.9.4.tgz",
+      "integrity": "sha512-ehQXbpQaQYycgu8OrvigwSPTFfVRcu0ECNYCWw+yzBp02Lw5paRqzzhUpfOgO2K38+WfFZuEz/0RPtam5g0OMg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.3.tgz",
+      "integrity": "sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/x509": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz",
+      "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.6.0",
+        "@peculiar/asn1-csr": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.0",
+        "@peculiar/asn1-pkcs9": "^2.6.0",
+        "@peculiar/asn1-rsa": "^2.6.0",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.0",
+        "pvtsutils": "^1.3.6",
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
    "node_modules/@pkgjs/parseargs": {
      "version": "0.11.0",
      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -4033,6 +4248,31 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/@simplewebauthn/browser": {
+      "version": "13.3.0",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/browser/-/browser-13.3.0.tgz",
+      "integrity": "sha512-BE/UWv6FOToAdVk0EokzkqQQDOWtNydYlY6+OrmiZ5SCNmb41VehttboTetUM3T/fr6EAFYVXjz4My2wg230rQ==",
+      "license": "MIT"
+    },
+    "node_modules/@simplewebauthn/server": {
+      "version": "13.3.2",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/server/-/server-13.3.2.tgz",
+      "integrity": "sha512-KEDhfcGP1PAKRVSDjA3npTQFqS2b/srm+ipoNBNHdkzrHAlaRQUTE+a5f4ywsx6thxAw1NU2rYcLEY1949RGbQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@hexagon/base64": "^1.1.27",
+        "@levischuck/tiny-cbor": "^0.2.2",
+        "@peculiar/asn1-android": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/x509": "^1.14.3"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
    "node_modules/@smithy/config-resolver": {
      "version": "4.7.2",
      "resolved": "https://registry.npmjs.org/@smithy/config-resolver/-/config-resolver-4.7.2.tgz",
@@ -5855,6 +6095,20 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
    "node_modules/assertion-error": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
@@ -10192,6 +10446,24 @@
        "node": ">=6"
      }
    },
+    "node_modules/pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/pvutils": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.2.0.tgz",
+      "integrity": "sha512-BbubeCEyTuQjVMakvJQ/Sxbc93F2pwmbsxONT/ZRrwU7Ua38d8unYTwXpTVLAKJ4BDuH9IGztCjQcd/N/39Dvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
    "node_modules/qrcode": {
      "version": "1.5.4",
      "resolved": "https://registry.npmjs.org/qrcode/-/qrcode-1.5.4.tgz",
@@ -10398,6 +10670,12 @@
        "node": ">=8.10.0"
      }
    },
+    "node_modules/reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
+      "license": "Apache-2.0"
+    },
    "node_modules/reflect.getprototypeof": {
      "version": "1.0.10",
      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -11687,6 +11965,24 @@
        "fsevents": "~2.3.3"
      }
    },
+    "node_modules/tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^1.9.3"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/tsyringe/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
    "node_modules/type-check": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -1,6 +1,6 @@
 {
  "name": "betreuungs-cockpit",
-  "version": "1.0.1",
+  "version": "1.1.1",
  "private": true,
  "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
  "engines": {
@@ -44,6 +44,8 @@
    "@radix-ui/react-label": "2.1.1",
    "@radix-ui/react-slot": "1.1.1",
    "@react-pdf/renderer": "4.1.6",
+    "@simplewebauthn/browser": "13.3.0",
+    "@simplewebauthn/server": "13.3.2",
    "archiver": "7.0.1",
    "class-variance-authority": "0.7.1",
    "clsx": "2.1.1",
@@ -90,5 +92,11 @@
    "prisma@6.3.1": true,
    "sharp@0.33.5": true,
    "unrs-resolver@1.12.2": true
+  },
+  "overrides": {
+    "next-auth": {
+      "@simplewebauthn/server": "$@simplewebauthn/server",
+      "@simplewebauthn/browser": "$@simplewebauthn/browser"
+    }
  }
 }
@@ -0,0 +1,67 @@
+-- Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
+--
+-- ACHTUNG beim Erzeugen weiterer Migrationen: "prisma migrate diff" wollte
+-- hier zusaetzlich die Trigramm-Indizes "dokument_absender_trgm" und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/suche.sql und
+-- sind Prisma unbekannt - ein DROP haette die unscharfe Suche stillgelegt,
+-- ohne dass irgendetwas fehlgeschlagen waere. Solche Zeilen gehoeren aus
+-- jeder erzeugten Migration entfernt.
+
+-- CreateEnum
+CREATE TYPE "PasskeyAnfrageArt" AS ENUM ('REGISTRIERUNG', 'ANMELDUNG');
+
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_REGISTRIERT';
+ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_ENTFERNT';
+
+-- CreateTable
+CREATE TABLE "passkey" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "credentialId" TEXT NOT NULL,
+    "publicKey" BYTEA NOT NULL,
+    "counter" BIGINT NOT NULL DEFAULT 0,
+    "transports" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "name" TEXT NOT NULL,
+    "geraeteArt" TEXT,
+    "gesichert" BOOLEAN NOT NULL DEFAULT false,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "zuletztBenutztAm" TIMESTAMP(3),
+
+    CONSTRAINT "passkey_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "passkey_anfrage" (
+    "id" TEXT NOT NULL,
+    "challenge" TEXT NOT NULL,
+    "art" "PasskeyAnfrageArt" NOT NULL,
+    "userId" TEXT,
+    "ablaufAm" TIMESTAMP(3) NOT NULL,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "passkey_anfrage_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "passkey_credentialId_key" ON "passkey"("credentialId");
+
+-- CreateIndex
+CREATE INDEX "passkey_userId_idx" ON "passkey"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "passkey_anfrage_challenge_key" ON "passkey_anfrage"("challenge");
+
+-- CreateIndex
+CREATE INDEX "passkey_anfrage_ablaufAm_idx" ON "passkey_anfrage"("ablaufAm");
+
+-- AddForeignKey
+ALTER TABLE "passkey" ADD CONSTRAINT "passkey_userId_fkey" FOREIGN KEY ("userId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
@@ -89,6 +89,7 @@ model User {
  geloeschtAm    DateTime?

  zugaenge           BetreuungsZugang[]
+  passkeys           Passkey[]
  auditEintraege     AuditLog[]
  angelegteVorgaenge Vorgang[]          @relation("VorgangAngelegtVon")
  berichte           Bericht[]
@@ -135,6 +136,91 @@ model LoginVersuch {
  @@map("login_versuch")
 }

+/// Ein registrierter Passkey (WebAuthn/FIDO2).
+///
+/// Der private Schluessel verlaesst das Geraet nie - hier liegt nur der
+/// oeffentliche Teil. Ein gestohlener Datenbankabzug erlaubt deshalb keine
+/// Anmeldung, anders als bei einem Passworthash, den man offline angreifen
+/// kann.
+///
+/// Ein Passkey zaehlt bei uns als ZWEI Faktoren: Besitz des Geraets plus
+/// die Nutzerverifikation darauf (Fingerabdruck, Gesicht oder Geraete-PIN).
+/// Deshalb wird bei der Anmeldung "userVerified" erzwungen - siehe
+/// src/lib/auth/passkey.ts. Ohne diese Pruefung waere es nur ein Faktor.
+model Passkey {
+  id String @id @default(cuid())
+
+  userId String
+  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  /// Kennung des Authenticators, base64url. Eindeutig ueber alle Benutzer -
+  /// derselbe Schluessel darf nicht an zwei Zugaengen haengen.
+  credentialId String @unique
+
+  /// Oeffentlicher Schluessel im COSE-Format. Kein Geheimnis.
+  publicKey Bytes
+
+  /// Signaturzaehler des Authenticators. Zaehlt er nicht hoch, obwohl er
+  /// es vorher tat, ist der Schluessel womoeglich geklont worden.
+  /// BigInt, weil der Zaehler bis 2^32-1 geht.
+  counter BigInt @default(0)
+
+  /// "usb", "nfc", "ble", "internal", "hybrid" - hilft dem Browser beim
+  /// naechsten Mal, das richtige Geraet vorzuschlagen.
+  transports String[] @default([])
+
+  /// Vom Benutzer vergeben ("iPhone von Florian"). Bei mehreren Geraeten
+  /// ist das die einzige Moeglichkeit, sie auseinanderzuhalten.
+  name String
+
+  /// "singleDevice" = liegt nur auf diesem Geraet, "multiDevice" = wird vom
+  /// Schluesselbund synchronisiert. Steht in der Uebersicht, weil es den
+  /// Unterschied macht, ob ein verlorenes Geraet den Zugang mitnimmt.
+  geraeteArt String?
+
+  /// Ob der Anbieter den Schluessel gesichert hat (iCloud, Google, Bitwarden).
+  gesichert Boolean @default(false)
+
+  erstelltAm       DateTime  @default(now())
+  zuletztBenutztAm DateTime?
+
+  @@index([userId])
+  @@map("passkey")
+}
+
+enum PasskeyAnfrageArt {
+  REGISTRIERUNG
+  ANMELDUNG
+}
+
+/// Kurzlebiger Speicher fuer die Challenge einer laufenden Passkey-Aktion.
+///
+/// Die Challenge muss serverseitig liegen und genau einmal gelten, sonst
+/// liesse sich eine mitgeschnittene Antwort erneut einspielen. Verbraucht
+/// wird sie durch DELETE - dass genau eine Zeile geloescht wurde, ist der
+/// Beweis, dass sie noch nicht benutzt war.
+///
+/// Bewusst ohne Fremdschluessel auf User: die Zeile lebt fuenf Minuten und
+/// ist kein Fachdatum. Der Wartungslauf raeumt Liegengebliebenes weg.
+model PasskeyAnfrage {
+  id String @id @default(cuid())
+
+  /// base64url, zufaellig. Eindeutig, damit das Verbrauchen atomar ist.
+  challenge String @unique
+
+  art PasskeyAnfrageArt
+
+  /// Bei der Registrierung bekannt. Bei der Anmeldung nicht - dort weiss
+  /// der Server erst nach der Antwort, wer sich anmeldet.
+  userId String?
+
+  ablaufAm   DateTime
+  erstelltAm DateTime @default(now())
+
+  @@index([ablaufAm])
+  @@map("passkey_anfrage")
+}
+
 // =============================================================================
 // Betreute Person
 // =============================================================================
@@ -1527,6 +1613,8 @@ enum AuditAktion {
  ANMELDUNG_FEHLGESCHLAGEN
  ABMELDUNG
  ZWEITER_FAKTOR_EINGERICHTET
+  PASSKEY_REGISTRIERT
+  PASSKEY_ENTFERNT
  PASSWORT_GEAENDERT
  ROLLE_GEAENDERT
  FREIGABE_GEAENDERT
@@ -25,6 +25,42 @@ BEGIN
    RETURN OLD;
  END IF;

+  /*
+   * Eine einzige Ausnahme beim UPDATE: das Nullen der beiden
+   * Fremdschluessel.
+   *
+   * Wird eine betreute Person oder ein Benutzer endgueltig geloescht
+   * (Papierkorb nach 30 Tagen), setzt Postgres wegen ON DELETE SET NULL
+   * die Spalten betreuteId bzw. userId auf NULL. Ohne diese Ausnahme
+   * scheitert das Loeschen - und der Papierkorb liesse sich nie leeren.
+   *
+   * Der Nachweis bleibt dabei vollstaendig: Zeitpunkt, Aktion, Entitaet,
+   * Bezeichnung und die verschluesselte Aenderung sind unberuehrt, ebenso
+   * die Momentaufnahmen userEmail und userName. Es verschwindet nur der
+   * Verweis auf einen Datensatz, den es nicht mehr gibt.
+   *
+   * Jede andere Aenderung wird abgewiesen - auch das Zurueckschreiben
+   * eines Fremdschluessels auf einen anderen Wert.
+   */
+  IF TG_OP = 'UPDATE'
+     AND NEW.id                        =                OLD.id
+     AND NEW.zeitpunkt                 =                OLD.zeitpunkt
+     AND NEW.aktion                    =                OLD.aktion
+     AND NEW.entitaet                  =                OLD.entitaet
+     AND NEW."entitaetId"              IS NOT DISTINCT FROM OLD."entitaetId"
+     AND NEW.bezeichnung               IS NOT DISTINCT FROM OLD.bezeichnung
+     AND NEW."userEmail"               IS NOT DISTINCT FROM OLD."userEmail"
+     AND NEW."userName"                IS NOT DISTINCT FROM OLD."userName"
+     AND NEW."aenderungVerschluesselt" IS NOT DISTINCT FROM OLD."aenderungVerschluesselt"
+     AND NEW."ipHash"                  IS NOT DISTINCT FROM OLD."ipHash"
+     AND NEW."userAgent"               IS NOT DISTINCT FROM OLD."userAgent"
+     -- Die beiden Fremdschluessel duerfen sich aendern, aber NUR nach NULL.
+     AND (NEW."betreuteId" IS NULL OR NEW."betreuteId" IS NOT DISTINCT FROM OLD."betreuteId")
+     AND (NEW."userId"     IS NULL OR NEW."userId"     IS NOT DISTINCT FROM OLD."userId")
+  THEN
+    RETURN NEW;
+  END IF;
+
  RAISE EXCEPTION
    'Das Audit-Log ist unveraenderlich. % auf audit_log ist nicht zulaessig.',
    TG_OP
@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Warum klappt die Anmeldung nicht?
+ *
+ *   node --env-file=.env scripts/anmeldung-pruefen.mjs <e-mail>
+ *   docker compose exec app node scripts/anmeldung-pruefen.mjs <e-mail>
+ *
+ * Die Anwendung sagt am Anmeldeformular bewusst nicht, woran es lag - sonst
+ * liesse sich daran ablesen, welche Adressen es gibt. Auf dem Server darf
+ * man es wissen: Jeder Versuch wird mit Grund protokolliert, und dieses
+ * Skript liest ihn vor.
+ *
+ * Es aendert nichts. Es liest nur.
+ */
+import { PrismaClient } from '@prisma/client'
+
+const email = (process.argv[2] ?? '').trim().toLowerCase()
+
+if (!email) {
+  console.error('Aufruf: node scripts/anmeldung-pruefen.mjs <e-mail>')
+  process.exit(1)
+}
+
+const db = new PrismaClient()
+
+function zeit(d) {
+  return d ? new Date(d).toLocaleString('de-DE') : '—'
+}
+
+/** Klartext zu den Gruenden, die src/auth.ts protokolliert. */
+const GRUND = {
+  unbekannt: 'Diese E-Mail-Adresse gibt es nicht (Tippfehler? andere Adresse?)',
+  'passwort-falsch': 'Das Passwort stimmt nicht',
+  'code-falsch': 'Der Code aus der Authenticator-App stimmt nicht',
+  gesperrt: 'Abgewiesen, weil zu diesem Zeitpunkt bereits gesperrt war',
+  'konto-inaktiv': 'Der Zugang ist deaktiviert oder im Papierkorb',
+}
+
+try {
+  const benutzer = await db.user.findUnique({ where: { email } })
+
+  console.log('\n══ Zugang ' + '═'.repeat(50))
+
+  if (!benutzer) {
+    console.log(`  Es gibt KEINEN Zugang mit der Adresse ${email}.`)
+    const alle = await db.user.findMany({
+      select: { email: true, aktiv: true, geloeschtAm: true },
+      orderBy: { erstelltAm: 'asc' },
+    })
+    console.log(
+      alle.length
+        ? '\n  Vorhandene Adressen:\n' +
+            alle.map((u) => `    ${u.email}${u.geloeschtAm ? '  (im Papierkorb)' : u.aktiv ? '' : '  (deaktiviert)'}`).join('\n')
+        : '\n  Es gibt ueberhaupt keinen Zugang. Leg ihn im Browser unter /ersteinrichtung an.',
+    )
+  } else {
+    const zweiterFaktor = benutzer.totpAktiviertAm
+      ? `eingerichtet am ${zeit(benutzer.totpAktiviertAm)}`
+      : benutzer.totpSecretVerschluesselt
+        ? 'vorbereitet, aber NICHT bestaetigt - beim Anmelden wird noch kein Code verlangt'
+        : 'noch nicht eingerichtet - beim Anmelden wird noch kein Code verlangt'
+
+    console.log(`  Name:              ${benutzer.name}`)
+    console.log(`  Rolle:             ${benutzer.rolle}`)
+    console.log(`  Aktiv:             ${benutzer.aktiv ? 'ja' : 'NEIN - Anmeldung nicht moeglich'}`)
+    console.log(`  Papierkorb:        ${benutzer.geloeschtAm ? 'JA seit ' + zeit(benutzer.geloeschtAm) : 'nein'}`)
+    console.log(`  Zweiter Faktor:    ${zweiterFaktor}`)
+    console.log(`  Wiederherstellung: ${benutzer.wiederherstellungscodes.length} Codes uebrig`)
+    console.log(`  Passwort gesetzt:  ${zeit(benutzer.passwortGeaendertAm)}`)
+    console.log(`  Letzte Anmeldung:  ${zeit(benutzer.letzteAnmeldung)}`)
+
+    const zugaenge = await db.betreuungsZugang.count({ where: { userId: benutzer.id } })
+    const betreute = await db.betreute.count({ where: { geloeschtAm: null } })
+    console.log(`  Betreute Personen: ${zugaenge} zugeordnet, ${betreute} insgesamt angelegt`)
+
+    if (zugaenge === 0 && betreute === 0) {
+      console.log(
+        '\n  Hinweis: Nach dem Anmelden landest du zuerst bei der\n' +
+          '  Ersteinrichtung - erst zweiter Faktor, dann betreute Person.',
+      )
+    }
+  }
+
+  // --- Versuche der letzten Tage -------------------------------------------
+  const versuche = await db.loginVersuch.findMany({
+    where: { email },
+    orderBy: { zeitpunkt: 'desc' },
+    take: 15,
+  })
+
+  console.log('\n══ Letzte Anmeldeversuche ' + '═'.repeat(35))
+
+  if (versuche.length === 0) {
+    console.log(
+      '  Keine. Es ist also NIE ein Versuch beim Server angekommen.\n\n' +
+        '  Das heisst: Das Formular hat gar nicht abgeschickt, oder es lief\n' +
+        '  auf eine andere Adresse. Pruef AUTH_URL - siehe unten.',
+    )
+  } else {
+    for (const v of versuche) {
+      const kennzeichen = v.erfolg ? 'OK    ' : 'FEHLER'
+      const grund = v.erfolg ? 'angemeldet' : (GRUND[v.grund] ?? v.grund ?? 'unbekannter Grund')
+      console.log(`  ${zeit(v.zeitpunkt).padEnd(20)} ${kennzeichen}  ${grund}`)
+    }
+  }
+
+  // --- Sperre ---------------------------------------------------------------
+  const fenster = Number.parseInt(process.env.LOGIN_FENSTER_SEKUNDEN ?? '900', 10)
+  const grenze = Number.parseInt(process.env.LOGIN_MAX_VERSUCHE ?? '5', 10)
+  const seit = new Date(Date.now() - fenster * 1000)
+
+  const offen = await db.loginVersuch.count({
+    where: { email, erfolg: false, zeitpunkt: { gte: seit } },
+  })
+
+  console.log('\n══ Sperre ' + '═'.repeat(51))
+  console.log(`  ${offen} von ${grenze} Fehlversuchen im laufenden Fenster (${fenster / 60} Minuten)`)
+
+  if (offen >= grenze) {
+    console.log(
+      '\n  GESPERRT. Warte das Fenster ab, oder setz die Zaehler zurueck:\n' +
+        '    docker compose exec db psql -U cockpit betreuungs_cockpit \\\n' +
+        '      -c "DELETE FROM login_versuch WHERE erfolg = false;"',
+    )
+  }
+
+  // --- Umgebung -------------------------------------------------------------
+  console.log('\n══ Umgebung ' + '═'.repeat(49))
+  console.log(`  AUTH_URL:  ${process.env.AUTH_URL ?? 'NICHT GESETZT'}`)
+  console.log(
+    '\n  Diese Adresse muss EXAKT die sein, die du im Browser aufrufst -\n' +
+      '  gleiches Schema (https), gleicher Hostname, kein Schraegstrich am\n' +
+      '  Ende. Weicht sie ab, wird das Sitzungs-Cookie fuer die falsche\n' +
+      '  Herkunft gesetzt: Die Anmeldung landet ohne Fehlermeldung wieder\n' +
+      '  auf dem Formular, und oben steht kein einziger Fehlversuch.\n',
+  )
+} catch (fehler) {
+  // Ein Prisma-Stacktrace hilft hier niemandem weiter.
+  const meldung = fehler instanceof Error ? fehler.message : String(fehler)
+
+  if (/Can't reach database server|ECONNREFUSED/i.test(meldung)) {
+    // Das Passwort in der Verbindungszeichenkette gehoert nicht auf den Schirm.
+    const url = (process.env.DATABASE_URL ?? 'NICHT GESETZT').replace(/:[^:@/]+@/, ':***@')
+    console.error(
+      [
+        '',
+        'Die Datenbank ist nicht erreichbar.',
+        '',
+        `  DATABASE_URL: ${url}`,
+        '',
+        '  Im Docker-Betrieb gehoert dieses Skript IN den Behaelter:',
+        '    docker compose exec app node scripts/anmeldung-pruefen.mjs <e-mail>',
+        '',
+        '  Laeuft die Datenbank ueberhaupt?',
+        '    docker compose ps',
+        '',
+      ].join('\n'),
+    )
+  } else {
+    console.error(`\nFehler: ${meldung}\n`)
+  }
+  process.exitCode = 1
+} finally {
+  await db.$disconnect()
+}
@@ -0,0 +1,392 @@
+#!/usr/bin/env bash
+#
+# Betreuungs-Cockpit aktualisieren.
+#
+#   ./scripts/update.sh              auf die neueste veroeffentlichte Fassung
+#   ./scripts/update.sh v1.2.0       auf eine bestimmte Fassung
+#   ./scripts/update.sh --ja         ohne Rueckfrage (fuer cron)
+#   ./scripts/update.sh --pruefen    nur nachsehen, nichts aendern
+#   ./scripts/update.sh --verwerfen  eigene Aenderungen an versionierten
+#                                    Dateien wegwerfen statt beiseitelegen
+#
+# Was das Skript tut, in dieser Reihenfolge:
+#
+#   1. Voraussetzungen pruefen (Verzeichnis, git, docker, .env)
+#   2. Fassungen holen und vergleichen
+#   3. Zeigen, was sich aendert (Changelog-Abschnitte dazwischen)
+#   4. Nachfragen
+#   5. SICHERUNG anstossen - und abbrechen, wenn sie nicht klappt
+#   6. Eigene Aenderungen beiseitelegen, umschalten, neu bauen, starten
+#   7. Die beiden SQL-Skripte ausfuehren (sie sind idempotent)
+#   8. Pruefen, ob die neue Fassung wirklich laeuft
+#
+# Die Reihenfolge ist Absicht: Bis einschliesslich Schritt 4 wird nichts
+# veraendert. Wer vorher abbricht - oder wobei etwas schiefgeht -, findet
+# alles so vor wie zuvor. Erst danach wird angefasst.
+#
+# Schritt 5 ist der wichtigste: Eine Datenbank-Migration laesst sich nicht
+# zurueckrollen. Ohne Sicherung wird hier nichts aktualisiert.
+#
+# Schritt 7 ebenfalls: Die SQL-Skripte laufen NICHT mit den Migrationen
+# mit. Wer sie vergisst, hat einen veralteten Trigger und merkt es erst,
+# wenn etwas nicht geht.
+#
+# Die .env wird nie angefasst - sie ist nicht versioniert.
+
+# Die geschweiften Klammern sorgen dafuer, dass bash die ganze Datei liest,
+# bevor sie irgendetwas ausfuehrt. Ohne sie koennte der git-checkout weiter
+# unten das Skript unter den eigenen Fuessen austauschen.
+{
+set -euo pipefail
+
+# --- Ausgabe -----------------------------------------------------------------
+
+if [ -t 1 ]; then
+  ROT=$'\033[31m'; GRUEN=$'\033[32m'; GELB=$'\033[33m'; FETT=$'\033[1m'; AUS=$'\033[0m'
+else
+  ROT=''; GRUEN=''; GELB=''; FETT=''; AUS=''
+fi
+
+schritt()  { printf '\n%s==> %s%s\n' "$FETT" "$1" "$AUS"; }
+gut()      { printf '    %s%s%s\n' "$GRUEN" "$1" "$AUS"; }
+warnung()  { printf '    %s%s%s\n' "$GELB" "$1" "$AUS"; }
+abbruch()  { printf '\n%sAbbruch: %s%s\n\n' "$ROT" "$1" "$AUS" >&2; exit 1; }
+
+# --- Aufrufparameter ---------------------------------------------------------
+
+ZIEL=""
+OHNE_RUECKFRAGE=0
+NUR_PRUEFEN=0
+OHNE_SICHERUNG=0
+VERWERFEN=0
+ENTSCHEIDUNG=""
+
+for arg in "$@"; do
+  case "$arg" in
+    --ja|-j)          OHNE_RUECKFRAGE=1 ;;
+    --pruefen|-p)     NUR_PRUEFEN=1 ;;
+    --ohne-sicherung) OHNE_SICHERUNG=1 ;;
+    --verwerfen)      VERWERFEN=1 ;;
+    --hilfe|-h)
+      sed -n '2,34p' "$0" | sed 's/^#\s\?//'
+      exit 0 ;;
+    -*)               abbruch "Unbekannte Angabe: $arg (--hilfe zeigt die Moeglichkeiten)" ;;
+    *)                ZIEL="$arg" ;;
+  esac
+done
+
+# --- 1. Voraussetzungen ------------------------------------------------------
+
+schritt "Voraussetzungen"
+
+cd "$(dirname "$0")/.." || abbruch "Das Projektverzeichnis ist nicht erreichbar."
+PROJEKT="$(pwd)"
+
+[ -f docker-compose.yml ] || abbruch "Hier liegt keine docker-compose.yml: $PROJEKT"
+[ -f .env ]               || abbruch "Es gibt keine .env. Ohne sie startet die Anwendung nicht."
+command -v git >/dev/null || abbruch "git ist nicht installiert."
+docker compose version >/dev/null 2>&1 || abbruch "docker compose (v2) ist nicht verfuegbar."
+
+gut "Verzeichnis: $PROJEKT"
+
+# Nur nachsehen - angefasst wird die Arbeitskopie erst kurz vor dem
+# Umschalten, wenn Sicherung und Rueckfrage durch sind. Ein Abbruch
+# dazwischen darf keinen Halbzustand hinterlassen.
+SCHMUTZIG=""
+if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
+  SCHMUTZIG="ja"
+  warnung "Es gibt eigene Aenderungen an versionierten Dateien."
+  git status --short --untracked-files=no | sed 's/^/      /'
+  printf '      Sie werden vor dem Umschalten beiseite gelegt.\n'
+else
+  gut "Arbeitskopie ist sauber"
+fi
+
+# --- 2. Was ist da, was kommt ------------------------------------------------
+
+schritt "Fassungen"
+
+if ! git fetch --tags --quiet origin; then
+  abbruch "Konnte die Fassungen nicht vom Server holen.
+         Erreichst du ihn? Stimmen die Zugangsdaten?
+         Es wurde nichts geaendert."
+fi
+
+JETZT="$(git describe --tags --exact-match 2>/dev/null || git rev-parse --short HEAD)"
+NEUESTE="$(git tag --list 'v*' --sort=-v:refname | head -1)"
+
+[ -n "$NEUESTE" ] || abbruch "Es gibt keine veroeffentlichte Fassung (kein Tag)."
+
+if [ -z "$ZIEL" ]; then
+  ZIEL="$NEUESTE"
+fi
+
+git rev-parse --verify --quiet "$ZIEL^{commit}" >/dev/null \
+  || abbruch "Die Fassung '$ZIEL' gibt es nicht. Vorhanden:
+$(git tag --list 'v*' --sort=-v:refname | head -5 | sed 's/^/           /')"
+
+printf '    Jetzt:   %s\n' "$JETZT"
+printf '    Ziel:    %s%s%s\n' "$FETT" "$ZIEL" "$AUS"
+
+if [ "$(git rev-parse HEAD)" = "$(git rev-parse "$ZIEL^{commit}")" ]; then
+  gut "Bereits auf dem gewuenschten Stand - nichts zu tun."
+  exit 0
+fi
+
+# --- 3. Was aendert sich -----------------------------------------------------
+
+schritt "Was sich aendert"
+
+# Der Changelog muss aus der ZIELfassung kommen: Der laufende Stand kennt
+# die neuen Abschnitte ja noch gar nicht.
+CHANGELOG="$(git show "$ZIEL:CHANGELOG.md" 2>/dev/null || true)"
+
+if [ -n "$CHANGELOG" ]; then
+  # Alle Abschnitte zwischen dem laufenden und dem gewuenschten Stand.
+  JETZT_NR="${JETZT#v}"
+  printf '%s
+' "$CHANGELOG" | awk -v jetzt="$JETZT_NR" '
+    /^## \[/ {
+      nummer = $0
+      sub(/^## \[/, "", nummer); sub(/\].*/, "", nummer)
+      if (nummer == jetzt) exit
+      drucken = (nummer != "Unveröffentlicht")
+    }
+    drucken { print "    " $0 }
+  ' | head -60
+else
+  warnung "Kein CHANGELOG.md in $ZIEL gefunden."
+fi
+
+printf '\n'
+git log --oneline --no-decorate "HEAD..$ZIEL" | head -15 | sed 's/^/    /'
+
+if [ "$NUR_PRUEFEN" = "1" ]; then
+  printf '\n'
+  gut "Nur geprueft - es wurde nichts geaendert."
+  [ -n "$SCHMUTZIG" ] && warnung "Beim echten Lauf wuerden deine Aenderungen beiseite gelegt."
+  exit 0
+fi
+
+# --- 4. Nachfragen -----------------------------------------------------------
+
+if [ "$OHNE_RUECKFRAGE" != "1" ]; then
+  printf '\n%sJetzt aktualisieren auf %s? [j/N] %s' "$FETT" "$ZIEL" "$AUS"
+  read -r antwort </dev/tty || antwort=""
+  case "$antwort" in
+    [jJ]|[jJ][aA]) ;;
+    *) printf '\n'; warnung "Abgebrochen, nichts geaendert."; exit 0 ;;
+  esac
+fi
+
+# --- 5. Sicherung ------------------------------------------------------------
+
+if [ "$OHNE_SICHERUNG" = "1" ]; then
+  schritt "Sicherung wird uebersprungen"
+  warnung "Auf eigene Gefahr - eine Migration laesst sich nicht zurueckrollen."
+else
+  schritt "Sicherung"
+
+  if docker compose ps --status running --services 2>/dev/null | grep -qx sicherung; then
+    if docker compose exec -T sicherung /bin/sh /sicherung.sh; then
+      gut "Sicherung angelegt und selbst geprueft."
+    else
+      abbruch "Die Sicherung ist fehlgeschlagen. Es wird nichts aktualisiert.
+         Mit --ohne-sicherung laesst sich das uebergehen - aber ueberleg
+         dir das zweimal."
+    fi
+  else
+    warnung "Der Dienst 'sicherung' laeuft nicht - es wurde nichts gesichert."
+    if [ "$OHNE_RUECKFRAGE" != "1" ]; then
+      printf '\n    %sTrotzdem weitermachen? [j/N] %s' "$FETT" "$AUS"
+      read -r weiter </dev/tty || weiter=""
+      case "$weiter" in [jJ]|[jJ][aA]) ;; *) abbruch "Abgebrochen." ;; esac
+    fi
+  fi
+fi
+
+# --- 6. Umschalten und bauen -------------------------------------------------
+
+# Aenderungen an versionierten Dateien blockieren das Umschalten.
+#
+# Im Betrieb ist das der Normalfall: Man passt die docker-compose.yml an,
+# bis etwas laeuft. Genau diese Anpassungen sind spaeter oft schon
+# eingearbeitet - das Skript soll sie also nicht zum Hindernis machen.
+#
+# Verworfen wird trotzdem nichts stillschweigend. Standard ist "beiseite
+# legen": git stash macht es rueckholbar. Wer sie wirklich weghaben will,
+# nimmt --verwerfen.
+#
+# Die .env ist nie betroffen - sie ist nicht versioniert.
+schritt "Eigene Aenderungen"
+
+if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
+  printf '\n    Diese versionierten Dateien sind veraendert:\n\n'
+  git status --short --untracked-files=no | sed 's/^/      /'
+  printf '\n'
+
+  if [ "$VERWERFEN" = "1" ]; then
+    ENTSCHEIDUNG="verwerfen"
+  elif [ "$OHNE_RUECKFRAGE" = "1" ]; then
+    # Ohne jemanden zum Fragen: die sichere Variante.
+    ENTSCHEIDUNG="beiseite"
+  else
+    printf '    %s[b]%s eiseite legen (git stash, spaeter rueckholbar)\n' "$FETT" "$AUS"
+    printf '    %s[v]%s erwerfen (endgueltig weg)\n' "$FETT" "$AUS"
+    printf '    %s[a]%s bbrechen\n\n' "$FETT" "$AUS"
+    printf '    Was soll damit geschehen? [b/v/a] '
+    read -r wahl </dev/tty || wahl=""
+    case "$wahl" in
+      [bB]|'') ENTSCHEIDUNG="beiseite" ;;
+      [vV])    ENTSCHEIDUNG="verwerfen" ;;
+      *)       abbruch "Abgebrochen, nichts geaendert." ;;
+    esac
+  fi
+
+  if [ "$ENTSCHEIDUNG" = "verwerfen" ]; then
+    git checkout -- .
+    warnung "Aenderungen verworfen."
+  else
+    STASH_NAME="vor Update $(date +%Y-%m-%d_%H%M)"
+    git stash push --quiet --message "$STASH_NAME" -- . \
+      || abbruch "Konnte die Aenderungen nicht beiseite legen."
+    gut "Beiseite gelegt als: $STASH_NAME"
+    printf '      Ansehen:    git stash list\n'
+    printf '      Zurueck:    git stash pop\n'
+    printf '      Wegwerfen:  git stash drop\n'
+  fi
+else
+  gut "Arbeitskopie ist sauber"
+fi
+
+schritt "Umschalten auf $ZIEL"
+
+# Eine unversionierte Datei kann im Weg stehen, wenn die Zielfassung sie
+# fuehrt. Das passiert beim Update auf die Fassung, die dieses Skript
+# eingefuehrt hat: Man hat es sich von Hand geholt, jetzt gehoert es dazu.
+# Solche Dateien werden nicht weggeworfen, sondern beiseite geschoben.
+if ! git checkout --quiet "$ZIEL" 2>/dev/null; then
+  IM_WEG="$(git checkout "$ZIEL" 2>&1     | sed -n '/would be overwritten/,/^Aborting/p'     | grep -E '^\s' | tr -d '	 ' | grep -v '^$' || true)"
+
+  if [ -n "$IM_WEG" ]; then
+    ZEIT="$(date +%Y%m%d-%H%M%S)"
+    printf '    Diese unversionierten Dateien stehen im Weg:
+'
+    for datei in $IM_WEG; do
+      [ -e "$datei" ] || continue
+      mv "$datei" "${datei}.vor-update-${ZEIT}"
+      printf '      %s -> %s.vor-update-%s
+' "$datei" "$datei" "$ZEIT"
+    done
+    git checkout --quiet "$ZIEL" || abbruch "Das Umschalten auf $ZIEL ist fehlgeschlagen.
+         Deine Aenderungen liegen im Stash: git stash list"
+  else
+    abbruch "Das Umschalten auf $ZIEL ist fehlgeschlagen.
+$([ -n "$SCHMUTZIG" ] && printf '         Deine Aenderungen liegen im Stash: git stash list')"
+  fi
+fi
+
+gut "$(git describe --tags --always)"
+
+# Das Ausfuehrbarkeitsbit kommt normalerweise aus dem Repository mit. Wer
+# Dateien von Hand kopiert hat - etwa um an dieses Skript zu kommen, bevor
+# es in der laufenden Fassung existierte -, hat es verloren. Dann waere der
+# naechste Aufruf ein "Permission denied", und man sucht an der falschen
+# Stelle.
+chmod +x scripts/*.sh 2>/dev/null || true
+
+schritt "Bauen und starten"
+printf '    Das dauert beim ersten Mal einige Minuten.\n\n'
+
+if ! GIT_COMMIT="$(git rev-parse --short HEAD)" \
+     BUILD_ZEIT="$(date -Iseconds)" \
+     docker compose up -d --build; then
+  printf '\n'
+  abbruch "Bauen oder Starten ist fehlgeschlagen.
+         Die Quellen stehen jetzt auf $ZIEL, die Anwendung laeuft aber
+         noch mit dem alten Abbild - oder gar nicht.
+
+         Zurueck auf den vorherigen Stand:
+           git checkout $JETZT && docker compose up -d --build
+$([ -n "$SCHMUTZIG" ] && printf '\n         Deine Aenderungen liegen im Stash: git stash list')"
+fi
+
+# --- 7. Warten, bis die Anwendung antwortet ----------------------------------
+
+schritt "Warten auf die Anwendung"
+
+# Adresse und Port stehen in der .env - Standard ist die Loopback-Adresse.
+ADRESSE="$(grep -E '^APP_BIND=' .env | tail -1 | cut -d= -f2- | tr -d '"' || true)"
+PORT="$(grep -E '^APP_PORT=' .env | tail -1 | cut -d= -f2- | tr -d '"' || true)"
+[ -n "$ADRESSE" ] || ADRESSE="127.0.0.1"
+[ -n "$PORT" ] || PORT="3000"
+# Auf 0.0.0.0 kann man nicht zugreifen - dann ueber die Loopback-Adresse.
+[ "$ADRESSE" = "0.0.0.0" ] && ADRESSE="127.0.0.1"
+
+GESUND="http://${ADRESSE}:${PORT}/api/gesundheit"
+ANTWORT=""
+
+for _ in $(seq 1 60); do
+  ANTWORT="$(curl -fsS --max-time 5 "$GESUND" 2>/dev/null || true)"
+  case "$ANTWORT" in *'"bereit"'*) break ;; esac
+  printf '.'
+  sleep 3
+done
+printf '\n'
+
+case "$ANTWORT" in
+  *'"bereit"'*) gut "Die Anwendung antwortet." ;;
+  *)
+    printf '\n'
+    docker compose logs app --tail 40 | sed 's/^/    /'
+    abbruch "Die Anwendung antwortet nicht unter $GESUND.
+         Die letzten Zeilen aus dem Log stehen oben.
+         Zurueck geht es mit:  git checkout $JETZT && docker compose up -d --build"
+    ;;
+esac
+
+# --- 8. SQL-Skripte ----------------------------------------------------------
+
+schritt "Volltextsuche und Audit-Schutz"
+printf '    Diese beiden laufen nicht mit den Migrationen mit.\n'
+printf '    Sie sind idempotent - mehrfaches Ausfuehren schadet nicht.\n\n'
+
+PRISMA="node node_modules/prisma/build/index.js"
+
+for skript in volltextsuche audit-schutz; do
+  if docker compose exec -T app $PRISMA db execute \
+       --schema prisma/schema.prisma --file "prisma/sql/${skript}.sql" >/dev/null 2>&1; then
+    gut "${skript}.sql ausgefuehrt"
+  else
+    warnung "${skript}.sql ist fehlgeschlagen - bitte von Hand nachholen:"
+    printf '      docker compose exec app %s db execute \\\n' "$PRISMA"
+    printf '        --schema prisma/schema.prisma --file prisma/sql/%s.sql\n' "$skript"
+  fi
+done
+
+# --- 9. Nachschau ------------------------------------------------------------
+
+schritt "Ergebnis"
+
+LAEUFT="$(printf '%s' "$ANTWORT" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')"
+ERWARTET="${ZIEL#v}"
+
+printf '    Erwartet: %s\n' "$ERWARTET"
+printf '    Laeuft:   %s\n' "${LAEUFT:-unbekannt}"
+
+if [ "$LAEUFT" = "$ERWARTET" ]; then
+  printf '\n'
+  gut "Fertig. Version $ERWARTET laeuft."
+else
+  printf '\n'
+  warnung "Die laufende Fassung stimmt nicht mit der erwarteten ueberein."
+  warnung "Vermutlich hat der Bau den alten Behaelter stehen lassen:"
+  printf '      docker compose up -d --build --force-recreate app\n'
+fi
+
+printf '\n    Zustand:  docker compose ps\n'
+printf '    Log:      docker compose logs app --tail 50\n'
+printf '    Zurueck:  git checkout %s && docker compose up -d --build\n\n' "$JETZT"
+
+exit 0
+}
@@ -97,7 +97,12 @@ schreiben('src/lib/version.ts', ersetzt)

 // --- 3. CHANGELOG.md --------------------------------------------------------

-const heute = new Date().toISOString().slice(0, 10)
+// Deutsche Zeit, nicht UTC. Sonst bekommt eine Veroeffentlichung nach
+// 22 Uhr (Sommerzeit) das Datum des Vortages - dieselbe Zeitzonenfalle,
+// derentwegen die Fristen im Schema @db.Date sind.
+const heute = new Intl.DateTimeFormat('sv-SE', {
+  timeZone: 'Europe/Berlin',
+}).format(new Date())
 let changelog = lesen('CHANGELOG.md')

 const UNVEROEFFENTLICHT = '## [Unveröffentlicht]'
@@ -1,9 +1,16 @@
 'use client'

-import { useActionState } from 'react'
+import { useActionState, useEffect, useState } from 'react'
 import { useFormStatus } from 'react-dom'
-import { AlertCircle, Loader2, ShieldCheck } from 'lucide-react'
+import { useRouter } from 'next/navigation'
+import { AlertCircle, Fingerprint, Loader2, ShieldCheck } from 'lucide-react'
 import { anmeldungBestaetigen, type BestaetigenZustand } from '@/server/actions/bestaetigen'
+import { passkeyBestaetigen, passkeyBestaetigungStarten } from '@/server/actions/passkey'
+import {
+  browserSupportsWebAuthn,
+  passkeyBrowserfehler,
+  startAuthentication,
+} from '@/lib/passkey-browser'
 import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
@@ -19,10 +26,17 @@ function Absenden() {
  )
 }

-export function BestaetigenFormular({ weiter }: { weiter: string }) {
+export function BestaetigenFormular({
+  weiter,
+  passkeysMoeglich,
+}: {
+  weiter: string
+  passkeysMoeglich: boolean
+}) {
  const [zustand, aktion] = useActionState<BestaetigenZustand, FormData>(anmeldungBestaetigen, {})

  return (
+    <div className="space-y-5">
      <form action={aktion} className="space-y-4" noValidate>
        <input type="hidden" name="weiter" value={weiter} />

@@ -50,5 +64,95 @@ export function BestaetigenFormular({ weiter }: { weiter: string }) {

        <Absenden />
      </form>
+
+      {passkeysMoeglich && <PasskeyBestaetigung weiter={weiter} />}
+    </div>
+  )
+}
+
+/**
+ * Bestaetigung mit Passkey statt mit Passwort und Code.
+ *
+ * Geprueft wird zusaetzlich, dass der Passkey zum angemeldeten Benutzer
+ * gehoert - sonst koennte jemand mit dem eigenen Finger eine fremde,
+ * offen stehende Sitzung freischalten. Genau der Fall, gegen den diese
+ * Seite gebaut ist.
+ */
+function PasskeyBestaetigung({ weiter }: { weiter: string }) {
+  const router = useRouter()
+  const [browserKann, setBrowserKann] = useState(false)
+  const [laeuft, setLaeuft] = useState(false)
+  const [fehler, setFehler] = useState<string | null>(null)
+
+  useEffect(() => {
+    setBrowserKann(browserSupportsWebAuthn())
+  }, [])
+
+  async function bestaetigen() {
+    setFehler(null)
+    setLaeuft(true)
+
+    try {
+      const start = await passkeyBestaetigungStarten()
+      if (!start.ok) {
+        setFehler(start.fehler)
+        return
+      }
+
+      const antwort = await startAuthentication({ optionsJSON: start.optionen })
+      const ergebnis = await passkeyBestaetigen(JSON.stringify(antwort))
+
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.fehler)
+        return
+      }
+
+      router.replace(weiter)
+      router.refresh()
+    } catch (ausnahme) {
+      setFehler(passkeyBrowserfehler(ausnahme))
+    } finally {
+      setLaeuft(false)
+    }
+  }
+
+  if (!browserKann) return null
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center gap-3">
+        <span className="h-px flex-1 bg-border" />
+        <span className="text-xs uppercase tracking-wide text-muted-foreground">oder</span>
+        <span className="h-px flex-1 bg-border" />
+      </div>
+
+      {fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{fehler}</AlertDescription>
+        </Alert>
+      )}
+
+      <Button
+        type="button"
+        variant="outline"
+        size="lg"
+        className="w-full"
+        onClick={() => void bestaetigen()}
+        disabled={laeuft}
+      >
+        {laeuft ? (
+          <>
+            <Loader2 className="animate-spin" aria-hidden="true" />
+            Warte auf das Gerät …
+          </>
+        ) : (
+          <>
+            <Fingerprint aria-hidden="true" />
+            Mit Passkey bestätigen
+          </>
+        )}
+      </Button>
+    </div>
  )
 }
@@ -3,6 +3,7 @@ import { ShieldAlert } from 'lucide-react'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Alert, AlertDescription } from '@/components/ui/alert'
 import { erfordereBenutzer } from '@/lib/auth/sitzung'
+import { passkeysMoeglich } from '@/lib/auth/passkey'
 import { BestaetigenFormular } from './formular'

 export const metadata: Metadata = { title: 'Bestätigen' }
@@ -26,7 +27,7 @@ export default async function BestaetigenSeite({
          </CardDescription>
        </CardHeader>
        <CardContent>
-          <BestaetigenFormular weiter={weiter} />
+          <BestaetigenFormular weiter={weiter} passkeysMoeglich={passkeysMoeglich()} />
        </CardContent>
      </Card>

@@ -1,11 +1,13 @@
 import type { Metadata } from 'next'
 import Link from 'next/link'
-import { KeyRound, ShieldCheck } from 'lucide-react'
+import { Fingerprint, KeyRound, ShieldCheck } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { SeitenKopf } from '@/components/seiten-kopf'
 import { erfordereBenutzer } from '@/lib/auth/sitzung'
+import { passkeysDesBenutzers, passkeysMoeglich } from '@/lib/auth/passkey'
+import { PasskeyVerwaltung } from '@/components/konto/passkey-verwaltung'
 import { ROLLEN_BESCHRIFTUNG, ROLLEN_ERKLAERUNG } from '@/lib/auth/rollen'
 import { formatDatumZeit } from '@/lib/utils'
 import { PasswortFormular } from './passwort-formular'
@@ -16,10 +18,11 @@ export const dynamic = 'force-dynamic'
 export default async function KontoSeite() {
  const benutzer = await erfordereBenutzer()
  const codesUebrig = benutzer.wiederherstellungscodes.length
+  const passkeys = await passkeysDesBenutzers(benutzer.id)

  return (
    <div className="max-w-2xl space-y-6">
-      <SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten und zweiter Faktor." />
+      <SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten, zweiter Faktor und Passkeys." />

      <Card>
        <CardHeader className="pb-3">
@@ -89,6 +92,28 @@ export default async function KontoSeite() {
        </CardContent>
      </Card>

+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="flex items-center gap-2 text-base">
+            <Fingerprint className="size-5" aria-hidden="true" />
+            Passkeys
+          </CardTitle>
+          <CardDescription>
+            Anmelden mit Fingerabdruck, Gesicht oder Geräte-PIN — ohne E-Mail, Passwort und Code.
+            Ein Passkey gilt als zweiter Faktor, weil er Besitz des Geräts und dessen Entsperrung
+            verlangt. Er ist an diese Adresse gebunden: Auf einer nachgebauten Anmeldeseite
+            funktioniert er nicht.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <PasskeyVerwaltung
+            passkeys={passkeys}
+            zweiterFaktorAktiv={Boolean(benutzer.totpAktiviertAm)}
+            moeglich={passkeysMoeglich()}
+          />
+        </CardContent>
+      </Card>
+
      <Card>
        <CardHeader className="pb-3">
          <CardTitle className="flex items-center gap-2 text-base">
@@ -34,6 +34,8 @@ const AKTION_BESCHRIFTUNG: Record<AuditAktion, string> = {
  ANMELDUNG_FEHLGESCHLAGEN: 'Anmeldung fehlgeschlagen',
  ABMELDUNG: 'abgemeldet',
  ZWEITER_FAKTOR_EINGERICHTET: 'zweiter Faktor eingerichtet',
+  PASSKEY_REGISTRIERT: 'Passkey eingerichtet',
+  PASSKEY_ENTFERNT: 'Passkey entfernt',
  PASSWORT_GEAENDERT: 'Passwort geändert',
  ROLLE_GEAENDERT: 'Rolle geändert',
  FREIGABE_GEAENDERT: 'Freigabe geändert',
@@ -41,7 +43,8 @@ const AKTION_BESCHRIFTUNG: Record<AuditAktion, string> = {

 function variante(aktion: AuditAktion) {
  if (aktion === 'ANMELDUNG_FEHLGESCHLAGEN' || aktion === 'ENDGUELTIG_GELOESCHT') return 'rot'
-  if (aktion === 'GELOESCHT' || aktion === 'EXPORTIERT') return 'orange'
+  if (aktion === 'GELOESCHT' || aktion === 'EXPORTIERT' || aktion === 'PASSKEY_ENTFERNT')
+    return 'orange'
  if (aktion === 'ERSTELLT') return 'gruen'
  return 'secondary'
 }
@@ -4,6 +4,8 @@ import { ShieldCheck } from 'lucide-react'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { aktuellerBenutzer } from '@/lib/auth/sitzung'
 import { db } from '@/lib/db'
+import { passkeysMoeglich } from '@/lib/auth/passkey'
+import { PasskeyAnmeldung } from '@/components/passkey-anmeldung'
 import { AnmeldeFormular } from './formular'

 export const metadata: Metadata = { title: 'Anmelden' }
@@ -32,10 +34,14 @@ export default async function AnmeldenSeite({
          <CardTitle>Anmelden</CardTitle>
          <CardDescription>
            E-Mail, Passwort und der Code aus deiner Authenticator-App — alle drei zusammen.
+            {passkeysMoeglich() && ' Oder in einem Schritt mit deinem Passkey.'}
          </CardDescription>
        </CardHeader>
-        <CardContent>
+        <CardContent className="space-y-5">
          <AnmeldeFormular weiter={weiter} />
+          {/* Nur wenn der Server ueber https laeuft - sonst gibt der
+              Browser WebAuthn gar nicht frei. */}
+          {passkeysMoeglich() && <PasskeyAnmeldung weiter={weiter} />}
        </CardContent>
      </Card>

@@ -43,7 +49,9 @@ export default async function AnmeldenSeite({
        <ShieldCheck className="mt-0.5 size-4 shrink-0" aria-hidden="true" />
        <p>
          Hier liegen Gesundheits- und Vermögensdaten einer betreuten Person. Der zweite Faktor ist
-          deshalb Pflicht und lässt sich nicht abschalten.
+          deshalb Pflicht und lässt sich nicht abschalten. Ein Passkey erfüllt ihn ebenfalls: Er
+          verlangt Fingerabdruck, Gesicht oder Geräte-PIN — und lässt sich, anders als ein
+          abgetippter Code, nicht auf einer nachgebauten Seite abgreifen.
        </p>
      </div>
    </>
@@ -12,6 +12,8 @@ import {
  versuchFesthalten,
 } from '@/lib/auth/ratelimit'
 import { protokollieren } from '@/lib/audit'
+import { PasskeyFehler, anmeldungPruefen } from '@/lib/auth/passkey'
+import type { AuthenticationResponseJSON } from '@simplewebauthn/server'

 /**
 * Anmeldung: E-Mail + Passwort + TOTP - alle drei zusammen, in einem Schritt.
@@ -30,6 +32,8 @@ export type AnmeldeGrund =
  | 'gesperrt'
  | 'konto-inaktiv'
  | 'code-falsch'
+  /** Passkey-Fehler; der genaue Grund haengt mit Doppelpunkt daran. */
+  | 'passkey'

 /**
 * Auth.js transportiert Fehler aus authorize() nur ueber das Feld "code".
@@ -45,6 +49,19 @@ export class AnmeldeFehler extends CredentialsSignin {
  }
 }

+/**
+ * Wie AnmeldeFehler, nur fuer Passkeys: der Grund wird als "passkey:<grund>"
+ * kodiert, damit die Anmeldeseite die passende Erklaerung zeigen kann.
+ */
+export class PasskeyAnmeldeFehler extends CredentialsSignin {
+  code: string
+
+  constructor(grund: string) {
+    super(grund)
+    this.code = `passkey:${grund}`
+  }
+}
+
 function ipAusAnfrage(anfrage: Request | undefined): string | null {
  if (!anfrage) return null
  const weitergeleitet = anfrage.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
@@ -203,6 +220,101 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
        }
      },
    }),
+
+    /**
+     * Anmeldung mit Passkey - ein Schritt, ohne E-Mail und ohne Passwort.
+     *
+     * Die vollstaendige Pruefung laeuft hier drin und nicht in der Server
+     * Action davor. Das ist Absicht: Wuerde die Action pruefen und das
+     * Ergebnis anschliessend an signIn() weiterreichen, gaebe es einen
+     * Zwischenzustand, dem authorize() glauben muesste. Genau solche
+     * "war schon geprueft"-Uebergaben sind die Stelle, an der sich
+     * Anmeldungen faelschen lassen. Hier gibt es sie nicht.
+     */
+    Credentials({
+      id: 'passkey',
+      name: 'Passkey',
+      credentials: {
+        antwort: { label: 'Antwort des Authenticators', type: 'text' },
+      },
+
+      async authorize(daten, anfrage) {
+        const ip = ipAusAnfrage(anfrage)
+
+        let antwort: AuthenticationResponseJSON
+        try {
+          antwort = JSON.parse(String(daten?.antwort ?? '')) as AuthenticationResponseJSON
+        } catch {
+          throw new PasskeyAnmeldeFehler('ungueltig')
+        }
+
+        let geprueft
+        try {
+          geprueft = await anmeldungPruefen(antwort)
+        } catch (fehler) {
+          // Fehlversuche zaehlen mit, auch wenn der Zugang unbekannt ist -
+          // sonst waere der Passkey-Weg ein Schlupfloch an der Sperre vorbei.
+          await versuchFesthalten('(passkey)', ip, false, 'passkey-ungueltig')
+          await protokollieren({
+            aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
+            entitaet: 'User',
+            userEmail: '(passkey)',
+            bezeichnung:
+              fehler instanceof PasskeyFehler ? `Passkey: ${fehler.grund}` : 'Passkey abgewiesen',
+          })
+          throw new PasskeyAnmeldeFehler(
+            fehler instanceof PasskeyFehler ? fehler.grund : 'ungueltig',
+          )
+        }
+
+        const { benutzer, passkey } = geprueft
+
+        // Die Sperre gilt fuer den Zugang, nicht fuer das Verfahren. Sie
+        // wird erst hier geprueft, weil vorher niemand weiss, wer sich
+        // anmeldet - erraten laesst sich ein Passkey ohnehin nicht.
+        const sperre = await anmeldungErlaubt(benutzer.email, ip)
+        if (sperre.gesperrt) {
+          await versuchFesthalten(benutzer.email, ip, false, 'gesperrt')
+          throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
+        }
+
+        if (!benutzer.aktiv || benutzer.geloeschtAm) {
+          await versuchFesthalten(benutzer.email, ip, false, 'konto-inaktiv')
+          throw new AnmeldeFehler('konto-inaktiv')
+        }
+
+        await Promise.all([
+          versuchFesthalten(benutzer.email, ip, true, 'passkey'),
+          fehlversucheZuruecksetzen(benutzer.email),
+          db.user.update({
+            where: { id: benutzer.id },
+            data: { letzteAnmeldung: new Date() },
+          }),
+          protokollieren({
+            aktion: 'ANMELDUNG',
+            entitaet: 'User',
+            entitaetId: benutzer.id,
+            userId: benutzer.id,
+            userEmail: benutzer.email,
+            userName: benutzer.name,
+            bezeichnung: `Mit Passkey „${passkey.name}“`,
+          }),
+        ])
+
+        return {
+          id: benutzer.id,
+          email: benutzer.email,
+          name: benutzer.name,
+          rolle: benutzer.rolle,
+          sitzungsGeneration: benutzer.sitzungsGeneration,
+          // Ein Passkey mit Nutzerverifikation IST der zweite Faktor. Ohne
+          // eingerichtetes TOTP laesst er sich gar nicht erst anlegen, das
+          // Flag ist hier also immer wahr - es wird trotzdem aus dem
+          // Benutzer gelesen und nicht fest gesetzt.
+          zweiterFaktorAktiv: Boolean(benutzer.totpAktiviertAm),
+        }
+      },
+    }),
  ],

  callbacks: {
@@ -0,0 +1,277 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useRouter } from 'next/navigation'
+import {
+  AlertCircle,
+  CheckCircle2,
+  Fingerprint,
+  Loader2,
+  Plus,
+  Smartphone,
+  Trash2,
+} from 'lucide-react'
+import {
+  passkeyEinrichtungAbschliessen,
+  passkeyEinrichtungStarten,
+  passkeyEntfernen,
+} from '@/server/actions/passkey'
+import {
+  browserSupportsWebAuthn,
+  passkeyBrowserfehler,
+  startRegistration,
+} from '@/lib/passkey-browser'
+import type { PasskeyUebersicht } from '@/lib/auth/passkey'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Feld } from '@/components/feld'
+import { formatDatum, formatDatumZeit } from '@/lib/utils'
+
+/**
+ * Verwaltung der eigenen Passkeys unter "Mein Konto".
+ *
+ * Die Liste kommt vom Server; nach jeder Aenderung wird die Seite neu
+ * geladen (router.refresh) statt den Zustand hier mitzufuehren. Bei einer
+ * Handvoll Eintraegen ist das die ehrlichere Loesung: Was auf dem Bildschirm
+ * steht, steht auch so in der Datenbank.
+ */
+export function PasskeyVerwaltung({
+  passkeys,
+  zweiterFaktorAktiv,
+  moeglich,
+}: {
+  passkeys: PasskeyUebersicht[]
+  zweiterFaktorAktiv: boolean
+  /** Ob der Server Passkeys ueberhaupt anbieten kann (https). */
+  moeglich: boolean
+}) {
+  const router = useRouter()
+  const [browserKann, setBrowserKann] = useState(false)
+  const [name, setName] = useState('')
+  const [laeuft, setLaeuft] = useState(false)
+  const [entfernt, setEntfernt] = useState<string | null>(null)
+  const [fehler, setFehler] = useState<string | null>(null)
+  const [erfolg, setErfolg] = useState<string | null>(null)
+  const [nachfrage, setNachfrage] = useState<string | null>(null)
+
+  useEffect(() => {
+    setBrowserKann(browserSupportsWebAuthn())
+  }, [])
+
+  async function einrichten() {
+    setFehler(null)
+    setErfolg(null)
+
+    if (name.trim() === '') {
+      setFehler('Bitte gib dem Gerät zuerst einen Namen.')
+      return
+    }
+
+    setLaeuft(true)
+    try {
+      const start = await passkeyEinrichtungStarten()
+      if (!start.ok) {
+        setFehler(start.fehler)
+        return
+      }
+
+      const antwort = await startRegistration({ optionsJSON: start.optionen })
+      const ergebnis = await passkeyEinrichtungAbschliessen(name, JSON.stringify(antwort))
+
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.fehler)
+        return
+      }
+
+      setName('')
+      setErfolg(ergebnis.meldung ?? 'Passkey eingerichtet.')
+      router.refresh()
+    } catch (ausnahme) {
+      setFehler(passkeyBrowserfehler(ausnahme, true))
+    } finally {
+      setLaeuft(false)
+    }
+  }
+
+  async function entfernen(id: string) {
+    setFehler(null)
+    setErfolg(null)
+    setNachfrage(null)
+    setEntfernt(id)
+
+    try {
+      const ergebnis = await passkeyEntfernen(id)
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.fehler)
+        return
+      }
+      setErfolg(ergebnis.meldung ?? 'Passkey entfernt.')
+      router.refresh()
+    } finally {
+      setEntfernt(null)
+    }
+  }
+
+  if (!moeglich) {
+    return (
+      <Alert variant="hinweis">
+        <AlertCircle aria-hidden="true" />
+        <AlertDescription>
+          Passkeys brauchen eine verschlüsselte Verbindung. Diese Installation ist nicht über
+          <code className="mx-1 rounded bg-muted px-1 py-0.5 text-xs">https</code>
+          erreichbar — sobald sie es ist, erscheint hier die Verwaltung.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  if (!zweiterFaktorAktiv) {
+    return (
+      <Alert variant="hinweis">
+        <AlertCircle aria-hidden="true" />
+        <AlertDescription>
+          Richte zuerst die Authenticator-App ein. Ein Passkey hängt an einem Gerät — ginge das
+          verloren und wäre er der einzige Weg hinein, käme niemand mehr an die Akte. Der Passkey
+          ist die bequeme Tür, nicht die einzige.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  return (
+    <div className="space-y-4">
+      {fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{fehler}</AlertDescription>
+        </Alert>
+      )}
+
+      {erfolg && (
+        <Alert variant="erfolg">
+          <CheckCircle2 aria-hidden="true" />
+          <AlertDescription>{erfolg}</AlertDescription>
+        </Alert>
+      )}
+
+      {passkeys.length === 0 ? (
+        <p className="text-sm text-muted-foreground">
+          Noch kein Passkey eingerichtet. Du meldest dich weiterhin mit E-Mail, Passwort und Code an
+          — das bleibt auch danach möglich.
+        </p>
+      ) : (
+        <ul className="divide-y rounded-md border">
+          {passkeys.map((passkey) => (
+            <li key={passkey.id} className="flex flex-wrap items-start gap-3 p-3">
+              <Smartphone
+                className="mt-0.5 size-5 shrink-0 text-muted-foreground"
+                aria-hidden="true"
+              />
+
+              <div className="min-w-0 flex-1">
+                <p className="font-medium">{passkey.name}</p>
+                <p className="text-xs text-muted-foreground">
+                  Eingerichtet am {formatDatum(passkey.erstelltAm)}
+                  {passkey.zuletztBenutztAm
+                    ? ` · zuletzt benutzt ${formatDatumZeit(passkey.zuletztBenutztAm)}`
+                    : ' · noch nicht benutzt'}
+                </p>
+                {passkey.geraeteArt === 'singleDevice' && (
+                  <p className="mt-1 text-xs text-muted-foreground">
+                    Liegt nur auf diesem Gerät. Geht es verloren, ist auch der Passkey weg.
+                  </p>
+                )}
+              </div>
+
+              {passkey.gesichert && (
+                <Badge variant="secondary" className="shrink-0">
+                  gesichert
+                </Badge>
+              )}
+
+              {nachfrage === passkey.id ? (
+                <div className="flex shrink-0 items-center gap-2">
+                  <Button
+                    type="button"
+                    variant="destructive"
+                    size="sm"
+                    onClick={() => void entfernen(passkey.id)}
+                    disabled={entfernt === passkey.id}
+                  >
+                    {entfernt === passkey.id ? (
+                      <Loader2 className="animate-spin" aria-hidden="true" />
+                    ) : null}
+                    Wirklich entfernen
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => setNachfrage(null)}
+                  >
+                    Abbrechen
+                  </Button>
+                </div>
+              ) : (
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="sm"
+                  className="shrink-0"
+                  onClick={() => setNachfrage(passkey.id)}
+                  aria-label={`Passkey „${passkey.name}“ entfernen`}
+                >
+                  <Trash2 aria-hidden="true" />
+                  Entfernen
+                </Button>
+              )}
+            </li>
+          ))}
+        </ul>
+      )}
+
+      {browserKann ? (
+        <div className="space-y-3 rounded-md border border-dashed p-3">
+          <Feld
+            id="passkey-name"
+            beschriftung="Neues Gerät"
+            erklaerung="Ein Name, an dem du es später wiedererkennst — etwa „iPhone“ oder „Laptop Büro“."
+          >
+            <Input
+              id="passkey-name"
+              value={name}
+              onChange={(ereignis) => setName(ereignis.target.value)}
+              maxLength={60}
+              placeholder="iPhone"
+              autoComplete="off"
+            />
+          </Feld>
+
+          <Button type="button" onClick={() => void einrichten()} disabled={laeuft}>
+            {laeuft ? (
+              <>
+                <Loader2 className="animate-spin" aria-hidden="true" />
+                Warte auf das Gerät …
+              </>
+            ) : (
+              <>
+                <Plus aria-hidden="true" />
+                Passkey einrichten
+              </>
+            )}
+          </Button>
+        </div>
+      ) : (
+        <Alert variant="hinweis">
+          <Fingerprint aria-hidden="true" />
+          <AlertDescription>
+            Dieser Browser kann keine Passkeys. Auf einem anderen Gerät klappt es vermutlich — die
+            bereits eingerichteten bleiben davon unberührt.
+          </AlertDescription>
+        </Alert>
+      )}
+    </div>
+  )
+}
@@ -0,0 +1,104 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { AlertCircle, Fingerprint, Loader2 } from 'lucide-react'
+import { passkeyAnmeldungAbschliessen, passkeyAnmeldungStarten } from '@/server/actions/passkey'
+import {
+  browserSupportsWebAuthn,
+  passkeyBrowserfehler,
+  startAuthentication,
+} from '@/lib/passkey-browser'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+
+/**
+ * Knopf "Mit Passkey anmelden" auf der Anmeldeseite.
+ *
+ * Der Ablauf ist dreiteilig: Optionen vom Server holen, das Geraet fragen,
+ * die Antwort zurueckschicken. Gelingt der letzte Schritt, leitet die Server
+ * Action weiter - dieser Baustein sieht das Ergebnis dann gar nicht mehr.
+ *
+ * Sichtbar ist der Knopf nur, wenn der Server ihn anbietet (https) UND der
+ * Browser WebAuthn kann. Die zweite Pruefung laeuft erst nach dem ersten
+ * Rendern: Auf dem Server gibt es kein navigator-Objekt, und ein Knopf, der
+ * beim Laden verschwindet, ist unangenehmer als einer, der kurz spaeter
+ * erscheint.
+ */
+export function PasskeyAnmeldung({ weiter }: { weiter: string }) {
+  const [laeuft, setLaeuft] = useState(false)
+  const [fehler, setFehler] = useState<string | null>(null)
+  const [browserKann, setBrowserKann] = useState(false)
+
+  useEffect(() => {
+    setBrowserKann(browserSupportsWebAuthn())
+  }, [])
+
+  async function anmelden() {
+    setFehler(null)
+    setLaeuft(true)
+
+    try {
+      const start = await passkeyAnmeldungStarten()
+      if (!start.ok) {
+        setFehler(start.fehler)
+        return
+      }
+
+      const antwort = await startAuthentication({
+        optionsJSON: start.optionen,
+      })
+
+      const ergebnis = await passkeyAnmeldungAbschliessen(JSON.stringify(antwort), weiter)
+      // Bei Erfolg wird gar nichts zurueckgegeben - die Action leitet weiter.
+      if (!ergebnis.ok) setFehler(ergebnis.fehler)
+    } catch (ausnahme) {
+      setFehler(passkeyBrowserfehler(ausnahme))
+    } finally {
+      setLaeuft(false)
+    }
+  }
+
+  if (!browserKann) return null
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center gap-3">
+        <span className="h-px flex-1 bg-border" />
+        <span className="text-xs uppercase tracking-wide text-muted-foreground">oder</span>
+        <span className="h-px flex-1 bg-border" />
+      </div>
+
+      {fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{fehler}</AlertDescription>
+        </Alert>
+      )}
+
+      <Button
+        type="button"
+        variant="outline"
+        size="lg"
+        className="w-full"
+        onClick={anmelden}
+        disabled={laeuft}
+      >
+        {laeuft ? (
+          <>
+            <Loader2 className="animate-spin" aria-hidden="true" />
+            Warte auf das Gerät …
+          </>
+        ) : (
+          <>
+            <Fingerprint aria-hidden="true" />
+            Mit Passkey anmelden
+          </>
+        )}
+      </Button>
+
+      <p className="text-center text-xs text-muted-foreground">
+        Fingerabdruck, Gesicht oder Geräte-PIN — ohne E-Mail und Passwort.
+      </p>
+    </div>
+  )
+}
@@ -0,0 +1,464 @@
+import 'server-only'
+import {
+  generateAuthenticationOptions,
+  generateRegistrationOptions,
+  verifyAuthenticationResponse,
+  verifyRegistrationResponse,
+} from '@simplewebauthn/server'
+import type {
+  AuthenticationResponseJSON,
+  AuthenticatorTransportFuture,
+  PublicKeyCredentialCreationOptionsJSON,
+  PublicKeyCredentialRequestOptionsJSON,
+  RegistrationResponseJSON,
+} from '@simplewebauthn/server'
+import type { Passkey, PasskeyAnfrageArt, User } from '@prisma/client'
+import { db } from '@/lib/db'
+import { env } from '@/lib/env'
+
+/**
+ * Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
+ *
+ * ---------------------------------------------------------------------------
+ * Warum ein Passkey hier den zweiten Faktor ERSETZEN darf
+ * ---------------------------------------------------------------------------
+ *
+ * Die Zusage dieser Anwendung lautet: zwei Faktoren, nicht abschaltbar. Ein
+ * Passkey sieht auf den ersten Blick nach einem einzigen Klick aus - er ist
+ * aber zwei Faktoren, sofern der Authenticator die Nutzerverifikation
+ * durchfuehrt:
+ *
+ *   1. Besitz  - der private Schluessel liegt im Sicherheitsbaustein des
+ *                Geraets und laesst sich nicht auslesen.
+ *   2. Wissen  - Geraete-PIN
+ *      oder Sein - Fingerabdruck, Gesicht.
+ *
+ * Diese Bedingung wird nicht gehofft, sondern erzwungen: bei der Anmeldung
+ * ebenso wie beim Einrichten steht userVerification auf "required", und die
+ * Pruefung laeuft mit requireUserVerification. Ein Authenticator, der nur
+ * Anwesenheit meldet (blosses Antippen), wird abgewiesen.
+ *
+ * Zusaetzlich ist ein Passkey dem Zahlenkomma aus Passwort + TOTP in einem
+ * Punkt ueberlegen: Er ist an die Domain gebunden. Eine nachgebaute
+ * Anmeldeseite bekommt keine Signatur - Phishing, der haeufigste Weg an
+ * einen TOTP-Code zu kommen, laeuft ins Leere.
+ *
+ * ---------------------------------------------------------------------------
+ * Warum TOTP trotzdem zuerst eingerichtet sein muss
+ * ---------------------------------------------------------------------------
+ *
+ * Ein Passkey haengt am Geraet. Geht das Handy verloren und ist es der
+ * einzige Zugangsweg, ist die Akte zu - und in ihr stehen Unterlagen, die
+ * eine betreute Person braucht. Deshalb laesst sich ein Passkey erst
+ * anlegen, wenn der zweite Faktor samt Wiederherstellungscodes steht. Der
+ * Passkey ist die bequeme Tuer, nicht die einzige.
+ */
+
+/**
+ * Wie lange eine begonnene Passkey-Aktion abgeschlossen werden kann.
+ *
+ * Fuenf Minuten sind reichlich fuer "Handy suchen, Finger auflegen" und
+ * kurz genug, dass eine abgefangene Challenge nichts mehr wert ist.
+ */
+export const ANFRAGE_GUELTIG_SEKUNDEN = 300
+
+/**
+ * Obergrenze je Benutzer. Nicht aus technischen Gruenden - die Liste soll
+ * uebersichtlich bleiben, damit ein fremder Eintrag auffaellt.
+ */
+export const MAX_PASSKEYS_JE_BENUTZER = 10
+
+/**
+ * Obergrenze fuer gleichzeitig offene Anmeldeversuche.
+ *
+ * Eine Anmeldung darf jeder beginnen, auch ohne angemeldet zu sein - anders
+ * ginge es nicht. Damit daraus kein Weg wird, die Tabelle vollzuschreiben,
+ * gilt eine Decke. Fuer eine Handvoll Benutzer ist sie unerreichbar; fuer
+ * ein Skript ist sie schnell erreicht, und dann ist Schluss.
+ */
+export const MAX_OFFENE_ANMELDUNGEN = 200
+
+export type PasskeyGrund =
+  | 'nicht-verfuegbar'
+  | 'anfrage-abgelaufen'
+  | 'unbekannt'
+  | 'nicht-verifiziert'
+  | 'geklont'
+  | 'bereits-vorhanden'
+  | 'zu-viele'
+  | 'zweiter-faktor-fehlt'
+  | 'zu-viele-anfragen'
+  | 'ungueltig'
+
+/** Traegt einen Grund, damit die Oberflaeche einen brauchbaren Satz daraus macht. */
+export class PasskeyFehler extends Error {
+  constructor(
+    readonly grund: PasskeyGrund,
+    nachricht?: string,
+  ) {
+    super(nachricht ?? grund)
+    this.name = 'PasskeyFehler'
+  }
+}
+
+export const PASSKEY_MELDUNG: Record<PasskeyGrund, string> = {
+  'nicht-verfuegbar':
+    'Passkeys brauchen eine verschlüsselte Verbindung. Diese Installation läuft nicht über https — ' +
+    'melde dich mit Passwort und Code an.',
+  'anfrage-abgelaufen':
+    'Das hat zu lange gedauert. Bitte klicke noch einmal auf „Mit Passkey anmelden“.',
+  unbekannt:
+    'Dieser Passkey ist hier nicht hinterlegt. Vielleicht gehört er zu einer anderen Adresse ' +
+    'oder wurde inzwischen entfernt.',
+  'nicht-verifiziert':
+    'Dein Gerät hat den Passkey ohne Fingerabdruck, Gesichtserkennung oder PIN freigegeben. ' +
+    'Das wäre nur ein Faktor — und hier liegen Gesundheitsdaten. Bitte richte die Gerätesperre ein.',
+  geklont:
+    'Der Zähler dieses Passkeys ist nicht weitergelaufen. Das kann auf eine Kopie hindeuten. ' +
+    'Der Passkey wurde nicht akzeptiert — bitte entferne ihn und richte einen neuen ein.',
+  'bereits-vorhanden': 'Dieser Passkey ist bereits hinterlegt.',
+  'zu-viele': `Es sind höchstens ${MAX_PASSKEYS_JE_BENUTZER} Passkeys möglich. Entferne zuerst einen alten.`,
+  'zweiter-faktor-fehlt':
+    'Richte zuerst die Authenticator-App ein. Ein Passkey hängt an einem Gerät — ohne einen ' +
+    'zweiten Weg wäre der Zugang bei Verlust zu.',
+  'zu-viele-anfragen':
+    'Gerade laufen ungewöhnlich viele Anmeldeversuche. Bitte versuche es in ein paar Minuten ' +
+    'noch einmal oder melde dich mit Passwort und Code an.',
+  ungueltig: 'Der Passkey konnte nicht geprüft werden. Bitte versuche es noch einmal.',
+}
+
+/**
+ * Kopiert Bytes in ein Uint8Array mit eigenem, nicht geteiltem Puffer.
+ *
+ * Prisma liefert einen Buffer, TextEncoder ein Uint8Array<ArrayBufferLike> -
+ * die Bibliothek verlangt ausdruecklich Uint8Array<ArrayBuffer>. Der
+ * Unterschied ist nicht kosmetisch: ArrayBufferLike schliesst
+ * SharedArrayBuffer ein, und auf geteiltem Speicher darf keine
+ * Signaturpruefung arbeiten, weil sich der Inhalt waehrenddessen aendern
+ * koennte.
+ */
+function alsUint8(daten: Uint8Array): Uint8Array<ArrayBuffer> {
+  const kopie = new Uint8Array(new ArrayBuffer(daten.byteLength))
+  kopie.set(daten)
+  return kopie
+}
+
+/**
+ * Holt die Challenge aus der Antwort des Browsers.
+ *
+ * Sie steckt in den clientData, die der Authenticator mitsigniert hat. Wir
+ * lesen sie hier nur, um die passende Zeile zu finden - geprueft wird sie
+ * anschliessend von der Bibliothek gegen genau diesen Wert.
+ *
+ * Exportiert, damit sie sich ohne Datenbank pruefen laesst.
+ */
+export function challengeAusAntwort(clientDataJSON: string): string {
+  try {
+    const roh = Buffer.from(clientDataJSON, 'base64url').toString('utf8')
+    const gelesen: unknown = JSON.parse(roh)
+    const challenge =
+      typeof gelesen === 'object' && gelesen !== null && 'challenge' in gelesen
+        ? (gelesen as { challenge: unknown }).challenge
+        : null
+    if (typeof challenge !== 'string' || challenge.length === 0) {
+      throw new PasskeyFehler('ungueltig')
+    }
+    return challenge
+  } catch (fehler) {
+    if (fehler instanceof PasskeyFehler) throw fehler
+    throw new PasskeyFehler('ungueltig')
+  }
+}
+
+/** Legt eine Challenge ab. Nur der Server kennt sie, bis der Browser antwortet. */
+async function anfrageMerken(
+  challenge: string,
+  art: PasskeyAnfrageArt,
+  userId: string | null,
+): Promise<void> {
+  await db.passkeyAnfrage.create({
+    data: {
+      challenge,
+      art,
+      userId,
+      ablaufAm: new Date(Date.now() + ANFRAGE_GUELTIG_SEKUNDEN * 1000),
+    },
+  })
+}
+
+/**
+ * Verbraucht eine Challenge - und zwar genau einmal.
+ *
+ * Das DELETE ist der eigentliche Schutz gegen das erneute Einspielen einer
+ * mitgeschnittenen Antwort: Die Datenbank entscheidet, wer die Zeile
+ * bekommt. Wurde keine Zeile geloescht, war sie schon verbraucht oder
+ * abgelaufen - beides fuehrt zum Abbruch.
+ */
+async function anfrageVerbrauchen(
+  challenge: string,
+  art: PasskeyAnfrageArt,
+  userId?: string,
+): Promise<void> {
+  const { count } = await db.passkeyAnfrage.deleteMany({
+    where: {
+      challenge,
+      art,
+      ablaufAm: { gt: new Date() },
+      ...(userId ? { userId } : {}),
+    },
+  })
+  if (count !== 1) throw new PasskeyFehler('anfrage-abgelaufen')
+}
+
+/** Wirft, wenn die Installation gar nicht ueber https erreichbar ist. */
+function verfuegbarkeitPruefen(): void {
+  if (!env.passkey.sicherAufrufbar) throw new PasskeyFehler('nicht-verfuegbar')
+}
+
+/** Ob Passkeys unter der aktuellen Adresse ueberhaupt angeboten werden koennen. */
+export function passkeysMoeglich(): boolean {
+  return env.passkey.sicherAufrufbar
+}
+
+// ---------------------------------------------------------------------------
+// Einrichten
+// ---------------------------------------------------------------------------
+
+export async function registrierungVorbereiten(
+  benutzer: User,
+): Promise<PublicKeyCredentialCreationOptionsJSON> {
+  verfuegbarkeitPruefen()
+
+  // Ohne Authenticator-App kein Passkey - siehe Kopfkommentar.
+  if (!benutzer.totpAktiviertAm) throw new PasskeyFehler('zweiter-faktor-fehlt')
+
+  const vorhandene = await db.passkey.findMany({
+    where: { userId: benutzer.id },
+    select: { credentialId: true, transports: true },
+  })
+
+  if (vorhandene.length >= MAX_PASSKEYS_JE_BENUTZER) throw new PasskeyFehler('zu-viele')
+
+  const optionen = await generateRegistrationOptions({
+    rpName: env.passkey.rpName,
+    rpID: env.passkey.rpId,
+    // Stabil aus der Benutzer-ID. Damit erkennt ein Geraet beim zweiten
+    // Einrichten, dass es derselbe Zugang ist, und ersetzt den Eintrag,
+    // statt einen zweiten anzulegen.
+    userID: alsUint8(new TextEncoder().encode(benutzer.id)),
+    userName: benutzer.email,
+    userDisplayName: benutzer.name,
+    // Keine Attestierung anfordern: Wir wollen nicht wissen, welches
+    // Fabrikat der Benutzer benutzt. Das ist ein Datum, das uns nichts
+    // angeht, und es macht den Ablauf auf manchen Geraeten umstaendlicher.
+    attestationType: 'none',
+    // Schon hinterlegte Schluessel ausschliessen, sonst legt dasselbe
+    // Geraet stillschweigend einen zweiten an.
+    excludeCredentials: vorhandene.map((eintrag) => ({
+      id: eintrag.credentialId,
+      transports: eintrag.transports as AuthenticatorTransportFuture[],
+    })),
+    authenticatorSelection: {
+      // "required": der Schluessel wird auf dem Geraet auffindbar
+      // gespeichert. Nur dann geht die Anmeldung ohne vorherige Eingabe
+      // der E-Mail-Adresse.
+      residentKey: 'required',
+      requireResidentKey: true,
+      // Der Punkt, an dem aus einem Faktor zwei werden.
+      userVerification: 'required',
+    },
+    timeout: ANFRAGE_GUELTIG_SEKUNDEN * 1000,
+  })
+
+  await anfrageMerken(optionen.challenge, 'REGISTRIERUNG', benutzer.id)
+  return optionen
+}
+
+export async function registrierungPruefen(
+  benutzer: User,
+  name: string,
+  antwort: RegistrationResponseJSON,
+): Promise<Passkey> {
+  verfuegbarkeitPruefen()
+  if (!benutzer.totpAktiviertAm) throw new PasskeyFehler('zweiter-faktor-fehlt')
+
+  const challenge = challengeAusAntwort(antwort.response.clientDataJSON)
+  await anfrageVerbrauchen(challenge, 'REGISTRIERUNG', benutzer.id)
+
+  let ergebnis
+  try {
+    ergebnis = await verifyRegistrationResponse({
+      response: antwort,
+      expectedChallenge: challenge,
+      expectedOrigin: env.passkey.herkunft,
+      expectedRPID: env.passkey.rpId,
+      requireUserVerification: true,
+    })
+  } catch {
+    throw new PasskeyFehler('ungueltig')
+  }
+
+  if (!ergebnis.verified) throw new PasskeyFehler('ungueltig')
+
+  const { credential, credentialDeviceType, credentialBackedUp, userVerified } =
+    ergebnis.registrationInfo
+
+  // Doppelte Absicherung: die Bibliothek prueft es bereits, aber diese
+  // Zusage ist zu wichtig, um sie an einer Voreinstellung haengen zu lassen.
+  if (!userVerified) throw new PasskeyFehler('nicht-verifiziert')
+
+  const schonDa = await db.passkey.findUnique({
+    where: { credentialId: credential.id },
+    select: { id: true },
+  })
+  if (schonDa) throw new PasskeyFehler('bereits-vorhanden')
+
+  return db.passkey.create({
+    data: {
+      userId: benutzer.id,
+      credentialId: credential.id,
+      publicKey: Buffer.from(credential.publicKey),
+      counter: BigInt(credential.counter),
+      transports: credential.transports ?? [],
+      name,
+      geraeteArt: credentialDeviceType,
+      gesichert: credentialBackedUp,
+    },
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Anmelden
+// ---------------------------------------------------------------------------
+
+export async function anmeldungVorbereiten(): Promise<PublicKeyCredentialRequestOptionsJSON> {
+  verfuegbarkeitPruefen()
+
+  // Erst aufraeumen, dann die Decke pruefen: Abgelaufenes soll nicht als
+  // laufender Versuch zaehlen.
+  await abgelaufeneAnfragenEntfernen()
+  const offen = await db.passkeyAnfrage.count({ where: { art: 'ANMELDUNG' } })
+  if (offen >= MAX_OFFENE_ANMELDUNGEN) throw new PasskeyFehler('zu-viele-anfragen')
+
+  const optionen = await generateAuthenticationOptions({
+    rpID: env.passkey.rpId,
+    // Bewusst ohne allowCredentials: Der Server soll vor der Anmeldung
+    // nicht verraten, welche Schluessel es zu einer Adresse gibt - und der
+    // Benutzer soll seine E-Mail gar nicht erst eintippen muessen. Das
+    // Geraet weiss selbst, welchen Schluessel es fuer diese Domain hat.
+    userVerification: 'required',
+    timeout: ANFRAGE_GUELTIG_SEKUNDEN * 1000,
+  })
+
+  await anfrageMerken(optionen.challenge, 'ANMELDUNG', null)
+  return optionen
+}
+
+export type PasskeyAnmeldung = {
+  benutzer: User
+  passkey: Passkey
+}
+
+/**
+ * Prueft eine Anmeldeantwort vollstaendig und meldet, wem sie gehoert.
+ *
+ * Alles, was hier durchgeht, ist kryptografisch belegt: die Signatur passt
+ * zum hinterlegten oeffentlichen Schluessel, die Challenge war frisch und
+ * genau einmal gueltig, die Domain stimmt, und das Geraet hat den Benutzer
+ * verifiziert.
+ *
+ * Rate-Limiting und Audit-Log passieren NICHT hier, sondern beim Aufrufer -
+ * dort ist bekannt, ob es eine Anmeldung oder eine erneute Bestaetigung ist.
+ */
+export async function anmeldungPruefen(
+  antwort: AuthenticationResponseJSON,
+): Promise<PasskeyAnmeldung> {
+  verfuegbarkeitPruefen()
+
+  const challenge = challengeAusAntwort(antwort.response.clientDataJSON)
+  await anfrageVerbrauchen(challenge, 'ANMELDUNG')
+
+  const passkey = await db.passkey.findUnique({
+    where: { credentialId: antwort.id },
+    include: { user: true },
+  })
+
+  if (!passkey) throw new PasskeyFehler('unbekannt')
+
+  let ergebnis
+  try {
+    ergebnis = await verifyAuthenticationResponse({
+      response: antwort,
+      expectedChallenge: challenge,
+      expectedOrigin: env.passkey.herkunft,
+      expectedRPID: env.passkey.rpId,
+      requireUserVerification: true,
+      credential: {
+        id: passkey.credentialId,
+        publicKey: alsUint8(passkey.publicKey),
+        counter: Number(passkey.counter),
+        transports: passkey.transports as AuthenticatorTransportFuture[],
+      },
+    })
+  } catch (fehler) {
+    // Die Bibliothek meldet einen nicht weitergelaufenen Zaehler als
+    // gewoehnlichen Fehler. Der verdient eine eigene Meldung: er ist der
+    // einzige Hinweis auf einen kopierten Schluessel, den wir bekommen.
+    const text = fehler instanceof Error ? fehler.message : ''
+    if (text.includes('counter value')) throw new PasskeyFehler('geklont')
+    throw new PasskeyFehler('ungueltig')
+  }
+
+  if (!ergebnis.verified) throw new PasskeyFehler('ungueltig')
+  if (!ergebnis.authenticationInfo.userVerified) throw new PasskeyFehler('nicht-verifiziert')
+
+  await db.passkey.update({
+    where: { id: passkey.id },
+    data: {
+      counter: BigInt(ergebnis.authenticationInfo.newCounter),
+      zuletztBenutztAm: new Date(),
+      // Beides kann sich nachtraeglich aendern, etwa wenn der Benutzer die
+      // Schluesselbund-Synchronisierung einschaltet.
+      geraeteArt: ergebnis.authenticationInfo.credentialDeviceType,
+      gesichert: ergebnis.authenticationInfo.credentialBackedUp,
+    },
+  })
+
+  return { benutzer: passkey.user, passkey }
+}
+
+// ---------------------------------------------------------------------------
+// Verwalten und Aufraeumen
+// ---------------------------------------------------------------------------
+
+export type PasskeyUebersicht = {
+  id: string
+  name: string
+  geraeteArt: string | null
+  gesichert: boolean
+  erstelltAm: Date
+  zuletztBenutztAm: Date | null
+}
+
+export async function passkeysDesBenutzers(userId: string): Promise<PasskeyUebersicht[]> {
+  return db.passkey.findMany({
+    where: { userId },
+    orderBy: [{ zuletztBenutztAm: { sort: 'desc', nulls: 'last' } }, { erstelltAm: 'desc' }],
+    select: {
+      id: true,
+      name: true,
+      geraeteArt: true,
+      gesichert: true,
+      erstelltAm: true,
+      zuletztBenutztAm: true,
+    },
+  })
+}
+
+/** Raeumt liegengebliebene Challenges weg; wird vom Wartungslauf aufgerufen. */
+export async function abgelaufeneAnfragenEntfernen(): Promise<number> {
+  const { count } = await db.passkeyAnfrage.deleteMany({
+    where: { ablaufAm: { lt: new Date() } },
+  })
+  return count
+}
@@ -58,14 +58,25 @@ function einmal<T>(fn: () => T): () => T {

 const holeVerschluesselungsschluessel = einmal((): Map<number, Buffer> => {
  const schluessel = new Map<number, Buffer>()
+
  // ENC_KEY_V1, ENC_KEY_V2, ... - alte Versionen bleiben zum Entschluesseln
  // stehen, verschluesselt wird immer mit der aktiven Version.
-  for (const [name] of Object.entries(process.env)) {
+  for (const [name, wert] of Object.entries(process.env)) {
    const treffer = name.match(/^ENC_KEY_V(\d+)$/)
-    if (treffer) {
+    if (!treffer) continue
+
+    // Eine LEERE Variable ist kein Schluessel.
+    //
+    // docker compose reicht ENC_KEY_V2 immer durch - mit leerem Wert, wenn
+    // in der .env keiner steht. Wuerde hier allein der Name zaehlen, waere
+    // jede Installation ohne zweiten Schluessel kaputt, und zwar mit der
+    // irrefuehrenden Meldung "ENC_KEY_V2 fehlt" - obwohl niemand einen
+    // zweiten Schluessel wollte.
+    if (!wert || wert.trim() === '') continue
+
    schluessel.set(Number.parseInt(treffer[1]!, 10), schluessel32(name))
  }
-  }
+
  if (schluessel.size === 0) {
    throw new Error(
      'Kein Verschluesselungsschluessel gefunden. Es muss mindestens ENC_KEY_V1 ' +
@@ -78,8 +89,11 @@ const holeVerschluesselungsschluessel = einmal((): Map<number, Buffer> => {
 const holeAktiveVersion = einmal((): number => {
  const version = zahl('ENC_KEY_AKTIV', 1)
  if (!holeVerschluesselungsschluessel().has(version)) {
+    const vorhanden = [...holeVerschluesselungsschluessel().keys()].sort().join(', ')
    throw new Error(
-      `ENC_KEY_AKTIV=${version}, aber ENC_KEY_V${version} ist nicht gesetzt.`,
+      `ENC_KEY_AKTIV=${version}, aber ENC_KEY_V${version} ist nicht gesetzt oder leer. ` +
+        `Vorhanden sind die Versionen: ${vorhanden}. Beim Rotieren zuerst den ` +
+        `neuen Schluessel eintragen, danach ENC_KEY_AKTIV umstellen.`,
    )
  }
  return version
@@ -171,6 +185,35 @@ export const env = {
    return (process.env.AUTH_URL ?? 'http://localhost:3000').replace(/\/$/, '')
  },

+  /**
+   * Herkunft und Bereichskennung fuer Passkeys (WebAuthn).
+   *
+   * Beides wird aus AUTH_URL abgeleitet und nicht getrennt konfiguriert -
+   * eine zweite Quelle waere eine zweite Gelegenheit, sie auseinanderlaufen
+   * zu lassen.
+   *
+   * Die "rpId" ist der nackte Hostname ohne Schema und ohne Port. An sie
+   * bindet der Authenticator den Schluessel: Ein Passkey fuer
+   * cockpit.example.de funktioniert auf keiner anderen Adresse - genau das
+   * macht ihn gegen Phishing immun. Umgekehrt heisst das: Wer die Domain
+   * wechselt, muss alle Passkeys neu einrichten.
+   *
+   * Der Browser gibt WebAuthn ausserdem nur in einem sicheren Kontext frei -
+   * also unter https oder auf localhost. Hinter einem Proxy, der auf http
+   * weiterreicht, muss AUTH_URL trotzdem die oeffentliche https-Adresse
+   * nennen; verglichen wird gegen das, was im Browser in der Adresszeile
+   * stand.
+   */
+  get passkey() {
+    const url = new URL(process.env.AUTH_URL ?? 'http://localhost:3000')
+    return {
+      rpId: url.hostname,
+      rpName: 'Betreuungs-Cockpit',
+      herkunft: url.origin,
+      sicherAufrufbar: url.protocol === 'https:' || url.hostname === 'localhost',
+    }
+  },
+
  get istProduktion() {
    return process.env.NODE_ENV === 'production'
  },
@@ -0,0 +1,55 @@
+/**
+ * Browserseitige Hilfen fuer Passkeys.
+ *
+ * Bewusst ohne "server-only" und ohne Datenbankzugriff: Diese Datei laeuft
+ * im Browser. Die eigentliche Pruefung passiert auf dem Server
+ * (src/lib/auth/passkey.ts) - hier geht es nur darum, das Geraet
+ * anzusprechen und seine Fehler in verstaendliche Saetze zu uebersetzen.
+ */
+
+import {
+  browserSupportsWebAuthn,
+  startAuthentication,
+  startRegistration,
+} from '@simplewebauthn/browser'
+
+export { browserSupportsWebAuthn, startAuthentication, startRegistration }
+
+/**
+ * Uebersetzt die Ausnahmen der WebAuthn-Schnittstelle.
+ *
+ * Der Browser wirft DOMExceptions mit sehr knappen Namen und einer
+ * englischen Beschreibung, die man niemandem zeigen kann. Vor allem
+ * "NotAllowedError" ist irrefuehrend: Er bedeutet meistens schlicht, dass
+ * der Vorgang abgebrochen wurde oder die Zeit abgelaufen ist - nicht, dass
+ * etwas verboten waere.
+ */
+export function passkeyBrowserfehler(fehler: unknown, beimEinrichten = false): string {
+  const name = fehler instanceof Error ? fehler.name : ''
+
+  switch (name) {
+    case 'NotAllowedError':
+      return 'Abgebrochen oder zu lange gewartet. Du kannst es gleich noch einmal versuchen.'
+
+    case 'InvalidStateError':
+      return beimEinrichten
+        ? 'Für dieses Gerät ist hier bereits ein Passkey hinterlegt. Ein zweiter bringt nichts — ' +
+            'nimm ein anderes Gerät oder entferne zuerst den vorhandenen.'
+        : 'Dieses Gerät kann den Passkey gerade nicht verwenden.'
+
+    case 'SecurityError':
+      return (
+        'Die Adresse im Browser passt nicht zu der, für die der Passkey ausgestellt wurde. ' +
+        'Das ist genau der Schutz, der Phishing verhindert — prüfe die Adresszeile.'
+      )
+
+    case 'NotSupportedError':
+      return 'Dieses Gerät unterstützt keine Passkeys mit Fingerabdruck, Gesicht oder PIN.'
+
+    case 'AbortError':
+      return 'Abgebrochen.'
+
+    default:
+      return 'Der Passkey konnte nicht verwendet werden. Bitte versuche es noch einmal.'
+  }
+}
@@ -8,21 +8,36 @@ import { z } from 'zod'
 * ist, nicht was falsch war.
 */

-/** Leere Zeichenketten aus einem Formular sollen zu null werden, nicht zu "". */
+/**
+ * Optionales Textfeld.
+ *
+ * Drei Eingaben muessen zu null werden:
+ *   ""         das Feld war da, blieb aber leer
+ *   null       ausdruecklich geleert
+ *   undefined  das Feld war im Formular ueberhaupt nicht dabei
+ *
+ * Der letzte Fall ist der wichtige: Das kurze Formular der Ersteinrichtung
+ * schickt nur eine Handvoll Felder, das vollstaendige unter Stammdaten
+ * alle. Beide gehen durch dasselbe Schema. Ohne .optional() wuerde die
+ * Ersteinrichtung an zwei Dutzend Feldern scheitern, die gar nicht auf dem
+ * Bildschirm stehen - und die Meldung liesse sich keinem Feld zuordnen.
+ */
 const optionalerText = (max = 200) =>
  z
    .string()
    .trim()
    .max(max, `Bitte höchstens ${max} Zeichen.`)
-    .transform((wert) => (wert === '' ? null : wert))
+    .optional()
    .nullable()
+    .transform((wert) => (wert === undefined || wert === '' ? null : wert))

-/** HTML-Datumsfelder liefern "" oder "2026-01-15". */
+/** HTML-Datumsfelder liefern "" oder "2026-01-15" - oder gar nichts. */
 const optionalesDatum = z
  .string()
  .trim()
-  .transform((wert) => (wert === '' ? null : wert))
+  .optional()
  .nullable()
+  .transform((wert) => (wert === undefined || wert === '' ? null : wert))
  .refine((wert) => wert === null || /^\d{4}-\d{2}-\d{2}$/.test(wert), {
    message: 'Bitte ein Datum im Format TT.MM.JJJJ wählen.',
  })
@@ -17,7 +17,7 @@
 */

 /** Muss zur "version" in der package.json passen. */
-export const VERSION = '1.0.1'
+export const VERSION = '1.1.1'

 /**
 * Kurzer Git-Stand, beim Bauen hineingereicht:
@@ -3,6 +3,7 @@ import { db, papierkorbGrenze } from '@/lib/db'
 import { env } from '@/lib/env'
 import { fristErinnerung, mailSenden } from '@/lib/mail'
 import { alteVersucheEntfernen } from '@/lib/auth/ratelimit'
+import { abgelaufeneAnfragenEntfernen } from '@/lib/auth/passkey'

 /**
 * Taeglicher Wartungslauf.
@@ -14,6 +15,7 @@ import { alteVersucheEntfernen } from '@/lib/auth/ratelimit'
 *   2. Papierkorb leeren (30 Tage)
 *   3. Alte Anmeldeversuche entfernen (30 Tage)
 *   4. Altes Audit-Log entfernen (10 Jahre, ueber die DB-Funktion)
+ *   5. Liegengebliebene Passkey-Challenges entfernen (5 Minuten)
 *
 * Jeder Schritt faengt seine Fehler selbst ab. Faellt die Mail aus, soll
 * trotzdem aufgeraeumt werden - sonst laeuft die Datenbank voll, weil ein
@@ -25,6 +27,7 @@ export type Wartungsergebnis = {
  papierkorbGeleert: number
  loginversucheEntfernt: number
  auditEintraegeEntfernt: number
+  passkeyAnfragenEntfernt: number
  fehler: string[]
 }

@@ -56,6 +59,7 @@ export async function wartungslauf(): Promise<Wartungsergebnis> {
    papierkorbGeleert: 0,
    loginversucheEntfernt: 0,
    auditEintraegeEntfernt: 0,
+    passkeyAnfragenEntfernt: 0,
    fehler: [],
  }

@@ -93,6 +97,15 @@ export async function wartungslauf(): Promise<Wartungsergebnis> {
    ergebnis.fehler.push(`Audit-Log: ${beschreiben(fehler)}`)
  }

+  // --- 5. Passkey-Challenges ----------------------------------------------
+  try {
+    // Normalerweise raeumt jede Anmeldung selbst auf. Bleibt der letzte
+    // Versuch des Tages liegen, faengt es dieser Lauf ab.
+    ergebnis.passkeyAnfragenEntfernt = await abgelaufeneAnfragenEntfernen()
+  } catch (fehler) {
+    ergebnis.fehler.push(`Passkey-Anfragen: ${beschreiben(fehler)}`)
+  }
+
  return ergebnis
 }

@@ -53,6 +53,49 @@ function felderAusFehler(fehler: z.ZodError): Record<string, string> {
  return ergebnis
 }

+/**
+ * Baut die Antwort auf einen Pruefungsfehler.
+ *
+ * Der wichtige Teil ist die Unterscheidung: Beanstandet die Pruefung ein
+ * Feld, das gar nicht abgeschickt wurde, dann passt das Formular nicht zum
+ * Schema - und die Meldung liesse sich auf dem Bildschirm keinem Feld
+ * zuordnen. Der Nutzer saehe "Bitte pruefe die markierten Felder", ohne
+ * dass irgendetwas markiert waere, und kaeme nie weiter.
+ *
+ * Das ist ein Fehler im Programm, keiner in der Eingabe. Er wird deshalb
+ * benannt und ins Serverlog geschrieben, statt ihn dem Nutzer als
+ * Eingabefehler unterzuschieben.
+ */
+function antwortAufFehler(fehler: z.ZodError, formular: FormData): BetreuteZustand {
+  const felder = felderAusFehler(fehler)
+  const gesendet = new Set(formular.keys())
+  const nichtZuordenbar = Object.entries(felder).filter(([feld]) => !gesendet.has(feld))
+
+  if (nichtZuordenbar.length > 0) {
+    const liste = nichtZuordenbar.map(([feld, meldung]) => `${feld}: ${meldung}`).join('; ')
+    console.error(
+      `[stammdaten] Das Formular passt nicht zum Schema. Beanstandet wurden ` +
+        `Felder, die es gar nicht abgeschickt hat: ${liste}`,
+    )
+    return {
+      fehler:
+        'Das Formular passt nicht zur Prüfung — betroffen sind Felder, die ' +
+        'hier gar nicht stehen: ' +
+        nichtZuordenbar.map(([feld]) => feld).join(', ') +
+        '. Das ist ein Fehler in der Anwendung, nicht in deiner Eingabe. ' +
+        'Einzelheiten stehen im Serverlog.',
+      felder,
+      werte: werteMerken(formular),
+    }
+  }
+
+  return {
+    fehler: 'Bitte prüfe die markierten Felder.',
+    felder,
+    werte: werteMerken(formular),
+  }
+}
+
 function werteMerken(formular: FormData): Record<string, string> {
  const werte: Record<string, string> = {}
  for (const [name, wert] of formular.entries()) {
@@ -77,13 +120,7 @@ export async function betreuteAnlegen(
  }

  const gelesen = BetreuteSchema.safeParse(formularLesen(formular))
-  if (!gelesen.success) {
-    return {
-      fehler: 'Bitte prüfe die markierten Felder.',
-      felder: felderAusFehler(gelesen.error),
-      werte: werteMerken(formular),
-    }
-  }
+  if (!gelesen.success) return antwortAufFehler(gelesen.error, formular)

  const { offen, verschluesselt } = aufteilen(gelesen.data)

@@ -134,13 +171,7 @@ export async function betreuteAendern(
  const { benutzer, betreute } = await erfordereZugang(betreuteId, 'STAMMDATEN', 'schreiben')

  const gelesen = BetreuteSchema.safeParse(formularLesen(formular))
-  if (!gelesen.success) {
-    return {
-      fehler: 'Bitte prüfe die markierten Felder.',
-      felder: felderAusFehler(gelesen.error),
-      werte: werteMerken(formular),
-    }
-  }
+  if (!gelesen.success) return antwortAufFehler(gelesen.error, formular)

  const { offen, verschluesselt } = aufteilen(gelesen.data)

@@ -0,0 +1,313 @@
+'use server'
+
+import { AuthError } from 'next-auth'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import type {
+  AuthenticationResponseJSON,
+  PublicKeyCredentialCreationOptionsJSON,
+  PublicKeyCredentialRequestOptionsJSON,
+  RegistrationResponseJSON,
+} from '@simplewebauthn/server'
+import { signIn } from '@/auth'
+import { db } from '@/lib/db'
+import { protokollieren } from '@/lib/audit'
+import {
+  PASSKEY_MELDUNG,
+  PasskeyFehler,
+  anmeldungPruefen,
+  anmeldungVorbereiten,
+  registrierungPruefen,
+  registrierungVorbereiten,
+} from '@/lib/auth/passkey'
+import { erfordereBenutzer, reauthBestaetigen } from '@/lib/auth/sitzung'
+
+/**
+ * Server Actions rund um Passkeys.
+ *
+ * Ein Passkey-Vorgang besteht immer aus zwei Aufrufen: erst holt der Browser
+ * die Optionen samt Challenge, dann schickt er die Antwort des Geraets
+ * zurueck. Dazwischen liegt der Griff zum Fingerabdrucksensor, und der
+ * dauert unbestimmt lange - deshalb zwei Schritte und keine Sitzungsvariable.
+ *
+ * Die Antworten des Authenticators kommen als JSON-Zeichenkette herein, nicht
+ * als Objekt. Grund: Was ueber die Grenze zum Server geht, wird hier
+ * ausdruecklich geparst und geprueft, statt sich auf die Serialisierung von
+ * React zu verlassen.
+ */
+
+/** Ergebnis eines Schritts, der Optionen liefert. */
+export type PasskeyStart<T> = { ok: true; optionen: T } | { ok: false; fehler: string }
+
+/** Ergebnis eines abschliessenden Schritts. */
+export type PasskeyErgebnis = { ok: true; meldung?: string } | { ok: false; fehler: string }
+
+function alsFehler(fehler: unknown): { ok: false; fehler: string } {
+  if (fehler instanceof PasskeyFehler) {
+    return { ok: false, fehler: PASSKEY_MELDUNG[fehler.grund] }
+  }
+  console.error('[passkey] Unerwarteter Fehler:', fehler)
+  return { ok: false, fehler: PASSKEY_MELDUNG.ungueltig }
+}
+
+/**
+ * Parst die Antwort des Browsers.
+ *
+ * Absichtlich nur eine grobe Formpruefung: Was zaehlt, prueft anschliessend
+ * die Bibliothek kryptografisch. Hier geht es nur darum, dass kein
+ * offensichtlicher Unsinn bis dorthin durchlaeuft.
+ */
+const AntwortSchema = z.object({
+  id: z.string().min(1),
+  rawId: z.string().min(1),
+  type: z.literal('public-key'),
+  response: z.object({ clientDataJSON: z.string().min(1) }).passthrough(),
+})
+
+function antwortLesen<T>(roh: string): T {
+  const gelesen = AntwortSchema.safeParse(JSON.parse(roh))
+  if (!gelesen.success) throw new PasskeyFehler('ungueltig')
+  return gelesen.data as T
+}
+
+// ---------------------------------------------------------------------------
+// Einrichten (angemeldet, unter "Mein Konto")
+// ---------------------------------------------------------------------------
+
+export async function passkeyEinrichtungStarten(): Promise<
+  PasskeyStart<PublicKeyCredentialCreationOptionsJSON>
+> {
+  try {
+    const benutzer = await erfordereBenutzer()
+    return { ok: true, optionen: await registrierungVorbereiten(benutzer) }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+const NameSchema = z
+  .string()
+  .trim()
+  .min(1, 'Bitte gib dem Gerät einen Namen.')
+  .max(60, 'Bitte höchstens 60 Zeichen.')
+
+export async function passkeyEinrichtungAbschliessen(
+  name: string,
+  antwortJson: string,
+): Promise<PasskeyErgebnis> {
+  try {
+    const benutzer = await erfordereBenutzer()
+
+    const geprueft = NameSchema.safeParse(name)
+    if (!geprueft.success) {
+      return {
+        ok: false,
+        fehler: geprueft.error.issues[0]?.message ?? 'Der Name passt nicht.',
+      }
+    }
+
+    const antwort = antwortLesen<RegistrationResponseJSON>(antwortJson)
+    const passkey = await registrierungPruefen(benutzer, geprueft.data, antwort)
+
+    await protokollieren({
+      aktion: 'PASSKEY_REGISTRIERT',
+      entitaet: 'Passkey',
+      entitaetId: passkey.id,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+      bezeichnung: passkey.name,
+    })
+
+    revalidatePath('/konto')
+    return { ok: true, meldung: `„${passkey.name}“ ist eingerichtet.` }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Verwalten
+// ---------------------------------------------------------------------------
+
+export async function passkeyEntfernen(id: string): Promise<PasskeyErgebnis> {
+  try {
+    const benutzer = await erfordereBenutzer()
+
+    // Zeilenweise Pruefung: Es genuegt nicht, dass die ID existiert - sie
+    // muss zu DIESEM Benutzer gehoeren. deleteMany mit userId im WHERE
+    // erledigt Pruefung und Loeschen in einem Zug; ein fremder Passkey
+    // trifft dann auf null Zeilen.
+    const passkey = await db.passkey.findFirst({
+      where: { id, userId: benutzer.id },
+      select: { id: true, name: true },
+    })
+    if (!passkey)
+      return {
+        ok: false,
+        fehler: 'Dieser Passkey gehört nicht zu deinem Zugang.',
+      }
+
+    await db.passkey.delete({ where: { id: passkey.id } })
+
+    await protokollieren({
+      aktion: 'PASSKEY_ENTFERNT',
+      entitaet: 'Passkey',
+      entitaetId: passkey.id,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+      bezeichnung: passkey.name,
+    })
+
+    revalidatePath('/konto')
+    return { ok: true, meldung: `„${passkey.name}“ wurde entfernt.` }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Anmelden (nicht angemeldet)
+// ---------------------------------------------------------------------------
+
+export async function passkeyAnmeldungStarten(): Promise<
+  PasskeyStart<PublicKeyCredentialRequestOptionsJSON>
+> {
+  try {
+    return { ok: true, optionen: await anmeldungVorbereiten() }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+/** Verhindert offene Weiterleitungen auf fremde Seiten. */
+function sicheresZiel(ziel: string): string {
+  if (!ziel.startsWith('/') || ziel.startsWith('//')) return '/heute'
+  return ziel
+}
+
+/**
+ * Erkennt die Weiterleitung, die Next.js intern als Ausnahme wirft.
+ * Wie in anmelden.ts ueber das digest-Feld statt ueber einen Import aus
+ * next/dist - interne Pfade aendern sich zwischen Nebenversionen.
+ */
+function istWeiterleitung(fehler: unknown): boolean {
+  return (
+    typeof fehler === 'object' &&
+    fehler !== null &&
+    'digest' in fehler &&
+    typeof (fehler as { digest?: unknown }).digest === 'string' &&
+    (fehler as { digest: string }).digest.startsWith('NEXT_REDIRECT')
+  )
+}
+
+/**
+ * Uebersetzt den Fehlercode aus authorize() in einen lesbaren Satz.
+ * "passkey:<grund>" kommt aus PasskeyAnmeldeFehler, alles andere aus dem
+ * gewoehnlichen Anmeldeweg.
+ */
+function fehlertext(code: string): string {
+  const [art, wert] = code.split(':')
+
+  if (art === 'passkey') {
+    const grund = wert as keyof typeof PASSKEY_MELDUNG
+    return PASSKEY_MELDUNG[grund] ?? PASSKEY_MELDUNG.ungueltig
+  }
+  if (art === 'gesperrt') {
+    const minuten = Math.ceil(Number.parseInt(wert ?? '0', 10) / 60)
+    return (
+      `Zu viele Fehlversuche. Aus Sicherheitsgründen ist die Anmeldung für ` +
+      `${minuten > 1 ? `etwa ${minuten} Minuten` : 'kurze Zeit'} gesperrt.`
+    )
+  }
+  if (art === 'konto-inaktiv') {
+    return 'Dieser Zugang ist deaktiviert. Bitte wende dich an den Administrator.'
+  }
+  return PASSKEY_MELDUNG.ungueltig
+}
+
+export async function passkeyAnmeldungAbschliessen(
+  antwortJson: string,
+  weiter: string,
+): Promise<PasskeyErgebnis> {
+  try {
+    // Nur die Form pruefen; signIn() macht die eigentliche Arbeit.
+    antwortLesen<AuthenticationResponseJSON>(antwortJson)
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+
+  try {
+    await signIn('passkey', {
+      antwort: antwortJson,
+      redirectTo: sicheresZiel(weiter),
+    })
+  } catch (fehler) {
+    // Bei Erfolg wirft signIn eine Weiterleitung - die muss durch.
+    if (istWeiterleitung(fehler)) throw fehler
+
+    if (fehler instanceof AuthError) {
+      const code =
+        'code' in fehler && typeof fehler.code === 'string' ? fehler.code : 'passkey:ungueltig'
+      return { ok: false, fehler: fehlertext(code) }
+    }
+
+    throw fehler
+  }
+
+  // Wird nicht erreicht - signIn leitet weiter.
+  return { ok: true }
+}
+
+// ---------------------------------------------------------------------------
+// Erneut bestaetigen (angemeldet, vor sensiblen Aktionen)
+// ---------------------------------------------------------------------------
+
+export async function passkeyBestaetigungStarten(): Promise<
+  PasskeyStart<PublicKeyCredentialRequestOptionsJSON>
+> {
+  try {
+    await erfordereBenutzer()
+    return { ok: true, optionen: await anmeldungVorbereiten() }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+/**
+ * Bestaetigt die laufende Sitzung mit einem Passkey.
+ *
+ * Wichtig ist die letzte Pruefung: Der Passkey muss dem angemeldeten
+ * Benutzer gehoeren. Sonst koennte jemand mit seinem eigenen Passkey die
+ * fremde Sitzung freischalten, die auf einem unbeaufsichtigten Rechner
+ * offen steht - genau der Fall, gegen den die erneute Bestaetigung da ist.
+ */
+export async function passkeyBestaetigen(antwortJson: string): Promise<PasskeyErgebnis> {
+  try {
+    const benutzer = await erfordereBenutzer()
+    const antwort = antwortLesen<AuthenticationResponseJSON>(antwortJson)
+
+    const { benutzer: eigentuemer } = await anmeldungPruefen(antwort)
+
+    if (eigentuemer.id !== benutzer.id) {
+      await protokollieren({
+        aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
+        entitaet: 'User',
+        entitaetId: benutzer.id,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        bezeichnung: 'Bestätigung mit fremdem Passkey',
+      })
+      return {
+        ok: false,
+        fehler: 'Dieser Passkey gehört zu einem anderen Zugang als dem gerade angemeldeten.',
+      }
+    }
+
+    await reauthBestaetigen(benutzer.id)
+    return { ok: true }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
@@ -0,0 +1,193 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import {
+  MAX_PASSKEYS_JE_BENUTZER,
+  PASSKEY_MELDUNG,
+  PasskeyFehler,
+  challengeAusAntwort,
+  passkeysMoeglich,
+} from '@/lib/auth/passkey'
+import { passkeyBrowserfehler } from '@/lib/passkey-browser'
+import { env } from '@/lib/env'
+
+/**
+ * Passkeys — die Teile, die sich ohne Datenbank und ohne Browser prüfen
+ * lassen.
+ *
+ * Der Schwerpunkt liegt auf der Herleitung von `rpId` und Herkunft aus
+ * `AUTH_URL`. Das ist bei WebAuthn die Stelle, an der eine Installation
+ * still kaputtgeht: Stimmt die Bereichskennung nicht, lässt sich zwar ein
+ * Passkey einrichten, aber nie wieder verwenden — und die Fehlermeldung des
+ * Browsers zeigt auf alles Mögliche, nur nicht auf die Konfiguration.
+ *
+ * Dieselbe Fehlerklasse hat uns bei `APP_BIND` und `ENC_KEY_V2` schon zwei
+ * Fassungen gekostet: eine Umgebungsvariable, die falsch ausgewertet wird,
+ * und ein Fehlerbild, das woandershin zeigt.
+ */
+
+let vorher: string | undefined
+
+beforeEach(() => {
+  vorher = process.env.AUTH_URL
+})
+
+afterEach(() => {
+  if (vorher === undefined) delete process.env.AUTH_URL
+  else process.env.AUTH_URL = vorher
+})
+
+describe('Bereichskennung aus AUTH_URL', () => {
+  it('nimmt den nackten Hostnamen als rpId, ohne Schema und ohne Port', () => {
+    process.env.AUTH_URL = 'https://cockpit.example.de'
+    expect(env.passkey.rpId).toBe('cockpit.example.de')
+    expect(env.passkey.herkunft).toBe('https://cockpit.example.de')
+  })
+
+  it('lässt den Port in der Herkunft stehen, aber nicht in der rpId', () => {
+    // Die Herkunft wird zeichengenau mit dem verglichen, was im Browser in
+    // der Adresszeile stand - der Port gehoert dazu. Die rpId ist dagegen
+    // die Domain, an die der Schluessel gebunden wird; ein Port darf dort
+    // nicht auftauchen, sonst weist der Authenticator sie zurueck.
+    process.env.AUTH_URL = 'https://cockpit.example.de:8443'
+    expect(env.passkey.rpId).toBe('cockpit.example.de')
+    expect(env.passkey.herkunft).toBe('https://cockpit.example.de:8443')
+  })
+
+  it('verträgt einen Schrägstrich am Ende', () => {
+    process.env.AUTH_URL = 'https://cockpit.example.de/'
+    expect(env.passkey.herkunft).toBe('https://cockpit.example.de')
+  })
+
+  it('erkennt eine Unterdomain als eigene Kennung', () => {
+    // Ein Passkey fuer betreuung.example.de gilt NICHT fuer example.de -
+    // genau das ist der Phishingschutz.
+    process.env.AUTH_URL = 'https://betreuung.example.de'
+    expect(env.passkey.rpId).toBe('betreuung.example.de')
+  })
+})
+
+describe('Verfügbarkeit', () => {
+  it('bietet Passkeys über https an', () => {
+    process.env.AUTH_URL = 'https://cockpit.example.de'
+    expect(env.passkey.sicherAufrufbar).toBe(true)
+    expect(passkeysMoeglich()).toBe(true)
+  })
+
+  it('bietet sie auf localhost an, auch ohne https', () => {
+    // Der Browser wertet localhost als sicheren Kontext - sonst liesse
+    // sich in der Entwicklung nichts ausprobieren.
+    process.env.AUTH_URL = 'http://localhost:3000'
+    expect(env.passkey.sicherAufrufbar).toBe(true)
+  })
+
+  it('bietet sie NICHT über einfaches http an', () => {
+    // Wichtig, dass das der Server entscheidet und nicht der Browser: Ein
+    // Knopf, der beim Klick eine kryptische DOMException wirft, ist
+    // schlechter als gar kein Knopf.
+    process.env.AUTH_URL = 'http://cockpit.example.de'
+    expect(env.passkey.sicherAufrufbar).toBe(false)
+    expect(passkeysMoeglich()).toBe(false)
+  })
+
+  it('bietet sie auch über eine nackte IP ohne https nicht an', () => {
+    process.env.AUTH_URL = 'http://10.0.0.5:3000'
+    expect(env.passkey.sicherAufrufbar).toBe(false)
+  })
+})
+
+describe('Challenge aus der Antwort des Browsers', () => {
+  function clientData(inhalt: unknown): string {
+    return Buffer.from(JSON.stringify(inhalt), 'utf8').toString('base64url')
+  }
+
+  it('liest die Challenge aus den clientData', () => {
+    const daten = clientData({
+      type: 'webauthn.get',
+      challenge: 'AbCdEf-1234_xyz',
+      origin: 'https://cockpit.example.de',
+    })
+    expect(challengeAusAntwort(daten)).toBe('AbCdEf-1234_xyz')
+  })
+
+  it('weist eine Antwort ohne Challenge ab', () => {
+    const daten = clientData({ type: 'webauthn.get', origin: 'https://cockpit.example.de' })
+    expect(() => challengeAusAntwort(daten)).toThrowError(PasskeyFehler)
+  })
+
+  it('weist eine leere Challenge ab', () => {
+    expect(() => challengeAusAntwort(clientData({ challenge: '' }))).toThrowError(PasskeyFehler)
+  })
+
+  it('weist eine Challenge ab, die keine Zeichenkette ist', () => {
+    expect(() => challengeAusAntwort(clientData({ challenge: 42 }))).toThrowError(PasskeyFehler)
+  })
+
+  it('weist Unsinn ab, statt daran abzustürzen', () => {
+    expect(() => challengeAusAntwort('das ist kein base64url-JSON')).toThrowError(PasskeyFehler)
+    expect(() => challengeAusAntwort('')).toThrowError(PasskeyFehler)
+  })
+})
+
+describe('Meldungen', () => {
+  it('hat zu jedem Grund einen Satz, den man jemandem zeigen kann', () => {
+    // Ein fehlender Eintrag wuerde als "undefined" auf dem Bildschirm
+    // landen. Der Typ verhindert das beim Uebersetzen; hier wird geprueft,
+    // dass auch nichts Leeres durchrutscht.
+    for (const [grund, text] of Object.entries(PASSKEY_MELDUNG)) {
+      expect(text.length, `Meldung für "${grund}"`).toBeGreaterThan(20)
+      expect(text, `Meldung für "${grund}"`).not.toMatch(/undefined/)
+    }
+  })
+
+  it('nennt in der Obergrenze die tatsächliche Zahl', () => {
+    expect(PASSKEY_MELDUNG['zu-viele']).toContain(String(MAX_PASSKEYS_JE_BENUTZER))
+  })
+
+  it('erklärt bei fehlender Nutzerverifikation, warum abgelehnt wird', () => {
+    // Das ist die Meldung, die am ehesten nach Schikane aussieht. Sie muss
+    // den Grund nennen, sonst haelt man sie fuer einen Fehler.
+    expect(PASSKEY_MELDUNG['nicht-verifiziert']).toMatch(/Fingerabdruck|PIN/)
+  })
+})
+
+describe('Fehler des Browsers', () => {
+  function dom(name: string): Error {
+    const fehler = new Error('irgendwas Englisches')
+    fehler.name = name
+    return fehler
+  }
+
+  it('deutet NotAllowedError als Abbruch, nicht als Verbot', () => {
+    // Der Name ist irrefuehrend: Er kommt auch, wenn schlicht niemand den
+    // Finger aufgelegt hat. "Nicht erlaubt" waere die falsche Auskunft.
+    const text = passkeyBrowserfehler(dom('NotAllowedError'))
+    expect(text).toMatch(/Abgebrochen/)
+    expect(text).not.toMatch(/verboten|nicht erlaubt/i)
+  })
+
+  it('erklärt beim Einrichten, dass dieses Gerät schon einen Passkey hat', () => {
+    expect(passkeyBrowserfehler(dom('InvalidStateError'), true)).toMatch(/bereits/)
+  })
+
+  it('sagt bei SecurityError, dass die Adresse nicht passt', () => {
+    expect(passkeyBrowserfehler(dom('SecurityError'))).toMatch(/Adress/)
+  })
+
+  it('fällt bei unbekannten Fehlern auf einen brauchbaren Satz zurück', () => {
+    expect(passkeyBrowserfehler(dom('VoellingNeuerFehler'))).toMatch(/noch einmal/)
+    expect(passkeyBrowserfehler('gar kein Fehlerobjekt')).toMatch(/noch einmal/)
+    expect(passkeyBrowserfehler(undefined)).toMatch(/noch einmal/)
+  })
+
+  it('gibt nie die englische Originalmeldung weiter', () => {
+    for (const name of [
+      'NotAllowedError',
+      'InvalidStateError',
+      'SecurityError',
+      'NotSupportedError',
+      'AbortError',
+      'Unbekannt',
+    ]) {
+      expect(passkeyBrowserfehler(dom(name))).not.toContain('irgendwas Englisches')
+    }
+  })
+})
@@ -0,0 +1,87 @@
+import { execFileSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { describe, expect, it } from 'vitest'
+
+/**
+ * Die Betriebsskripte müssen im Repository so liegen, dass sie auf dem
+ * Server auch laufen.
+ *
+ * Anlass sind zwei Fehler, die beide erst im Betrieb aufgefallen sind und
+ * beide nichts mit dem Programm zu tun hatten, sondern mit der Verpackung:
+ *
+ *   1. `scripts/` fehlte im Docker-Abbild — `node scripts/totp-geheimnis.mjs`
+ *      lief ins Leere (behoben in 1.0.1).
+ *   2. Die `.sh`-Dateien lagen mit Modus 644 im Repository. Die Anleitung
+ *      sagt `./scripts/update.sh`, auf Linux kam „Permission denied".
+ *
+ * Beide Male hat kein Test angeschlagen, weil beide Male der Code richtig
+ * war. Diese Datei prüft deshalb nicht Verhalten, sondern Verpackung.
+ *
+ * Der Ausführbarkeitsbit wird aus dem Git-Index gelesen, nicht vom
+ * Dateisystem: Unter Windows steht `core.filemode=false`, dort sagt das
+ * Dateisystem nichts aus. Maßgeblich ist, was ausgecheckt wird.
+ */
+
+function gitVerfuegbar(): boolean {
+  try {
+    execFileSync('git', ['rev-parse', '--git-dir'], { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Liefert [Modus, Pfad] je Datei, so wie sie im Index steht. */
+function eintraegeImIndex(muster: string): [string, string][] {
+  const ausgabe = execFileSync('git', ['ls-files', '-s', muster], { encoding: 'utf8' })
+  return ausgabe
+    .split('\n')
+    .filter((zeile) => zeile.trim() !== '')
+    .map((zeile) => {
+      const [angaben, pfad] = zeile.split('\t')
+      return [angaben!.split(' ')[0]!, pfad!]
+    })
+}
+
+const mitGit = gitVerfuegbar()
+
+describe.skipIf(!mitGit)('Betriebsskripte', () => {
+  it('legt jedes Shell-Skript ausführbar ab', () => {
+    const skripte = eintraegeImIndex('scripts/*.sh')
+
+    // Wenn hier nichts steht, stimmt das Muster nicht mehr - das waere
+    // ein stiller Ausfall der Pruefung.
+    expect(skripte.length).toBeGreaterThan(0)
+
+    for (const [modus, pfad] of skripte) {
+      expect(modus, `${pfad} muss ausführbar sein (100755, ist ${modus})`).toBe('100755')
+    }
+  })
+
+  it('gibt jedem Shell-Skript eine Shebang-Zeile', () => {
+    for (const [, pfad] of eintraegeImIndex('scripts/*.sh')) {
+      const ersteZeile = readFileSync(pfad, 'utf8').split('\n')[0] ?? ''
+      expect(ersteZeile, `${pfad} braucht eine Shebang-Zeile`).toMatch(/^#!/)
+    }
+  })
+
+  it('nimmt scripts/ ins Docker-Abbild auf', () => {
+    // Der Fehler aus 1.0.1: Die Wartungsskripte lagen im Repository, aber
+    // nicht im Behaelter. Aufgefallen ist es erst, als sie gebraucht wurden.
+    const dockerfile = readFileSync('Dockerfile', 'utf8')
+    // Die Zeile traegt zusaetzliche Schalter (--from, --chown) - deshalb
+    // nicht auf eine feste Reihenfolge festlegen, sondern nur darauf, dass
+    // scripts/ ins Abbild kopiert wird.
+    expect(dockerfile).toMatch(/^COPY.*\/scripts\s+\.\/scripts\s*$/m)
+  })
+
+  it('bindet die Sicherungsskripte aus scripts/ in die Compose-Datei ein', () => {
+    // Sie werden als Volume in den Sicherungsdienst gehaengt. Ein
+    // umbenanntes Skript faellt sonst erst um 03:15 Uhr auf - im Log,
+    // das niemand liest.
+    const compose = readFileSync('docker-compose.yml', 'utf8')
+    for (const name of ['sicherung.sh', 'wiederherstellung.sh']) {
+      expect(compose, `${name} wird nicht eingebunden`).toContain(`./scripts/${name}:`)
+    }
+  })
+})
@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest'
+import { BetreuteSchema, formularLesen } from '@/lib/validierung/betreute'
+
+/**
+ * Eingabepruefung der Stammdaten.
+ *
+ * Anlass für diese Datei war ein Fehler im Betrieb: Die Ersteinrichtung
+ * ließ sich nicht abschließen. Das Formular meldete „Bitte prüfe die
+ * markierten Felder", markierte aber keines — weil die Meldungen zu
+ * Feldern gehörten, die dort gar nicht stehen.
+ *
+ * Ursache: Das kurze Formular der Ersteinrichtung schickt neun Felder,
+ * das vollständige unter Stammdaten alle. Beide gehen durch dasselbe
+ * Schema, und die optionalen Felder waren zwar `nullable`, aber nicht
+ * `optional` — ein fehlendes Feld ist `undefined`, nicht `null`.
+ */
+
+/** Die Felder, die das kurze Formular der Ersteinrichtung tatsächlich schickt. */
+function ersteinrichtungsFormular(): FormData {
+  const f = new FormData()
+  f.set('vorname', 'Franziska')
+  f.set('nachname', 'Wilde')
+  f.set('geburtsdatum', '1963-09-23')
+  f.set('betreuungsgericht', 'Lichtenfels')
+  f.set('aktenzeichenGericht', 'XVII 355/25')
+  f.set('bestellungAm', '2025-11-07')
+  f.append('aufgabenkreise', 'VERMOEGENSSORGE')
+  f.append('aufgabenkreise', 'GESUNDHEITSSORGE')
+  f.set('befreiterBetreuer', 'on')
+  f.set('ehrenamtlich', 'on')
+  return f
+}
+
+describe('Ersteinrichtung', () => {
+  it('nimmt das kurze Formular an, obwohl es die meisten Felder nicht schickt', () => {
+    const gelesen = BetreuteSchema.safeParse(formularLesen(ersteinrichtungsFormular()))
+
+    if (!gelesen.success) {
+      const felder = Object.keys(gelesen.error.flatten().fieldErrors).join(', ')
+      throw new Error(`Abgelehnt wegen: ${felder}`)
+    }
+
+    expect(gelesen.data.vorname).toBe('Franziska')
+    expect(gelesen.data.nachname).toBe('Wilde')
+    expect(gelesen.data.geburtsdatum.toISOString()).toBe('1963-09-23T00:00:00.000Z')
+    expect(gelesen.data.bestellungAm?.toISOString()).toBe('2025-11-07T00:00:00.000Z')
+    expect(gelesen.data.aufgabenkreise).toEqual(['VERMOEGENSSORGE', 'GESUNDHEITSSORGE'])
+    expect(gelesen.data.befreiterBetreuer).toBe(true)
+    expect(gelesen.data.ehrenamtlich).toBe(true)
+  })
+
+  it('macht aus nicht gesendeten Feldern null, nicht undefined', () => {
+    const gelesen = BetreuteSchema.parse(formularLesen(ersteinrichtungsFormular()))
+
+    // Diese Felder standen nie auf dem Bildschirm. Sie muessen als null in
+    // der Datenbank landen, sonst schreibt Prisma sie gar nicht.
+    expect(gelesen.heimName).toBeNull()
+    expect(gelesen.diagnosen).toBeNull()
+    expect(gelesen.geburtsname).toBeNull()
+    expect(gelesen.heimEinzugAm).toBeNull()
+    expect(gelesen.bestellungBis).toBeNull()
+    expect(gelesen.aktenzeichenBezirk).toBeNull()
+    expect(gelesen.pflegegrad).toBeNull()
+    expect(gelesen.schwerbehinderungGdB).toBeNull()
+  })
+
+  it('haelt auch das vollstaendige Formular aus', () => {
+    const f = ersteinrichtungsFormular()
+    // So kommt es aus dem Bearbeitungsformular: alle Felder da, viele leer.
+    for (const feld of [
+      'anrede', 'geburtsname', 'geburtsort',
+      'heimName', 'heimStrasse', 'heimPlz', 'heimOrt', 'heimZimmer', 'heimTelefon',
+      'fruehereStrasse', 'frueherePlz', 'fruehererOrt',
+      'krankenkasse', 'krankenversichertennummer', 'pflegekasse',
+      'schwerbehinderungMerkzeichen', 'diagnosen', 'ermittelterWille',
+      'aufgabenkreiseFreitext', 'aktenzeichenBezirk', 'aktenzeichenSozialamt',
+      'rentenversicherungsnummer', 'steuerId', 'notizen',
+    ]) {
+      f.set(feld, '')
+    }
+    for (const feld of ['heimEinzugAm', 'pflegegradSeit', 'pflegegradBescheidVom', 'bestellungBis']) {
+      f.set(feld, '')
+    }
+    f.set('pflegegrad', '')
+    f.set('schwerbehinderungGdB', '')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success, 'Leere Felder duerfen nicht abgelehnt werden').toBe(true)
+  })
+
+  it('nimmt ausgefuellte Angaben unveraendert an', () => {
+    const f = ersteinrichtungsFormular()
+    f.set('heimName', '  Seniorenzentrum St. Katharina  ')
+    f.set('pflegegrad', '3')
+    f.set('diagnosen', 'COPD GOLD III')
+
+    const gelesen = BetreuteSchema.parse(formularLesen(f))
+    // Fuehrende und nachlaufende Leerzeichen fliegen raus.
+    expect(gelesen.heimName).toBe('Seniorenzentrum St. Katharina')
+    expect(gelesen.pflegegrad).toBe(3)
+    expect(gelesen.diagnosen).toBe('COPD GOLD III')
+  })
+
+  it('besteht weiterhin auf Vorname, Nachname und Geburtsdatum', () => {
+    const f = new FormData()
+    f.set('vorname', '')
+    f.set('nachname', '')
+    f.set('geburtsdatum', '')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success).toBe(false)
+
+    if (!gelesen.success) {
+      const felder = gelesen.error.flatten().fieldErrors
+      expect(Object.keys(felder).sort()).toEqual(['geburtsdatum', 'nachname', 'vorname'])
+    }
+  })
+
+  it('weist ein Geburtsdatum in der Zukunft ab', () => {
+    const f = ersteinrichtungsFormular()
+    f.set('geburtsdatum', '2099-01-01')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success).toBe(false)
+    if (!gelesen.success) {
+      expect(gelesen.error.flatten().fieldErrors.geburtsdatum?.[0]).toMatch(/Zukunft/)
+    }
+  })
+
+  it('weist ein unfertiges Datum ab, statt es stillschweigend zu verwerfen', () => {
+    const f = ersteinrichtungsFormular()
+    f.set('bestellungAm', '2025-11')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success).toBe(false)
+  })
+})
@@ -0,0 +1,105 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+/**
+ * Auswertung der Umgebungsvariablen.
+ *
+ * Der Anlass für diese Datei war ein Fehler im Betrieb: docker compose
+ * reicht `ENC_KEY_V2` immer durch — mit leerem Wert, wenn in der .env
+ * keiner steht. Die Schlüsselsammlung erkannte Schlüssel aber am
+ * Variablennamen statt am Inhalt, fand also ein leeres `ENC_KEY_V2` und
+ * brach ab. Die Meldung lautete „ENC_KEY_V2 fehlt", obwohl niemand einen
+ * zweiten Schlüssel wollte.
+ *
+ * Jede Prüfung hier lädt `@/lib/env` frisch, weil die Werte beim ersten
+ * Zugriff gemerkt werden.
+ */
+
+const ECHT = Buffer.alloc(32, 7).toString('base64')
+const ECHT_ZWEI = Buffer.alloc(32, 9).toString('base64')
+
+let vorher: NodeJS.ProcessEnv
+
+async function frischesEnv() {
+  // Leert die Modulregistrierung, damit der naechste Import das Modul neu
+  // auswertet - die Schluessel werden sonst nur beim ersten Mal gelesen.
+  vi.resetModules()
+  const { env } = await import('@/lib/env')
+  return env
+}
+
+beforeEach(() => {
+  vorher = { ...process.env }
+  for (const name of Object.keys(process.env)) {
+    if (/^ENC_KEY_V\d+$/.test(name)) delete process.env[name]
+  }
+  delete process.env.ENC_KEY_AKTIV
+})
+
+afterEach(() => {
+  process.env = vorher
+})
+
+describe('Verschlüsselungsschlüssel aus der Umgebung', () => {
+  it('nimmt einen einzelnen Schlüssel an', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
+    expect(env.aktiveSchluesselversion).toBe(1)
+  })
+
+  it('überspringt eine leere Schlüsselvariable', async () => {
+    // Genau das setzt docker compose, wenn in der .env kein zweiter
+    // Schlüssel steht: ENC_KEY_V2: ${ENC_KEY_V2:-}
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = ''
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
+    expect(env.aktiveSchluesselversion).toBe(1)
+  })
+
+  it('überspringt eine Variable, in der nur Leerzeichen stehen', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = '   '
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
+  })
+
+  it('nimmt beide Schlüssel an, wenn wirklich rotiert wird', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = ECHT_ZWEI
+    process.env.ENC_KEY_AKTIV = '2'
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()].sort()).toEqual([1, 2])
+    expect(env.aktiveSchluesselversion).toBe(2)
+  })
+
+  it('sagt beim Rotieren deutlich, wenn der neue Schlüssel fehlt', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = ''
+    process.env.ENC_KEY_AKTIV = '2'
+
+    const env = await frischesEnv()
+    expect(() => env.aktiveSchluesselversion).toThrow(/ENC_KEY_AKTIV=2/)
+    // Die Meldung nennt, was da ist, und die richtige Reihenfolge.
+    expect(() => env.aktiveSchluesselversion).toThrow(/Vorhanden sind die Versionen: 1/)
+    expect(() => env.aktiveSchluesselversion).toThrow(/zuerst den neuen Schluessel/)
+  })
+
+  it('beschwert sich, wenn gar kein Schlüssel gesetzt ist', async () => {
+    process.env.ENC_KEY_V2 = ''
+
+    const env = await frischesEnv()
+    expect(() => env.verschluesselungsschluessel).toThrow(/mindestens ENC_KEY_V1/)
+  })
+
+  it('weist einen Schlüssel falscher Länge ab', async () => {
+    process.env.ENC_KEY_V1 = Buffer.alloc(16, 1).toString('base64')
+
+    const env = await frischesEnv()
+    expect(() => env.verschluesselungsschluessel).toThrow(/32 Bytes/)
+  })
+})
Author	SHA1	Message	Date
Florian Wilde	38f4d8d91f	fix: Skripte lagen ohne Ausfuehrungsrecht im Repository Die Anleitung sagt "./scripts/update.sh" - auf Linux kam dort "Permission denied". Die drei .sh-Dateien lagen mit Modus 644 statt 755 im Index. Ursache ist der Entwicklungsrechner: Unter Windows steht core.filemode=false, git nimmt ein fehlendes Ausfuehrungsrecht dort gar nicht wahr. Gemeldet hat es der Betrieb, nicht der Bau. Wer von 1.1.0 oder aelter kommt, braucht einmalig "bash scripts/update.sh" - das alte Skript ist ja noch das nicht ausfuehrbare. Steht jetzt in README und Installationsanleitung. Zusaetzlich setzt update.sh nach dem Umschalten selbst ein chmod +x auf scripts/*.sh. Das faengt den Fall ab, dass jemand Dateien von Hand kopiert und das Recht dabei verliert - genau so kam man bisher an dieses Skript, bevor es in der laufenden Fassung existierte. Neu: tests/skripte.test.ts prueft nicht Verhalten, sondern Verpackung - Ausfuehrungsrecht im Index, Shebang, scripts/ im Docker-Abbild, die Sicherungsskripte in der Compose-Datei. Es ist der zweite Fehler dieser Art (vorher fehlte scripts/ ganz im Abbild, 1.0.1); beide Male war der Code richtig und kein Test sah hin, wie die Dateien beim Server ankommen. Gegenprobe gemacht: mit zurueckgesetztem Recht schlaegt er fehl und nennt die Datei. Nebenbei aufgefallen: scripts/version.mjs datierte in UTC. Diese Fassung waere um 00:08 deutscher Zeit auf den Vortag datiert worden. Rechnet jetzt in Europe/Berlin.	2026-08-23 00:13:05 +02:00
Florian Wilde	c38c988c3c	feat: Anmelden mit Passkey Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg - auf der Anmeldeseite und bei der erneuten Bestaetigung vor sensiblen Aktionen. Verwaltet unter "Mein Konto". Der Passkey ERSETZT den zweiten Faktor, statt zu ihm hinzuzukommen. Das ist tragbar, weil er zwei Faktoren in sich vereint: Besitz des Geraets und dessen Entsperrung. Damit das keine Annahme bleibt, wird die Nutzerverifikation angefordert (userVerification: 'required') und serverseitig nachgeprueft - eine Antwort ohne sie wird abgewiesen. TOTP muss vorher eingerichtet sein. Ein Passkey haengt an einem Geraet; waere er der einzige Weg hinein, koennte ein verlorenes Handy die Akte schliessen. Aufbau: - Die Pruefung laeuft vollstaendig im Credentials-Provider "passkey", nicht in der Server Action davor. Ein "war schon geprueft" ueber die Grenze zu reichen waere die Stelle, an der sich Anmeldungen faelschen lassen. - Challenges liegen serverseitig und werden per DELETE genau einmal verbraucht - die Datenbank entscheidet, wer sie bekommt. - Bereichskennung und Herkunft kommen aus AUTH_URL, nicht aus einer zweiten Konfigurationsquelle. - Ohne https wird der Knopf gar nicht erst angeboten. - Rate-Limiting, Kontosperre und Audit-Log gelten unveraendert; die Anmeldung nennt den verwendeten Passkey namentlich. Zwei Anmerkungen zur Migration: - "prisma migrate diff" wollte zusaetzlich die Trigramm-Indizes aus prisma/sql/suche.sql loeschen, die Prisma nicht kennt. Die Zeilen sind entfernt und im Migrationskopf vermerkt - ein DROP haette die unscharfe Suche stillgelegt, ohne dass etwas fehlgeschlagen waere. - "prisma format" hat das Schema durchgaengig neu ausgerichtet. Ohne Whitespace betrachtet sind es 88 hinzugefuegte Zeilen und keine geloeschte. Geprueft: 21 Einheitstests, drei End-to-End-Tests gegen Chromiums virtuellen Authenticator (einrichten, anmelden, bestaetigen, entfernen, Geraet ohne Verifikation abgewiesen), beide Geraeteprofile. 496 Tests, null Typfehler, Produktionsbau steht. Nebenbei: Die Zahlen im README waren veraltet (24 statt 33 Modelle, 46 statt 79 Seiten). Sie stehen jetzt mit dem Befehl daneben, mit dem man sie nachzaehlt.	2026-08-22 18:44:56 +02:00
Florian Wilde	9603917a86	fix: Changelog aus der Zielfassung, blockierende Dateien beiseite Zwei Fehler beim ersten Probelauf des Update-Skripts. Der Changelog blieb leer. Das Skript las CHANGELOG.md aus der Arbeitskopie - also aus dem LAUFENDEN Stand, der die neuen Abschnitte naturgemaess noch nicht kennt. Jetzt kommt er ueber git show aus der Zielfassung. Das Umschalten scheiterte an einer unversionierten Datei. Genau das passiert beim Sprung auf die Fassung, die dieses Skript eingefuehrt hat: Man holt es sich von Hand, und in der Zielfassung gehoert es dann dazu - git weigert sich, eine unversionierte Datei zu ueberschreiben. Solche Dateien werden jetzt nicht weggeworfen, sondern nach .vor-update-<zeit> beiseite geschoben, danach laeuft das Umschalten durch. Etappe: 8 Phase: Haertung	2026-08-22 15:10:40 +02:00
Florian Wilde	42eb242767	feat: Update-Skript, das die vergessenen Schritte mitnimmt Bisher war Aktualisieren eine Folge von Befehlen aus der Anleitung, und zwei davon vergisst man zuverlaessig: die Sicherung vorher und die beiden SQL-Skripte hinterher. Genau die hat es hier schon gekostet. ./scripts/update.sh macht das in einem Durchgang - mit zwei Eigenschaften, auf die es ankommt: Bis zur Rueckfrage wird nichts veraendert. Der erste Entwurf hat die eigenen Aenderungen beiseite gelegt und danach am Serverzugriff abgebrochen - Halbzustand, aus dem man erst wieder herausfinden muss. Jetzt laufen Pruefung, Abgleich und Changelog-Anzeige vollstaendig durch, bevor irgendetwas angefasst wird. Eigene Aenderungen an versionierten Dateien blockieren nicht. Im Betrieb passt man die docker-compose.yml an, bis etwas laeuft; genau diese Anpassungen sind spaeter oft schon eingearbeitet. Das Skript legt sie mit git stash beiseite - rueckholbar, nicht weggeworfen - und sagt, wie man sie zurueckbekommt. Wer sie wirklich loswerden will, nimmt --verwerfen. Die .env bleibt immer unangetastet. Schlaegt die Sicherung fehl, wird nicht aktualisiert. Schlaegt der Bau fehl, nennt das Skript den Weg zurueck. Nebenbei behoben: Der Port der MinIO-Konsole stand fest auf 9001. Lief dort schon etwas, startete der ganze Stapel nicht. Jetzt ueber MINIO_KONSOLE_PORT einstellbar - dieselbe Moeglichkeit, die APP_PORT schon hatte. Aufgefallen beim Aufsetzen einer Testumgebung. Etappe: 8 Phase: Haertung	2026-08-22 15:09:01 +02:00
Florian Wilde	7780739a1a	fix: Ersteinrichtung liess sich nicht abschliessen, Betreute nicht loeschen Zwei Fehler, beide erst im Betrieb sichtbar. 1. Schritt 3 der Ersteinrichtung meldete "Bitte pruefe die markierten Felder" - und markierte keines. Man kam dort nicht weiter. Das kurze Formular schickt neun Felder, das vollstaendige unter Stammdaten alle. Beide gehen durch dasselbe Schema, und die optionalen Felder waren zwar nullable, aber nicht optional: Ein Feld, das gar nicht abgeschickt wurde, ist undefined, nicht null. Beanstandet wurden also zwei Dutzend Felder, die auf dem Bildschirm nie standen. Damit das nicht wiederkommt, unterscheidet die Aktion jetzt zwischen Eingabefehler und Formular-Schema-Bruch: Beanstandet die Pruefung ein Feld, das nicht abgeschickt wurde, sagt sie das ausdruecklich und schreibt es ins Serverlog, statt es dem Nutzer als Eingabefehler unterzuschieben, den er nirgends finden kann. 2. Eine betreute Person liess sich nicht endgueltig loeschen. Postgres setzt beim Loeschen den Verweis im Audit-Log auf NULL, und genau dieses UPDATE hat der Unveraenderlichkeits-Trigger abgewiesen. Damit scheiterte auch das Leeren des Papierkorbs nach 30 Tagen. Der Trigger erlaubt jetzt genau eine Ausnahme: das Nullen der beiden Fremdschluessel. Jede andere Aenderung bleibt verboten, auch das Setzen eines Fremdschluessels auf einen anderen Wert. Der Nachweis bleibt vollstaendig - es verschwindet nur der Verweis auf einen Datensatz, den es nicht mehr gibt. Geprueft: sieben neue Tests gegen die tatsaechlichen Formularinhalte, der Ablauf einmal komplett im Browser bis zum Dashboard, und der Trigger gegen eine laufende Datenbank - Loeschen gelingt, Faelschen scheitert. Etappe: 8 Phase: Haertung	2026-08-22 14:36:18 +02:00
Florian Wilde	9365645f72	fix: Bindeadresse war in der Vorlage stillschweigend vorbelegt .env.example setzte APP_BIND=127.0.0.1 als fertigen Wert, mitten zwischen lauter anderen fertigen Werten. Wer die Datei kopiert und seinen Reverse Proxy auf einem anderen Server betreibt, kommt damit nicht an die Anwendung heran - und der Fehler sieht aus, als laege es am Proxy. Der sichere Standard bleibt 127.0.0.1. Er wird nur nicht mehr als "schon erledigt" praesentiert, sondern als Entscheidung mit drei benannten Faellen: Proxy daneben, Proxy woanders mit privatem Netz, Proxy woanders ohne. Beim dritten Fall steht die Firewallregel dabei. Die Installationsanleitung nennt APP_BIND jetzt schon in Schritt 3, wo die .env ausgefuellt wird - nicht erst in Schritt 7, wo der Proxy drankommt. Wer der Anleitung von oben nach unten folgt, stolpert sonst erst vier Schritte spaeter darueber. Dazu ein eigener Abschnitt in der Fehlersuche mit den zwei curl-Proben, die den Unterschied zwischen falscher Bindeadresse und Firewall zeigen - und dem Hinweis, dass dafuer kein Neubau noetig ist. Am Programm aendert sich nichts. Etappe: 8 Phase: Haertung	2026-08-22 14:22:38 +02:00
Florian Wilde	232543e2aa	fix: Leere Schluesselvariable legte die Verschluesselung lahm docker-compose.yml reicht ENC_KEY_V2 immer an den Behaelter durch - mit leerem Wert, wenn in der .env keiner steht. src/lib/env.ts erkannte Schluessel aber am Variablennamen statt am Inhalt, fand also ein leeres ENC_KEY_V2 und brach ab mit "Umgebungsvariable ENC_KEY_V2 fehlt". Die Meldung war doppelt irrefuehrend: Sie nannte einen Schluessel, den niemand wollte, und sie erschien an einer Stelle, die damit nichts zu tun hat - beim Einrichten des zweiten Faktors, als Serverfehler ohne Text. Betroffen war jede Stelle, die verschluesselte Felder schreibt oder liest, also praktisch alles ausser der Anmeldung selbst. Die kam durch, weil sie ohne Verschluesselung auskommt - der Fehler trat deshalb erst auf der naechsten Seite auf, und der Zusammenhang war nicht zu sehen. Leere Schluesselvariablen werden jetzt uebersprungen. Sieben Tests decken die Auswertung ab, darunter genau diese Konstellation. Die Meldung beim Schluesselwechsel nennt jetzt ausserdem, welche Versionen vorhanden sind, und die richtige Reihenfolge: erst den neuen Schluessel eintragen, dann ENC_KEY_AKTIV umstellen. Dazu scripts/anmeldung-pruefen.mjs. Das Anmeldeformular sagt bewusst nicht, woran eine Anmeldung scheiterte - sonst liesse sich daran ablesen, welche Adressen es gibt. Auf dem Server darf man es wissen: Jeder Versuch wird mit Grund protokolliert, und das Skript liest ihn vor, zusammen mit dem Zustand des Zugangs, dem Stand der Sperre und der AUTH_URL. Etappe: 8 Phase: Haertung	2026-08-22 14:00:25 +02:00