Merge branch 'phase/030-gitea-abgleich-2'

chore(gitea): Issues nach Gitea, Basic-Auth fuer Konto-Passwort (#030 )
In den Git-Zugangsdaten steht das Konto-Passwort, kein API-Token. Gitea nimmt es nur per Basic-Auth an; das Skript erkennt das jetzt selbst. Alle 30 Issues mit Labels und Meilensteinen uebertragen. Neu: #031 Rotation des Deployment-Keys und #032 Nacharbeiten fuer 1.0.0. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 17:13:18 +02:00 · 2026-10-12 17:13:15 +02:00 · 2026-10-12 17:08:19 +02:00 · 2026-10-12 17:08:17 +02:00 · 2026-10-12 17:08:06 +02:00 · 2026-10-12 17:02:54 +02:00
269 changed files with 26642 additions and 623 deletions
@@ -59,6 +59,25 @@ SSHKV_BREAKGLASS_PASSWORD=
 # --- Worker --------------------------------------------------------------------
 # Zeitplan fuer den Abgleich aller Hosts (cron)
 SSHKV_SYNC_CRON=30 2 * * *
 # Taegliche Zusammenfassung der Benachrichtigungen (cron, Europe/Berlin, #028). Geaenderte
 # Host-Keys meldet der Worker unabhaengig davon alle fuenf Minuten. Kanaele und Anlaesse
 # stellt ein Admin unter /einstellungen ein.
 SSHKV_MELDUNG_CRON=0 7 * * *
 # --- Syslog (optional, #027) ---------------------------------------------------
 # Jeder Protokolleintrag geht zusaetzlich als RFC-5424-Zeile an einen Syslog-Server – die
 # Kopie ausserhalb von sshkv. Ohne SSHKV_SYSLOG_HOST ist die Weiterleitung aus. Es gehen nur
 # Akteur, Aktion, Ergebnis, Host, Zielbenutzer, Fingerprint und Hash hinaus, nie Details/Diff.
 # Web und Worker protokollieren beide; beide brauchen die Variablen.
 # SSHKV_SYSLOG_HOST=syslog.intern
 # Standard 514
 # SSHKV_SYSLOG_PORT=514
 # udp (Standard) oder tcp (Oktettzaehlung nach RFC 6587)
 # SSHKV_SYSLOG_PROTOKOLL=udp
 # APP-NAME im Syslog-Kopf (Standard sshkv)
 # SSHKV_SYSLOG_APPNAME=sshkv
 # Facility (Standard authpriv; auch auth, daemon, user, local0 … local7)
 # SSHKV_SYSLOG_FACILITY=authpriv
 # --- Integrationstests (#011) ---------------------------------------------------
 # SSH-Testziele aus docker-compose.test.yml. Die Compose-Datei liest dieselben Variablen
@@ -70,3 +89,8 @@ SSHKV_TEST_ROOT_PASSWORT=sshkv-test
 SSHKV_TEST_TEST_PASSWORT=sshkv-test
 # Mock-OIDC (Port-Bindung)
 SSHKV_TEST_OIDC=127.0.0.1:8090
 # Mailpit fuer tests/integration/benachrichtigung.test.ts (#028), getrennt zu starten:
 #   docker run -d --name sshkv-mailpit -e MP_SMTP_DISABLE_RDNS=true \
 #     -p 127.0.0.1:1026:1025 -p 127.0.0.1:8026:8025 axllent/mailpit
 SSHKV_TEST_SMTP=127.0.0.1:1026
 SSHKV_TEST_MAILPIT_API=http://127.0.0.1:8026
@@ -15,6 +15,78 @@ und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 ### Sicherheit
 ## [0.5.0] – 2026-10-12
 Phase 5: Übersicht, Audit-Log, Benachrichtigungen, Handbuch und Betrieb.
 ### Hinzugefügt
 - Übersicht mit echten Zahlen: Kennzahlen, Hosts mit Abweichung, bald ablaufende und abgelaufene Schlüssel, letzte Aktionen (#026)
 - Audit-Log: Filter, aufklappbare Einträge mit Diff und Hashes, Prüfung der Hash-Kette, CSV-Export (gestreamt), optionale Syslog-Kopie nach RFC 5424 (#027)
 - Benachrichtigungen per E-Mail (Microsoft 365 SMTP vorbelegt) und Webhook mit Signatur: tägliche Zusammenfassung zu Drift, Ablauf und nicht erreichbaren Hosts, geänderte Host-Keys sofort; Testversand, Versandprotokoll ohne Doppelmeldungen; Einstellungsseite (#028)
 - Handbuch mit Bildern, Installation mit authentik und Reverse Proxy, Bedrohungsanalyse mit Notfallplan (#029)
 - `deploy/sichern.sh` und `deploy/wiederherstellen.sh` – Wiederherstellung auf einem Wegwerf-Stapel geprobt (#029)
 ### Geändert
 - Der Worker startet nicht, wenn der Master-Key nicht zur Datenbank passt (#029)
 ### Sicherheit
 - Sicherung ohne Master-Key, nur mit Prüfwert; Wiederherstellung bricht vor jeder Änderung ab, wenn der Master-Key nicht passt, und läuft in einer Transaktion
 - SMTP-Passwort und Webhook-Geheimnis verschlüsselt gespeichert und nie wieder angezeigt; Webhook nur über https, ohne Weiterleitungen
 - Syslog-Kopie enthält nie Details oder Diffs
 ## [0.4.0] – 2026-10-12
 Phase 4: Abgleich, Import, Rotation, Widerruf und Zuweisungsmatrix.
 ### Hinzugefügt
 - Abgleich je Host und nächtlich per Zeitplan (`SSHKV_SYNC_CRON`): erkennt fehlende Schlüssel, von Hand geänderte Blöcke, unbekannte Schlüssel, falsche Rechte, beschädigte Blöcke und veränderte Private Keys; Befunde öffnen und schließen sich selbst. Hostseite mit Abweichungen und Ist-Zustand je Benutzer, „Jetzt abgleichen“ auch auf der Übersicht (#021)
 - Unbekannte Schlüssel übernehmen: als bekannt aufnehmen oder per Dry-Run in den verwalteten Block holen (#022)
 - Geführte Rotation: neuer Schlüssel an allen Stellen, Verbindungstests, erst dann wird der alte entfernt; jederzeit fortsetzbar, Rotationskette auf der Schlüsselseite (#023)
 - Widerruf mit einem Klick und Massenwiderruf: Public Key, Private Key, config- und known_hosts-Einträge entfernen, optional Zielkonten; Zwischenzustand, solange ein Host nicht erreicht wird; abgelaufene Schlüssel mit Hinweis (#024)
 - Zuweisungsmatrix Schlüssel × Host mit Filtern, Zell-Dialog zum Zuweisen und CSV-Export (#025)
 - Skript zum Abgleich der Issues nach Gitea (`pnpm issues:sync`, #030 – Zugang steht noch aus)
 ### Sicherheit
 - Abgleich liest Dateien als der jeweilige Benutzer und ändert auf dem Host nichts
 - Zeilen außerhalb des verwalteten Blocks entfernt sshkv nur bei ausdrücklich übernommenen Schlüsseln
 - Ein Widerruf gilt erst als abgeschlossen, wenn der Schlüssel wirklich überall entfernt ist; eine Rotation entfernt den alten Schlüssel erst nach erfolgreichen Verbindungstests
 - CSV-Export entschärft Werte, die eine Tabellenkalkulation als Formel lesen würde
 ## [0.3.0] – 2026-10-12
 Phase 3: Host-zu-Host – Private Keys, Zielkonten, Vorlagen und Assistent.
 ### Hinzugefügt
 - Host-zu-Host-Assistent: Vorlage wählen, Host A und B, Zielbenutzer, Einschränkungen und `~/.ssh/config`-Alias, Fingerprint von B bestätigen, Dry-Run, ausrollen, Verbindung testen – in einem Durchgang (#020)
 - Zielbenutzer (z. B. `deploy`) auf dem Ziel anlegen, mit sudoers-Datei für bestimmte Befehle oder vollen Zugriff; Vorschau vor dem Anlegen, Prüfung mit `visudo -c` (#018)
 - Vorlagen verwalten: eingebaute „Deployment-Zugang“, „Backup-Zugang“, „Admin-Zugang Person“, eigene anlegen und archivieren, Live-Vorschau der Platzhalter und des sudoers-Inhalts (#019)
 - Übersicht verlinkt den Assistenten
 ### Sicherheit
 - Neue Benutzer mit sudo nur durch Admins mit frischer Bestätigung
 - sshkv überschreibt keine fremde sudoers-Datei und fasst Systemkonten nicht an; ein Widerruf löscht nur Benutzer, die sshkv selbst angelegt hat
 - Platzhalter-Werte können keine zusätzlichen authorized_keys-Optionen einschleusen
 ## [0.2.0] – 2026-10-12
 Phase 2: Schlüssel, Personen und Ausrollen von Public Keys – dazu vorgezogen aus Phase 3 das Ausrollen von Private Keys.
 ### Hinzugefügt
 - Schlüssel erzeugen (ed25519, RSA-4096, optional mit Passphrase), Paar oder Public Key importieren, Public Key exportieren; Liste mit Filter, Detailseite mit Verwendungen (#012)
 - Personen verwalten; Self-Service „Meine Schlüssel“: jeder Benutzer hinterlegt eigene Public Keys, wirksam erst nach Zuweisung (#013)
 - Private Key anzeigen und herunterladen – nur Admin, nur nach erneuter Bestätigung, genau einmal abholbar; Private Key aus SSHKeyVault löschen (#014)
 - authorized_keys-Parser und verwalteter Block: fremde Zeilen bleiben bytegenau, beschädigte Blöcke werden nie überschrieben, Deployment-Key ist vor dem Entfernen geschützt (#015)
 - Public Keys Hosts oder Hostgruppen zuweisen, Dry-Run mit Diff, Ausrollen mit Backup und optimistischer Sperre; Ansicht je Schlüssel und je Host (#016)
 - Private Key auf einen Quell-Host ausrollen, mit verwaltetem Block in `~/.ssh/config` und `known_hosts` (#017)
 - Verbindungstest von Host A nach Host B (#020, Teil)
 - Zielbenutzer anlegen und sudoers pflegen – Grundlage, Oberfläche folgt (#018, Teil)
 - Vorlagen: Platzhalter und Prüfung – Grundlage, Oberfläche folgt (#019, Teil)
 ### Sicherheit
 - Importierte Private Keys reisen nur verschlüsselt im Job; Vorgang, Protokoll und Browser sehen sie nie (Tests)
 - Private-Key-Ziele nimmt der Dry-Run nur für Admins auf
 - Dateien in fremden Home-Verzeichnissen werden als deren Benutzer gelesen und geschrieben (Symlink-Schutz)
 ## [0.1.0] – 2026-10-12
 Phase 1: Grundgerüst, Anmeldung, Hosts und Bootstrap.
@@ -2,8 +2,8 @@
 ## Zeitübersicht
-**Gesamt (Wandzeit):** 1 h 25 min  
+**Gesamt (Wandzeit):** 4 h 25 min  
-**Summe der Issue-Zeiten:** 4 h 23 min – Sub-Agenten arbeiteten parallel an #002, #006, #008 und #011.
+**Summe der Issue-Zeiten:** 13 h 18 min – Sub-Agenten arbeiteten parallel an #002, #006, #008, #011, #012–#014, #019 (Oberfläche), #023–#025, #027 und #028.
 | Issue | Zeit |
 |---|---|
@@ -19,10 +19,33 @@
 | #009 Host-Key-Prüfung | 0 h 25 min |
 | #010 Bootstrap | 0 h 35 min |
 | #011 Test-SSH-Container | 0 h 15 min |
 | #012 Schlüssel erzeugen, importieren, exportieren | 0 h 25 min |
 | #013 Personen und Self-Service | 0 h 10 min |
 | #014 Private Key anzeigen | 0 h 10 min |
 | #015 authorized_keys-Parser | 0 h 15 min |
 | #016 Public Key ausrollen | 0 h 40 min |
 | #017 Private Key ausrollen | 0 h 45 min |
 | #018 Zielbenutzer und sudoers | 0 h 30 min |
 | #019 Vorlagen | 0 h 20 min |
 | #020 Host-zu-Host-Assistent | 0 h 50 min |
 | #021 Abgleich und Drift-Erkennung | 0 h 45 min |
 | #022 Import bestehender Schlüssel | 0 h 20 min |
 | #023 Geführte Rotation | 0 h 20 min |
 | #024 Widerruf und Massenwiderruf | 0 h 25 min |
 | #025 Zuweisungsmatrix | 0 h 30 min |
 | #026 Übersicht | 0 h 25 min |
 | #027 Protokollansicht, CSV, Syslog | 0 h 20 min |
 | #028 Benachrichtigungen | 0 h 30 min |
 | #029 Handbuch und Betriebsdokumentation | 0 h 50 min |
 | #030 Gitea-Abgleich (vorbereitet) | 0 h 05 min |
 | Meilenstein | Zeit |
 |---|---|
 | v0.1.0 | 1 h 25 min (Wandzeit) | **abgeschlossen**
 | v0.2.0 | 1 h 00 min (Wandzeit) | **abgeschlossen**
 | v0.3.0 | 0 h 30 min (Wandzeit) | **abgeschlossen**
 | v0.4.0 | 0 h 45 min (Wandzeit) | **abgeschlossen**
 | v0.5.0 | 0 h 45 min (Wandzeit) | **abgeschlossen**
 ---
@@ -55,3 +78,74 @@
 - **Eigene Testdatenbank je parallelem Lauf:** Sub-Agent und Hauptsitzung leerten sich gegenseitig die Tabellen (in `CLAUDE.md` festgehalten).
 - **Prisma-Client in den Worker gebündelt:** Im Standalone-Abbild fand die ESM-Auflösung `@prisma/client` sonst nicht (erst im echten Docker-Stapel aufgefallen).
 - **Worker-Benutzer in Compose wählbar** (`SSHKV_WORKER_USER`), weil Docker-Secrets ohne Swarm die Rechte der Host-Datei tragen.
 ## 2026-10-12 · Sitzung 2 · 10:07–11:07
 **Issue:** #012–#020
 **Version:** 0.2.0
 ### Erledigt
 - #012–#014 (Schlüssel, Personen/Self-Service, Private Key anzeigen) von einem Sub-Agenten in eigenem Worktree, danach gemergt; Konflikte in `useVorgang` und der Handler-Tabelle zusammengeführt
 - #015 authorized_keys-Parser und Merge mit 26 Randfall-Tests
 - #016 Public Keys ausrollen: Soll, Trockenlauf, Ausrollen, Hostseite, Schlüsselseite – Integrationstests und E2E
 - #017 Private Key mit `~/.ssh/config` und `known_hosts` – Integrationstest „A meldet sich bei B an“, E2E für den ganzen Kern-Anwendungsfall
 - Vorgezogen: #018 Zielkonto-Skripte (Integrationstests), #019 Vorlagen-Logik, #020 Verbindungstest
 - Stand: 410 Unit-/DB-Tests, 30 Integrationstests, 12 E2E-Abläufe grün
 ### Entscheidungen
 - **Phase 3 teilweise vorgezogen,** weil Florian „weiter“ sagte, während der Agent noch an Phase 2 arbeitete – nur Teile ohne Schemaänderung, damit die Migrationen des Agenten nicht kollidieren.
 - **Trockenlauf und Ausrollen als zwei Vorgänge mit Hash-Sperre:** Es wird nie etwas anderes geschrieben, als jemand gesehen hat.
 - **Private-Key-Ziele im Dry-Run nur für Admins:** Sonst hätte ein Operator einen vorbereiteten Private Key ausrollen lassen können (Freigabe Frage 3).
 - **Keine Sicherungskopie alter Private Keys** auf dem Host; config-Block am Dateianfang, weil ssh den ersten Treffer nimmt.
 - **Ein Hook `useVorgang` für alle:** zwei parallel entstandene Fassungen zusammengeführt, beide Schnittstellen bleiben.
 ## 2026-10-12 · Sitzung 3 · 11:06–11:36
 **Issue:** #018–#020
 **Version:** 0.3.0
 ### Erledigt
 - #019 Vorlagen-Oberfläche (Liste, Formular, Live-Vorschau) von einem Sub-Agenten, gemergt
 - #018 Zielkonten als Vorgänge mit Migration, Herkunft gemerkt; Integrationstest anlegen → entfernen
 - #020 Host-zu-Host-Assistent mit Vorlagen, wiederaufnehmbarer Ausführung und Verbindungstest; E2E mit „Deployment-Zugang“
 - Stand: 423 Unit-/DB-Tests, 31 Integrationstests, 16 E2E-Abläufe grün
 ### Entscheidungen
 - **Migration auf Ortszeit-Reihenfolge umbenannt** (`20261012110000`): Prisma vergibt UTC-Zeitstempel, die Migrationen des Agenten trugen Ortszeit – sonst stünde die neue vor älteren.
 - **Bestätigung im neuen Tab:** Der Assistent hält seine Eingaben im Speicher; eine Umleitung nach `/bestaetigen` hätte sie gelöscht.
 - **Ausführung des Assistenten als Kette im Klick** statt als Hook-Zustandsmaschine – einfacher, und erledigte Schritte lassen sich beim Fortsetzen überspringen.
 - **Prozesse stoppen nur über ein Skript, das Programm und Arbeitsverzeichnis prüft:** Zweimal hatte ein zu breites Suchmuster die eigene Shell getroffen.
 ## 2026-10-12 · Sitzung 4 · 12:50–13:35
 **Issue:** #021–#025, #030
 **Version:** 0.4.0
 ### Erledigt
 - Zweites, getrenntes Paar SSH-Testziele (`sshkv-test-b`, Ports 2231/2232, Mock-OIDC 8091) für den Rotation/Widerruf-Agenten, damit Integrationstests sich nicht gegenseitig zurücksetzen
 - #021 Abgleich mit reiner Befundlogik, Worker-Ablauf, Zeitplan; #022 Übernahme mit neuem Feld `ausserhalbEntfernen` – Integrationstests und E2E
 - #023/#024 Rotation und Widerruf (Sub-Agent) mit Zwischenzustand `widerrufEingeleitetAm`; #025 Zuweisungsmatrix (Sub-Agent)
 - #030 Gitea-Skript bereitgelegt (Trockenlauf läuft)
 - Stand: 470 Unit-/DB-Tests, 38 Integrationstests, 21 E2E-Abläufe grün
 ### Entscheidungen
 - **Abgleich ändert nichts auf dem Host:** Er meldet nur; Korrekturen laufen über Dry-Run und Ausrollen, damit ein Mensch sie sieht.
 - **Bekannte Schlüssel außerhalb des Blocks sind kein Befund** – nur unbekannte. Sonst meldete jeder bewusst stehen gelassene Admin-Key dauerhaft Drift.
 - **Widerruf mit Zwischenzustand:** Ein Schlüssel wird erst WIDERRUFEN, wenn er überall entfernt ist; ein nicht erreichbarer Host lässt ihn erkennbar „unvollständig“.
 - **Rotation entfernt den alten Schlüssel erst nach erfolgreichen Verbindungstests**; doppelte Aliase in `~/.ssh/config`: die jüngste Zuweisung gewinnt.
 - **Migrationszeitstempel in Ortszeit-Reihenfolge** auch bei parallel entstandenen Migrationen (`…130000` Agent, `…131000` Hauptsitzung).
 ## 2026-10-12 · Sitzung 5 · 16:27–17:12
 **Issue:** #026–#029
 **Version:** 0.5.0
 ### Erledigt
 - #026 Übersicht aus der Datenbank; lesbare Aktionstexte aus #027
 - #027 Audit-Log-Ansicht, Kettenprüfung, CSV, Syslog (Sub-Agent)
 - #028 Benachrichtigungen und Einstellungsseite (Sub-Agent, eigener Mailpit und eigene Testziele)
 - #029 Handbuch (12 Kapitel mit Bildern), Installation, Bedrohungsanalyse, Sicherung; Sicherung/Wiederherstellung geprobt
 - Merge-Konflikte (Compose, Screenshot-Skript, Worker-Einstieg) zusammengeführt; der strukturelle Test für Aktionstexte fand vier neue Aktionen ohne Text
 - Stand: 858 Unit-/DB-Tests, 43 Integrationstests, 24 E2E-Abläufe grün
 ### Entscheidungen
 - **Wiederherstellung wirklich geprobt** statt nur beschrieben – sie fand zwei Fehler, die im Ernstfall die Wiederherstellung verhindert hätten.
 - **Master-Key nicht in die Sicherung,** nur ein Prüfwert; Worker verweigert den Start mit falschem Master-Key.
 - **Benachrichtigungen lesen ihre Anlässe aus der Datenbank** statt sich in den Abgleich einzuhängen; Doppelmeldungen verhindert ein Versandprotokoll mit Fingerabdruck je Anlass.
 - **Keine 1.0.0 ohne Abnahme:** 0.5.0 schließt die fünf Phasen; authentik, Gitea und ein Lauf auf echten Hosts stehen noch aus.
@@ -4,9 +4,9 @@ Selbst gehostete Weboberfläche zur zentralen Verwaltung von SSH-Schlüsseln: Sc
 erzeugen und verwalten, Public Keys in `authorized_keys` verteilen, Private Keys gezielt auf
 andere Hosts ausrollen, Ist- und Soll-Zustand abgleichen – alles revisionssicher protokolliert.
-> **Stand 0.1.0 (Phase 1):** Grundgerüst, Anmeldung (OIDC + Notfall-Admin mit TOTP), Hosts und
+> **Stand 0.5.0:** alle fünf Phasen aus [`docs/PLAN.md`](docs/PLAN.md) umgesetzt – Hosts mit Host-Key-Prüfung
-> Hostgruppen, Host-Key-Prüfung (TOFU) und Bootstrap neuer Hosts. Schlüsselverwaltung und
+> und Bootstrap, Schlüssel, Ausrollen von Public und Private Keys mit Dry-Run, Host-zu-Host-Assistent,
-> Ausrollen folgen in Phase 2 und 3 – siehe [`docs/PLAN.md`](docs/PLAN.md).
+> Abgleich, Rotation, Widerruf, Zuweisungsmatrix, Audit-Log, Benachrichtigungen. 1.0.0 nach der Abnahme.
 ## Sicherheit vorab
@@ -18,7 +18,15 @@ SSHKeyVault hat **root-Zugriff auf alle verwalteten Hosts**. Deshalb:
 - Private Keys liegen nur verschlüsselt in der Datenbank (AES-256-GCM, Envelope Encryption);
  entschlüsseln kann ausschließlich der Worker, der Webprozess hat den Master-Key nicht.
-Mehr dazu in [`docs/PLAN.md`](docs/PLAN.md), Abschnitt 3.
+Mehr dazu in [`docs/betrieb/sicherheit.md`](docs/betrieb/sicherheit.md) (mit Bedrohungsanalyse und
 Notfallplan) und [`docs/betrieb/sicherung.md`](docs/betrieb/sicherung.md).
 ## Dokumentation
 - [Handbuch](docs/anleitung/README.md) – Bedienung Schritt für Schritt mit Bildern
 - [Installation und Betrieb](docs/betrieb/installation.md) – Docker Compose, authentik, Reverse Proxy
 - [Sicherung und Wiederherstellung](docs/betrieb/sicherung.md) – `deploy/sichern.sh`, `deploy/wiederherstellen.sh`
 - [Sicherheit](docs/betrieb/sicherheit.md) – Aufbau, Bedrohungsanalyse, Notfallplan
 ## Installation (Docker Compose)
@@ -0,0 +1,67 @@
 #!/usr/bin/env bash
 # SSHKeyVault sichern (#029).
 #
 #   bash deploy/sichern.sh                       # nach /var/backups/sshkv
 #   bash deploy/sichern.sh /mnt/sicherung/sshkv  # anderes Ziel
 #
 # Sichert die Datenbank (pg_dump mit --clean, damit sie sich auch in eine nicht leere
 # Datenbank zurueckspielen laesst) und legt einen Pruefwert des Master-Keys daneben.
 #
 # Den MASTER-KEY selbst sichert dieses Skript absichtlich NICHT mit: Datenbank und Master-Key
 # zusammen geben alle Private Keys preis. Den Master-Key einmalig und GETRENNT aufbewahren
 # (Passwortmanager, Tresor, zweites Medium) – ohne ihn ist jede Sicherung wertlos.
 # Siehe docs/betrieb/sicherung.md.
 set -o errexit
 set -o nounset
 set -o pipefail
 VERZEICHNIS=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
 cd "$VERZEICHNIS"
 gruen() { printf '\033[1;32m✓ %s\033[0m\n' "$*"; }
 gelb() { printf '\033[1;33m! %s\033[0m\n' "$*"; }
 fehler() {
  printf '\033[1;31m✗ %s\033[0m\n' "$*" >&2
  exit 1
 }
 ZIEL="${1:-/var/backups/sshkv}"
 BEHALTEN="${SSHKV_SICHERUNGEN_BEHALTEN:-14}"
 STAND=$(date +%Y%m%d-%H%M%S)
 mkdir -p "$ZIEL"
 chmod 0700 "$ZIEL"
 # Datenbank: als Klartext-SQL, gzip-komprimiert. Enthaelt nur verschluesselte Private Keys.
 # Nur das Schema public: Die Warteschlange (Schema pgboss) legt der Worker beim Start neu an,
 # und ihre partitionierten Tabellen lassen sich mit --clean nicht zurueckspielen (in der
 # Wiederherstellungsprobe aufgefallen).
 docker compose exec -T db pg_dump -U sshkv --clean --if-exists --no-owner --schema=public sshkv \
  | gzip -9 > "${ZIEL}/datenbank-${STAND}.sql.gz" \
  || fehler "pg_dump ist fehlgeschlagen. Läuft der Dienst db?"
 [ -s "${ZIEL}/datenbank-${STAND}.sql.gz" ] || fehler "Die Sicherung ist leer."
 chmod 0600 "${ZIEL}/datenbank-${STAND}.sql.gz"
 gruen "Datenbank gesichert: ${ZIEL}/datenbank-${STAND}.sql.gz"
 # Pruefwert des Master-Keys: verraet nichts ueber den Schluessel, zeigt beim Zurueckspielen
 # aber, ob der richtige Master-Key bereitliegt.
 ENV_DATEI="${SSHKV_ENV_DATEI:-.env}"
 SCHLUESSEL="$(grep -E '^SSHKV_MASTER_KEY_HOST_FILE=' "$ENV_DATEI" 2>/dev/null | cut -d= -f2- || true)"
 SCHLUESSEL="${SCHLUESSEL:-./geheim/master.key}"
 if [ -r "$SCHLUESSEL" ]; then
  sha256sum "$SCHLUESSEL" | cut -d' ' -f1 > "${ZIEL}/master-key-pruefwert-${STAND}.txt"
  chmod 0600 "${ZIEL}/master-key-pruefwert-${STAND}.txt"
  gruen "Prüfwert des Master-Keys abgelegt (nicht der Schlüssel selbst)."
 else
  gelb "Master-Key ${SCHLUESSEL} nicht lesbar – kein Prüfwert abgelegt (mit sudo ausführen?)."
 fi
 # Alte Sicherungen aufraeumen (samt Pruefwert).
 ls -1t "${ZIEL}"/datenbank-*.sql.gz 2>/dev/null | tail -n +"$((BEHALTEN + 1))" | while read -r alt; do
  alter_stand=$(basename "$alt" .sql.gz)
  alter_stand=${alter_stand#datenbank-}
  rm -f -- "$alt" "${ZIEL}/master-key-pruefwert-${alter_stand}.txt"
 done
 gelb "Den Master-Key getrennt aufbewahren – er gehört NICHT neben diese Sicherung."
@@ -0,0 +1,80 @@
 #!/usr/bin/env bash
 # SSHKeyVault aus einer Sicherung wiederherstellen (#029).
 #
 #   bash deploy/wiederherstellen.sh /var/backups/sshkv                   # jüngste Sicherung
 #   bash deploy/wiederherstellen.sh /var/backups/sshkv 20261012-170000
 #   bash deploy/wiederherstellen.sh … --ja                               # ohne Rückfrage
 #
 # Voraussetzung: Der zur Sicherung gehoerende Master-Key liegt an der in .env genannten Stelle
 # (SSHKV_MASTER_KEY_HOST_FILE). Das Skript vergleicht ihn mit dem Pruefwert der Sicherung und
 # bricht ab, wenn er nicht passt – sonst laeuft sshkv ohne lesbare Private Keys an.
 set -o errexit
 set -o nounset
 set -o pipefail
 VERZEICHNIS=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
 cd "$VERZEICHNIS"
 blau() { printf '\033[1;36m› %s\033[0m\n' "$*"; }
 gruen() { printf '\033[1;32m✓ %s\033[0m\n' "$*"; }
 fehler() {
  printf '\033[1;31m✗ %s\033[0m\n' "$*" >&2
  exit 1
 }
 QUELLE="${1:-/var/backups/sshkv}"
 STAND=""
 OHNE_RUECKFRAGE="nein"
 for argument in "${@:2}"; do
  if [ "$argument" = "--ja" ]; then OHNE_RUECKFRAGE="ja"; else STAND="$argument"; fi
 done
 [ -d "$QUELLE" ] || fehler "Kein Sicherungsordner unter ${QUELLE}."
 if [ -z "$STAND" ]; then
  DATENBANK=$(ls -1t "${QUELLE}"/datenbank-*.sql.gz 2>/dev/null | head -n1 || true)
 else
  DATENBANK="${QUELLE}/datenbank-${STAND}.sql.gz"
 fi
 [ -n "${DATENBANK:-}" ] && [ -f "$DATENBANK" ] || fehler "Keine Datenbanksicherung in ${QUELLE} gefunden."
 PRUEFWERT="${DATENBANK/datenbank-/master-key-pruefwert-}"
 PRUEFWERT="${PRUEFWERT/.sql.gz/.txt}"
 ENV_DATEI="${SSHKV_ENV_DATEI:-.env}"
 SCHLUESSEL="$(grep -E '^SSHKV_MASTER_KEY_HOST_FILE=' "$ENV_DATEI" 2>/dev/null | cut -d= -f2- || true)"
 SCHLUESSEL="${SCHLUESSEL:-./geheim/master.key}"
 if [ -f "$PRUEFWERT" ]; then
  [ -r "$SCHLUESSEL" ] || fehler "Master-Key ${SCHLUESSEL} nicht lesbar (mit sudo ausführen?)."
  [ "$(sha256sum "$SCHLUESSEL" | cut -d' ' -f1)" = "$(cat "$PRUEFWERT")" ] \
    || fehler "Der Master-Key unter ${SCHLUESSEL} gehört NICHT zu dieser Sicherung. Abbruch."
  gruen "Master-Key passt zur Sicherung."
 else
  printf '\033[1;33m! Kein Prüfwert zur Sicherung – der Worker prüft den Master-Key beim Start.\033[0m\n'
 fi
 printf '\033[1;33m! Achtung: Der aktuelle Datenbestand wird durch die Sicherung ersetzt.\033[0m\n'
 echo "  Sicherung: $(basename "$DATENBANK")"
 if [ "$OHNE_RUECKFRAGE" != "ja" ]; then
  read -r -p "Wirklich zurückspielen? [tippen Sie ja] " antwort
  [ "$antwort" = "ja" ] || fehler "Abgebrochen."
 fi
 blau "Weboberfläche und Worker anhalten …"
 docker compose stop web worker
 blau "Datenbank zurückspielen …"
 # Eine Transaktion: scheitert etwas, bleibt der alte Stand vollstaendig erhalten (in der
 # Wiederherstellungsprobe hatte ein Abbruch ohne Transaktion das Schema pgboss halb geloescht).
 gunzip -c "$DATENBANK" | docker compose exec -T db psql -U sshkv -d sshkv -v ON_ERROR_STOP=1 --single-transaction -q >/dev/null \
  || fehler "Zurückspielen fehlgeschlagen. Web und Worker sind angehalten – nach Klärung: docker compose up -d"
 # Die Warteschlange gehoert nicht zur Sicherung: frisch anlegen lassen (macht der Worker beim
 # Start), offene Vorgaenge abbrechen – ihre Jobs sind damit weg.
 docker compose exec -T db psql -U sshkv -d sshkv -q -c "DROP SCHEMA IF EXISTS pgboss CASCADE" >/dev/null
 docker compose exec -T db psql -U sshkv -d sshkv -q -c \
  "UPDATE \"Vorgang\" SET status = 'ABGEBROCHEN', fehler = 'Durch Wiederherstellung abgebrochen.', \"beendetAm\" = now() WHERE status IN ('WARTEND','LAEUFT')" >/dev/null
 blau "Dienste starten …"
 docker compose up -d --wait web worker
 sleep 3
 if docker compose logs --tail 20 worker 2>&1 | grep -q "passt nicht zur Datenbank"; then
  fehler "Der Worker meldet: Master-Key passt nicht zur Datenbank. Siehe docker compose logs worker."
 fi
 gruen "Wiederhergestellt aus $(basename "$DATENBANK")."
@@ -64,6 +64,15 @@ services:
      SSHKV_OIDC_GROUP_ADMIN: ${SSHKV_OIDC_GROUP_ADMIN:-sshkv-admins}
      SSHKV_OIDC_GROUP_OPERATOR: ${SSHKV_OIDC_GROUP_OPERATOR:-sshkv-operators}
      SSHKV_OIDC_GROUP_READER: ${SSHKV_OIDC_GROUP_READER:-sshkv-readers}
      # Syslog-Kopie des Protokolls (#027) – optional, leer heisst aus.
      SSHKV_SYSLOG_HOST: ${SSHKV_SYSLOG_HOST:-}
      SSHKV_SYSLOG_PORT: ${SSHKV_SYSLOG_PORT:-514}
      SSHKV_SYSLOG_PROTOKOLL: ${SSHKV_SYSLOG_PROTOKOLL:-udp}
      SSHKV_SYSLOG_APPNAME: ${SSHKV_SYSLOG_APPNAME:-sshkv}
      SSHKV_SYSLOG_FACILITY: ${SSHKV_SYSLOG_FACILITY:-authpriv}
      # Nur zur Anzeige unter /einstellungen; ausgefuehrt werden die Zeitplaene im Worker.
      SSHKV_SYNC_CRON: ${SSHKV_SYNC_CRON:-30 2 * * *}
      SSHKV_MELDUNG_CRON: ${SSHKV_MELDUNG_CRON:-0 7 * * *}
    # Absichtlich KEIN Master-Key: eine Luecke im Webprozess allein entschluesselt keine
    # Private Keys. Nach aussen braucht er nur den OIDC-Anbieter.
    ports:
@@ -94,9 +103,19 @@ services:
      SSHKV_APP_SECRET: ${SSHKV_APP_SECRET}
      SSHKV_MASTER_KEY_FILE: /run/secrets/master_key
      SSHKV_SYNC_CRON: ${SSHKV_SYNC_CRON:-30 2 * * *}
      # Syslog-Kopie des Protokolls (#027) – optional, leer heisst aus.
      SSHKV_SYSLOG_HOST: ${SSHKV_SYSLOG_HOST:-}
      SSHKV_SYSLOG_PORT: ${SSHKV_SYSLOG_PORT:-514}
      SSHKV_SYSLOG_PROTOKOLL: ${SSHKV_SYSLOG_PROTOKOLL:-udp}
      SSHKV_SYSLOG_APPNAME: ${SSHKV_SYSLOG_APPNAME:-sshkv}
      SSHKV_SYSLOG_FACILITY: ${SSHKV_SYSLOG_FACILITY:-authpriv}
      # Benachrichtigungen (#028): taegliche Zusammenfassung; Links in den Nachrichten zeigen
      # auf SSHKV_APP_URL. Den Weg zu Mailserver und Webhook-Ziel hat der Worker ueber "aussen".
      SSHKV_MELDUNG_CRON: ${SSHKV_MELDUNG_CRON:-0 7 * * *}
      SSHKV_APP_URL: ${SSHKV_APP_URL}
    secrets:
      - master_key
-    # Der Worker braucht die Datenbank und den Weg zu den Hosts.
+    # Der Worker braucht die Datenbank und den Weg zu den Hosts (und zu Mailserver/Webhook).
    networks: [datenbank, aussen]
    healthcheck:
      test: ["CMD-SHELL", "pgrep -f dist/worker.mjs > /dev/null"]
@@ -0,0 +1,234 @@
 # SSHKeyVault – Handbuch
 SSHKeyVault (`sshkv`) verwaltet SSH-Schlüssel zentral: Schlüsselpaare erzeugen, Public Keys in
 `authorized_keys` verteilen, Private Keys gezielt auf andere Hosts legen, Ist und Soll abgleichen –
 alles protokolliert. Installation und Betrieb: [../betrieb/installation.md](../betrieb/installation.md),
 Sicherung: [../betrieb/sicherung.md](../betrieb/sicherung.md), Sicherheit:
 [../betrieb/sicherheit.md](../betrieb/sicherheit.md).
 **Grundsatz:** Auf einem Host ändert sich nur etwas, nachdem Sie einen **Dry-Run** gesehen und
 „Änderung anwenden“ geklickt haben. Alles, was sshkv in `authorized_keys`, `~/.ssh/config` und
 `known_hosts` schreibt, steht in einem verwalteten Block:
 ```
 # BEGIN SSHKV MANAGED – nicht manuell bearbeiten
 …
 # END SSHKV MANAGED
 ```
 Zeilen außerhalb dieses Blocks bleiben unverändert – außer Sie übernehmen einen Schlüssel ausdrücklich
 in die Verwaltung.
 1. [Anmelden](#1-anmelden)
 2. [Übersicht](#2-übersicht)
 3. [Einen Host aufnehmen](#3-einen-host-aufnehmen)
 4. [Kern-Anwendungsfall: Host A meldet sich bei Host B an](#4-kern-anwendungsfall-host-a-meldet-sich-bei-host-b-an)
 5. [Deployment-Zugang für Claude Code mit dem Assistenten](#5-deployment-zugang-für-claude-code-mit-dem-assistenten)
 6. [Abgleich, Drift und Übernahme](#6-abgleich-drift-und-übernahme)
 7. [Rotation und Widerruf](#7-rotation-und-widerruf)
 8. [Personen, Self-Service und Zuweisungsmatrix](#8-personen-self-service-und-zuweisungsmatrix)
 9. [Vorlagen](#9-vorlagen)
 10. [Private Key anzeigen oder löschen](#10-private-key-anzeigen-oder-löschen)
 11. [Audit-Log](#11-audit-log)
 12. [Einstellungen und Benachrichtigungen](#12-einstellungen-und-benachrichtigungen)
 ---
 ## 1. Anmelden
 ![Anmeldeseite](bilder/anmelden-desktop.png)
 - **Mit authentik anmelden** – der Normalfall. Ihre Rolle (Leser, Operator, Admin) kommt aus den
  authentik-Gruppen und wird bei jeder Anmeldung neu bestimmt.
 - **Notfallzugang** – nur, wenn authentik ausfällt. Anmeldename, Passwort und ein Code aus einer
  Authenticator-App. Bei der ersten Anmeldung richtet der Notfall-Admin den zweiten Faktor ein
  (QR-Code scannen, Code bestätigen).
 Kritische Aktionen (Private Key anzeigen, Benutzer mit sudo anlegen, Massenwiderruf, Host-Key
 ersetzen) verlangen eine **erneute Bestätigung**; sie gilt fünf Minuten.
 ## 2. Übersicht
 ![Übersicht](bilder/uebersicht-desktop.png)
 Kennzahlen, Hosts mit Abweichung, bald ablaufende Schlüssel und die letzten Aktionen. Von hier aus:
 **Jetzt abgleichen** (alle Hosts), **Host-zu-Host-Assistent**, **Neuer Schlüssel**.
 ## 3. Einen Host aufnehmen
 **Hosts → + Host anlegen:** Name (z. B. `srv-pve01`), Adresse, Port, Gruppen, Tags. Bei
 **Anmeldung** ist „Dienstbenutzer `sshkv` mit sudo“ empfohlen – im auth.log des Hosts ist dann
 eindeutig zu sehen, was von sshkv kam, und root-Login kann aus bleiben.
 **Host-Key bestätigen.** „Host-Key abrufen“ holt den Fingerprint, ohne sich anzumelden. Vergleichen
 Sie ihn direkt am Host:
 ```bash
 ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
 ```
 ![Host-Key bestätigen](bilder/hostkey-bestaetigen-desktop.png)
 Erst nach „Fingerprint stimmt – vertrauen“ verbindet sich sshkv. Ändert sich der Host-Key später,
 bricht jede Verbindung ab und die Hostseite warnt deutlich – annehmen nur, wenn der Host wirklich neu
 installiert wurde.
 **Bootstrap.** Zwei Wege, den Deployment-Key von sshkv auf den Host zu bringen:
 - **Einmalig per Passwort** (root oder ein Benutzer mit sudo). Das Passwort wird nicht gespeichert.
 - **Per Befehl:** den angezeigten Befehl auf dem Host einfügen, danach „Einrichtung prüfen“.
 ![Eingerichteter Host](bilder/host-eingerichtet-desktop.png)
 Danach zeigt die Hostseite den **sshd-Befund**. Steht dort „root darf sich per Passwort anmelden“,
 empfiehlt sich `PermitRootLogin prohibit-password` in `/etc/ssh/sshd_config` – sshkv ändert das nicht
 von sich aus.
 ## 4. Kern-Anwendungsfall: Host A meldet sich bei Host B an
 Beispiel: Der Backup-Server `srv-backup01` soll sich als `root` per SSH auf `srv-pve01` anmelden.
 Beide Hosts sind aufgenommen (Kapitel 3).
 **1. Schlüssel erzeugen.** *Schlüssel → + Schlüssel anlegen → Erzeugen*: Zweck „Backup srv-backup01 →
 srv-pve01“, Typ ed25519, optional Ablaufdatum. Keine Passphrase – ein Cronjob kann sie nicht eingeben.
 ![Schlüssel anlegen](bilder/schluessel-neu-desktop.png)
 **2a. Private Key auf A.** In der Karte *Private Key ausgerollt auf* → **+ Ausrollen**: Quell-Host
 `srv-backup01`, Benutzer `root`, Pfad `~/.ssh/id_ed25519_…`. Mit **Eintrag in ~/.ssh/config** und
 Ziel-Host `srv-pve01` legt sshkv einen Alias an und trägt den (bereits bestätigten) Host-Key von B in
 `known_hosts` von A ein. *HostName* ist die Adresse, unter der **A** den Host B erreicht.
 **2b. Public Key auf B.** In der Karte *Public Key ausgerollt auf* → **+ Ausrollen**: Ziel
 `srv-pve01`, Benutzer `root`, optional Einschränkungen wie `from="10.0.0.12",no-pty`.
 2a und 2b sind unabhängig und jederzeit nachholbar.
 **3. Dry-Run und anwenden.** *Dry-Run starten* zeigt je Host, was sich ändert – beim Private Key nur
 „wird angelegt“, nie den Inhalt.
 ![Dry-Run](bilder/kern-dry-run-desktop.png)
 „Änderung anwenden“ schreibt genau das, was Sie gesehen haben (mit Sicherung der Dateien). Hat sich
 in der Zwischenzeit etwas auf dem Host geändert, bricht sshkv ab – dann den Dry-Run neu starten.
 **4. Verbindung testen.** In der Private-Karte „Verbindung testen“ ruft auf A
 `ssh -o BatchMode=yes <alias> true` auf – genau das, was später der Cronjob braucht.
 ![Ausgerollt und getestet](bilder/kern-ausgerollt-desktop.png)
 ## 5. Deployment-Zugang für Claude Code mit dem Assistenten
 Szenario: Claude Code auf `srv-rz-claude-linux` soll eine Anwendung per SSH auf `srv-app01`
 ausrollen. **Übersicht → Host-zu-Host-Assistent** (nur Admins):
 1. **Vorlage „Deployment-Zugang“** wählen, Zweck „Claude Code Deployment → srv-app01“. Die Vorlage
   setzt Benutzer `deploy`, 90 Tage Laufzeit, `from="<IP von A>"` und den Alias `deploy-<Ziel>`.
 2. **Quelle:** `srv-rz-claude-linux`, Benutzer, unter dem Claude Code läuft.
 3. **Ziel:** `srv-app01`, Benutzer `deploy` – „Benutzer anlegen“ ist vorgewählt; sudo nach Bedarf
   (keine, bestimmte Befehle mit Vorschau der sudoers-Datei, oder voll). Fingerprint von B bestätigen.
 ![Assistent – Ziel](bilder/assistent-ziel-desktop.png)
 4. **Prüfen** und „Vorbereiten“: sshkv erzeugt den Schlüssel, legt `deploy` an (frische Bestätigung
   nötig – sie öffnet sich in einem neuen Tab, Ihre Eingaben bleiben stehen) und legt die
   Zuweisungen an.
 5. **Ausrollen:** Dry-Run, anwenden, „Verbindung von A nach B testen“.
 ![Assistent – fertig](bilder/assistent-fertig-desktop.png)
 Claude Code kann danach einfach `ssh deploy-srv-app01` benutzen. Wählen Sie `root` als Ziel, warnt
 der Assistent: Ein KI-Agent hätte dann uneingeschränkten Zugriff.
 **Nach Projektende** (oder Ablaufdatum): auf der Schlüsselseite **Widerrufen** – entfernt Public und
 Private Key, config- und known_hosts-Eintrag und auf Wunsch den Benutzer `deploy` samt sudoers-Datei.
 ## 6. Abgleich, Drift und Übernahme
 Nachts um 02:30 (einstellbar) und auf Knopfdruck vergleicht sshkv jeden Host mit dem Soll. Gefunden
 werden fehlende Schlüssel, von Hand geänderte Blöcke, **unbekannte Schlüssel** außerhalb des Blocks,
 falsche Rechte von `~/.ssh` und veränderte Private Keys. Der Abgleich ändert auf dem Host nichts.
 ![Abgleich](bilder/abgleich-desktop.png)
 Ein unbekannter Schlüssel lässt sich **übernehmen**: nur als bekannt aufnehmen (der Befund
 verschwindet) oder „in den verwalteten Block holen“ – dann wandert die Zeile beim nächsten Ausrollen
 (mit Dry-Run) in den Block.
 ## 7. Rotation und Widerruf
 **Rotieren** (Schlüsselseite): Ein neuer Schlüssel kommt an alle Stellen des alten, der Alias in
 `~/.ssh/config` zeigt auf die neue Datei, die Verbindungen werden getestet – **erst dann** wird der
 alte entfernt. Die Rotation lässt sich jederzeit fortsetzen.
 ![Rotation](bilder/rotation-desktop.png)
 **Widerrufen** (Schlüsselseite, Gefahr-Knopf): Der Dialog zeigt, was entfernt wird; danach Dry-Run
 und anwenden. Ist ein Host nicht erreichbar, bleibt der Schlüssel als „Widerruf unvollständig“
 markiert, bis auch dort alles entfernt ist. **Massenwiderruf:** in der Schlüsselliste mehrere
 auswählen (nur Admin).
 ![Widerruf](bilder/widerruf-desktop.png)
 ## 8. Personen, Self-Service und Zuweisungsmatrix
 - **Personen:** Admins, Mitarbeiter, Dienstleister mit ihren Schlüsseln. Private Keys von Personen
  speichert sshkv nie.
 - **Meine Schlüssel:** Jede angemeldete Person kann eigene Public Keys hinterlegen. Wirksam werden
  sie erst, wenn ein Operator oder Admin sie einem Host zuweist.
 ![Meine Schlüssel](bilder/meine-schluessel-desktop.png)
 - **Zuweisungen:** Matrix Schlüssel × Host mit Filtern; ein Klick auf eine Zelle zeigt die
  Zuweisungen und erlaubt neue. Export als CSV.
 ![Zuweisungen](bilder/zuweisungen-desktop.png)
 ## 9. Vorlagen
 Vorlagen legen Schlüsseltyp, Laufzeit, Zielbenutzer (samt Anlegen und sudo), `authorized_keys`-
 Optionen und das Alias-Muster vor. Platzhalter: `{{quellHost}}`, `{{quellHostIp}}`, `{{zielHost}}`,
 `{{zielHostIp}}`. Eingebaut: „Deployment-Zugang“, „Backup-Zugang“, „Admin-Zugang Person“.
 ![Vorlage bearbeiten](bilder/vorlage-bearbeiten-desktop.png)
 ## 10. Private Key anzeigen oder löschen
 Nur Admins, nur nach erneuter Bestätigung: „anzeigen (Re-Auth)“ in der Info-Leiste eines Schlüssels.
 Der Key wird genau einmal ausgeliefert und nirgends zwischengespeichert; jede Anzeige steht im
 Protokoll. **Private Key löschen** entfernt ihn endgültig aus sshkv – auf den Hosts bleibt er; neu
 ausrollen geht danach nicht mehr.
 ## 11. Audit-Log
 Jede Aktion steht im **Audit-Log**: Zeitpunkt, Benutzer, Host, Zielbenutzer, Fingerprint, das Diff
 der geänderten Datei und das Ergebnis – nie ein Private Key oder Passwort. Einträge lassen sich
 weder ändern noch löschen; jeder Eintrag ist per Hash mit seinem Vorgänger verkettet.
 ![Audit-Log](bilder/protokoll-desktop.png)
 - **Filter** nach Zeitraum, Aktionsgruppe, Benutzer, Host, Ergebnis und Freitext; eine Zeile
  aufklappen zeigt Diff, Details und Hashes.
 - **Kette prüfen** rechnet alle Hashes nach. Wurde eine Zeile an sshkv vorbei in der Datenbank
  verändert, zeigt die Seite die erste betroffene Zeile.
 - **CSV-Export** mit denselben Filtern (der Export selbst wird protokolliert).
 - **Syslog:** Mit `SSHKV_SYSLOG_HOST` geht jeder Eintrag zusätzlich an einen zentralen Syslog-Server
  (z. B. für Zabbix) – eine Kopie außerhalb von sshkv.
 ## 12. Einstellungen und Benachrichtigungen
 Unter **Einstellungen** (ändern nur Admins) richten Sie Benachrichtigungen ein:
 - **E-Mail** über SMTP – für Microsoft 365 vorbelegt (`smtp.office365.com:587`, STARTTLS).
 - **Webhook** (nur `https://`, außer ausdrücklich für interne Ziele erlaubt) mit optionaler Signatur
  `X-Sshkv-Signatur: sha256=…` über den Inhalt.
 - **Anlässe** einzeln schaltbar: neue Abweichungen, Schlüssel, die in 30/14/7 Tagen ablaufen,
  abgelaufene, aber noch ausgerollte Schlüssel, nicht erreichbare Hosts – als **tägliche
  Zusammenfassung** um 07:00 (`SSHKV_MELDUNG_CRON`) – und **geänderte Host-Keys sofort**.
 - **Testnachricht senden** je Kanal; die letzten Zustellungen stehen darunter. Jede Meldung geht nur
  einmal hinaus; fehlgeschlagene werden einige Male wiederholt.
 Passwörter und Geheimnisse werden verschlüsselt gespeichert und nie wieder angezeigt („gesetzt“).
 ![Einstellungen](bilder/einstellungen-desktop.png)
@@ -0,0 +1,113 @@
 # Installation und Betrieb
 SSHKeyVault läuft als Docker-Compose-Stapel aus drei Diensten plus einem einmaligen Migrationslauf:
 | Dienst | Aufgabe | Netz | Geheimnisse |
 |---|---|---|---|
 | `db` | PostgreSQL 17 | nur intern (`internal: true`) | Datenbankpasswort |
 | `migrate` | Schema einspielen, Notfall-Admin und Vorlagen anlegen (läuft bei jedem Start einmal) | intern | Notfall-Passwort beim ersten Start |
 | `web` | Weboberfläche (Port 3400) | intern + nach außen zum OIDC-Anbieter | `SSHKV_APP_SECRET`, OIDC-Client-Secret – **kein Master-Key** |
 | `worker` | SSH zu den Hosts, Ver-/Entschlüsselung, Zeitpläne | intern + zu den Hosts | Master-Key (Docker-Secret), `SSHKV_APP_SECRET` |
 ## Voraussetzungen
 - Linux-Host mit Docker und Docker Compose v2, **im internen Netz bzw. nur per VPN erreichbar**.
 - Der Worker muss die zu verwaltenden Hosts per SSH erreichen (Port 22 oder den jeweiligen Port).
 - authentik (oder ein anderer OIDC-Anbieter) für die Anmeldung.
 - Ein Reverse Proxy mit TLS vor der Weboberfläche.
 ## Schritt für Schritt
 ```bash
 sudo mkdir -p /opt/sshkv && cd /opt/sshkv
 git clone <repo> .                      # oder Release entpacken
 cp .env.example .env && chmod 600 .env
 ```
 In `.env` eintragen (Kommentare in der Datei erklären jede Variable):
 - `POSTGRES_PASSWORD` – `openssl rand -hex 24`
 - `SSHKV_APP_SECRET` – `openssl rand -base64 48`
 - `SSHKV_APP_URL` – die Adresse, unter der Benutzer sshkv aufrufen, z. B. `https://sshkv.intern.example.de`
 - `SSHKV_BREAKGLASS_PASSWORD` – mindestens 16 Zeichen; Notfall-Admin `notfall`
 - `SSHKV_OIDC_*` – siehe unten
 Master-Key erzeugen und nur für den Worker lesbar machen:
 ```bash
 sudo mkdir -p geheim
 sudo sh -c 'head -c 32 /dev/urandom > geheim/master.key'
 sudo chown 1001:1001 geheim/master.key && sudo chmod 400 geheim/master.key
 ```
 Starten:
 ```bash
 docker compose up -d --build
 docker compose logs -f worker        # „sshkv-worker … bereit“
 ```
 Beim ersten Start legt `migrate` das Schema, den Notfall-Admin und die eingebauten Vorlagen an; der
 Worker erzeugt den **Deployment-Key** der Instanz. Danach sofort den Master-Key sichern
 ([sicherung.md](sicherung.md)).
 ## authentik einrichten
 1. **Provider** „OAuth2/OpenID Provider“ anlegen: Client-Typ *confidential*, Redirect-URI
   `https://sshkv.intern.example.de/api/auth/oidc/rueckruf`, Scopes `openid profile email` und ein
   Scope-Mapping, das die Gruppen als Claim `groups` liefert (in authentik Standard).
 2. **Application** „SSHKeyVault“ mit diesem Provider anlegen.
 3. **Gruppen** `sshkv-admins`, `sshkv-operators`, `sshkv-readers` anlegen und Benutzer zuordnen
   (Namen änderbar über `SSHKV_OIDC_GROUP_*`). Wer in keiner Gruppe ist, kommt nicht hinein.
 4. In `.env`: `SSHKV_OIDC_ISSUER=https://authentik.example.de/application/o/sshkv/`,
   `SSHKV_OIDC_CLIENT_ID`, `SSHKV_OIDC_CLIENT_SECRET`, `SSHKV_OIDC_NAME=authentik`.
 Erneute Bestätigung vor kritischen Aktionen schickt `prompt=login` und `max_age=0`; sshkv prüft
 `auth_time` im ID-Token. authentik liefert `auth_time` standardmäßig.
 | Rolle | darf |
 |---|---|
 | Leser | alles ansehen, eigene Public Keys hinterlegen |
 | Operator | zusätzlich Hosts verwalten, Host-Keys bestätigen, Schlüssel erzeugen, Public Keys ausrollen, abgleichen |
 | Admin | zusätzlich Private Keys ausrollen/anzeigen/löschen, Zielkonten mit sudo, Massenwiderruf, Einstellungen, Vorlagen |
 ## Reverse Proxy (Beispiel Caddy)
 ```caddyfile
 sshkv.intern.example.de {
    tls internal                      # oder das interne Zertifikat
    @extern not remote_ip 10.0.0.0/8 192.168.0.0/16
    respond @extern 403
    reverse_proxy 127.0.0.1:3400
 }
 ```
 Wichtig: `SSHKV_APP_URL` muss die Adresse mit `https://` sein – davon hängen Secure-Cookie und
 OIDC-Rückruf ab.
 ## Hosts vorbereiten
 - **Debian/Ubuntu** mit `openssh-server`, `sudo`, `runuser` (util-linux), `base64`, `sha256sum`,
  `visudo` (bei Dienstbenutzer) – auf Standardinstallationen vorhanden.
 - Für den Bootstrap per Passwort einmalig ein Konto mit Passwort-Login (root oder ein Benutzer mit
  sudo). Danach kann Passwort-Login aus; sshkv zeigt den sshd-Befund an.
 ## Aktualisieren
 ```bash
 cd /opt/sshkv
 sudo bash deploy/sichern.sh
 git pull
 docker compose up -d --build         # migrate spielt neue Migrationen ein
 ```
 ## Variablen (Auswahl)
 | Variable | Bedeutung |
 |---|---|
 | `SSHKV_SYNC_CRON` | Zeitplan des Abgleichs (Standard `30 2 * * *`, Europe/Berlin) |
 | `SSHKV_MELDUNG_CRON` | tägliche Zusammenfassung der Benachrichtigungen (Standard `0 7 * * *`); geänderte Host-Keys gehen alle 5 Minuten sofort hinaus |
 | `SSHKV_SYSLOG_HOST`/`_PORT`/`_PROTOKOLL` | Kopie des Protokolls an einen Syslog-Server (RFC 5424, UDP oder TCP) |
 | `SSHKV_SYSLOG_FACILITY` / `_APPNAME` | Facility (Standard `authpriv`) und App-Name (Standard `sshkv`) |
 | `SSHKV_WORKER_USER` | Benutzer des Worker-Containers, falls die Master-Key-Datei nicht UID 1001 gehört |
 | `SSHKV_BIND` / `SSHKV_PORT` | Bindeadresse/Port der Weboberfläche (Standard `127.0.0.1:3400`) |
@@ -0,0 +1,84 @@
 # Sicherheit und Bedrohungsanalyse
 SSHKeyVault (`sshkv`) verwaltet die SSH-Zugänge zu Servern – und hat dafür selbst
 **root-gleichen Zugriff auf alle verwalteten Hosts**. Wer sshkv übernimmt, übernimmt die
 Infrastruktur. Diese Seite beschreibt, wie sshkv aufgebaut ist, um das zu erschweren, was
 trotzdem passieren kann und was im Ernstfall zu tun ist.
 ## Was sshkv besitzt
 | Wert | Wo | Schutz |
 |---|---|---|
 | **Deployment-Key** (Private Key) | Datenbank, verschlüsselt | Envelope Encryption mit Master-Key; nur der Worker entschlüsselt |
 | **Private Keys** von Service-Schlüsseln | Datenbank, verschlüsselt | wie oben; Anzeige nur für Admins mit frischer Bestätigung, protokolliert |
 | **Master-Key** | Datei auf dem Docker-Host, nur im Worker eingebunden | Dateirechte 0400, nicht in der Datenbank, nicht im Image, nicht im Repo |
 | `SSHKV_APP_SECRET` | `.env` | signiert Sitzungen, verschlüsselt TOTP-Geheimnis, SMTP-Passwort, Webhook-Geheimnis und Job-Transporte |
 | Host-Keys der Hosts | Datenbank | öffentlich; schützen vor Man-in-the-Middle (strikte Prüfung) |
 | Protokoll | Datenbank | append-only per Trigger, Hash-Kette, optional Syslog |
 **Personen-Keys** speichert sshkv nur als Public Key – ein Datenbankregel verhindert, dass dort je ein
 Private Key steht. Bootstrap-Passwörter werden nie gespeichert.
 ## Aufbau, der Angriffe erschwert
 - **Web und Worker getrennt.** Der Webprozess kennt den Master-Key nicht und spricht kein SSH. Eine
  Lücke in der Weboberfläche allein entschlüsselt keine Private Keys; ein Test hält strukturell fest,
  dass der Webprozess nichts aus `src/worker` importiert und nur eine einzige Datei die
  verschlüsselten Felder liest.
 - **Envelope Encryption** (AES-256-GCM): je Private Key ein eigener Datenschlüssel, gebunden an ID und
  Fingerprint des Schlüssels. Ein Datenbank-Dump allein gibt keinen Schlüssel preis (Test).
 - **Strikte Host-Key-Prüfung** bei jeder Verbindung. Ein geänderter Host-Key bricht die Verbindung vor
  dem Senden von Zugangsdaten ab; Ersetzen nur mit Häkchen und frischer Bestätigung.
 - **Dateien auf den Hosts** schreibt sshkv als jeweiliger Zielbenutzer (`runuser`): Ein Symlink im
  Home eines Benutzers kann root nicht dazu bringen, `/etc/shadow` zu lesen oder zu überschreiben
  (Integrationstest).
 - **Dry-Run mit optimistischer Sperre:** Ausgerollt wird nur, was ein Mensch gesehen hat. Hat sich die
  Datei oder die Zuweisung seitdem geändert, bricht der Vorgang ab.
 - **Rollen:** Private Keys anzeigen, ausrollen und löschen, Deployment-Key, Zielkonten mit sudo und
  Massenwiderruf nur für Admins; kritische Aktionen zusätzlich mit erneuter Anmeldung (5 Minuten).
  Ohne passende authentik-Gruppe gibt es keinen Zugang, auch keinen lesenden.
 - **Notfall-Admin** nur mit Passwort **und** TOTP; Rate-Limit gegen Raten.
 - **Weboberfläche:** Content-Security-Policy mit Nonce, `X-Frame-Options: DENY`, `Referrer-Policy:
  no-referrer`, HttpOnly-/SameSite-Cookies, Secure hinter HTTPS; Server Actions mit Origin-Prüfung.
 ## Was passiert, wenn sshkv kompromittiert wird?
 | Angreifer hat … | Folge | Gegenmaßnahme |
 |---|---|---|
 | nur ein **Datenbank-Backup** | Hosts, Zuweisungen, Public Keys, Protokoll sichtbar; **keine** Private Keys | Backup trotzdem vertraulich behandeln (verrät die Struktur der Infrastruktur) |
 | **Datenbank + Master-Key** | alle Private Keys inkl. Deployment-Key → root auf allen Hosts | Master-Key getrennt aufbewahren; Notfallplan unten |
 | die **Weboberfläche** als Admin (gestohlene Sitzung) | kann Schlüssel zuweisen und ausrollen; Private Keys nur nach erneuter Anmeldung | kurze Sitzungen (8 h), Re-Auth, Protokoll + Syslog zeigen jede Aktion |
 | den **Webprozess** (Codeausführung) | Datenbankzugriff, aber kein Master-Key | Worker getrennt; Master-Key nur im Worker-Container |
 | den **Worker** oder Docker-Host | alles | Host härten, nur internes Netz, Updates, Zugriff auf den Docker-Host streng begrenzen |
 | einen **verwalteten Host** | kann sshkv nicht angreifen; sieht nur den Public Key des Deployment-Keys | — |
 ### Notfallplan „sshkv kompromittiert“
 1. **Sofort:** Netzwerkzugang zu sshkv sperren (Firewall/VPN), Container anhalten
   (`docker compose stop`). Die Hosts bleiben erreichbar – sshkv ist kein Teil des Logins.
 2. **Deployment-Key auf allen Hosts entfernen:** Auf jedem Host in `~sshkv/.ssh/authorized_keys`
   (bzw. `/root/.ssh/authorized_keys` bei Anmeldeart root) die Zeile mit `sshkv-deployment@…` löschen
   und `/etc/sudoers.d/sshkv` entfernen. Mit einem Konfigurationsmanagement oder einer Schleife über
   die Hostliste (CSV-Export der Zuweisungen bzw. Hostliste).
 3. **Ausgerollte Service-Keys tauschen:** Jeder Private Key, den sshkv kannte, gilt als bekannt.
   Nach dem Wiederaufbau alle Service-Schlüssel rotieren (geführte Rotation) und alte widerrufen.
 4. **Neu aufsetzen:** neuer Master-Key, neues `SSHKV_APP_SECRET`, frische Datenbank oder geprüftes
   Backup; der Worker erzeugt einen neuen Deployment-Key; Hosts per Bootstrap neu aufnehmen.
 5. **Protokoll auswerten:** Syslog-Kopie (unveränderlich außerhalb von sshkv) mit dem Protokoll
   vergleichen; `protokoll_kette_pruefen()` zeigt manipulierte Zeilen.
 > Eine eingebaute **Rotation des Deployment-Keys** gibt es noch nicht (siehe `docs/issues`). Bis dahin
 > ist Schritt 2 Handarbeit.
 ## Betriebsregeln
 - **Nur intern betreiben.** Die Weboberfläche gehört ins interne Netz oder hinter ein VPN, nie ins
  Internet. Compose bindet standardmäßig nur an `127.0.0.1`; ein Reverse Proxy mit TLS steht davor
  (siehe [installation.md](installation.md)).
 - **Docker-Host wie einen Bastion-Host behandeln:** wenige Admins, SSH nur mit Schlüssel, Updates,
  keine anderen Dienste.
 - **Master-Key** getrennt sichern, Rechte 0400, nur für den Worker-Benutzer lesbar.
 - **Syslog** einschalten (`SSHKV_SYSLOG_*`), damit eine Kopie des Protokolls außerhalb von sshkv liegt.
 - **Hosts:** `PermitRootLogin prohibit-password` (sshkv zeigt das als Hinweis an), Anmeldeart
  „Dienstbenutzer“ bevorzugen – dann kann root-Login ganz aus bleiben.
 - **Benachrichtigungen** für Drift und geänderte Host-Keys aktivieren, damit Abweichungen auffallen.
@@ -0,0 +1,92 @@
 # Sicherung und Wiederherstellung
 Eine Sicherung von SSHKeyVault besteht aus **zwei Teilen, die getrennt aufbewahrt werden**:
 | Teil | Inhalt | Wie oft | Wohin |
 |---|---|---|---|
 | **Datenbank** | Hosts, Schlüssel (Private Keys nur verschlüsselt), Zuweisungen, Protokoll, Einstellungen | täglich | normales Backup-Ziel (`/var/backups/sshkv`, von dort auf das Sicherungssystem) |
 | **Master-Key** | 32 Byte, entschlüsselt alle Private Keys | einmalig nach der Installation und nach jeder Master-Key-Rotation | **getrennt:** Passwortmanager, Tresor, verschlüsselter Datenträger |
 | `.env` | `SSHKV_APP_SECRET`, OIDC-Zugang, Datenbankpasswort | nach jeder Änderung | wie der Master-Key |
 > **Ohne Master-Key ist jedes Datenbank-Backup wertlos** – die Private Keys lassen sich nicht mehr
 > entschlüsseln. **Mit Master-Key neben dem Backup** gibt ein gestohlenes Backup alle Private Keys
 > preis. Deshalb niemals beides am selben Ort.
 >
 > Ohne das richtige `SSHKV_APP_SECRET` gehen TOTP des Notfall-Admins, SMTP-Passwort und
 > Webhook-Geheimnis verloren (neu einrichten genügt); Private Keys hängen nur am Master-Key.
 ## Sichern
 ```bash
 cd /opt/sshkv                       # Verzeichnis mit docker-compose.yml und .env
 sudo bash deploy/sichern.sh                     # nach /var/backups/sshkv
 sudo bash deploy/sichern.sh /mnt/sicherung/sshkv
 ```
 Das Skript
 - schreibt `datenbank-<Stand>.sql.gz` (`pg_dump --clean --if-exists`, nur das Schema `public` – die
  Warteschlange legt der Worker selbst neu an),
 - legt `master-key-pruefwert-<Stand>.txt` daneben: den SHA-256 der Master-Key-Datei. Er verrät nichts
  über den Schlüssel, zeigt beim Zurückspielen aber, ob der richtige bereitliegt,
 - behält die letzten 14 Sicherungen (`SSHKV_SICHERUNGEN_BEHALTEN`),
 - sichert den Master-Key **nicht** mit.
 Als täglicher Cronjob auf dem Docker-Host:
 ```cron
 15 3 * * * root cd /opt/sshkv && bash deploy/sichern.sh >/var/log/sshkv-sicherung.log 2>&1
 ```
 ## Master-Key sichern (einmalig)
 ```bash
 sudo base64 /opt/sshkv/geheim/master.key   # Ausgabe in den Passwortmanager, Eintrag „sshkv Master-Key“
 sudo sha256sum /opt/sshkv/geheim/master.key   # Prüfwert dazuschreiben
 ```
 Zurück in eine Datei: `echo '<base64>' | base64 -d > geheim/master.key && chmod 400 geheim/master.key`
 und den Eigentümer setzen (Container-Benutzer 1001 oder `SSHKV_WORKER_USER`).
 ## Wiederherstellen
 ```bash
 cd /opt/sshkv
 sudo bash deploy/wiederherstellen.sh /var/backups/sshkv              # jüngste Sicherung
 sudo bash deploy/wiederherstellen.sh /var/backups/sshkv 20261012-163958
 ```
 Das Skript
 1. prüft den Master-Key unter `SSHKV_MASTER_KEY_HOST_FILE` gegen den Prüfwert der Sicherung und
   **bricht ab, wenn er nicht passt**,
 2. fragt nach (`--ja` überspringt),
 3. hält Weboberfläche und Worker an,
 4. spielt die Datenbank **in einer Transaktion** zurück – scheitert etwas, bleibt der alte Stand
   vollständig erhalten,
 5. setzt die Warteschlange zurück und bricht offene Vorgänge ab (ihre Jobs gehören nicht zur
   Sicherung),
 6. startet die Dienste und prüft, dass der Worker den Master-Key akzeptiert.
 Zusätzlich prüft der **Worker bei jedem Start**, ob er den Deployment-Key mit dem eingebundenen
 Master-Key entschlüsseln kann, und startet sonst nicht („Der Master-Key passt nicht zur Datenbank“).
 ### Geprobt am 12.10.2026
 Auf einem Wegwerf-Stapel (gleiches `docker-compose.yml`):
 1. Markierung angelegt (Host `srv-probe`, Protokolleintrag), gesichert.
 2. Markierung gelöscht, weiterer Protokolleintrag geschrieben.
 3. Zurückgespielt → Host wieder da, Protokoll wieder auf dem gesicherten Stand, Hash-Kette
   unversehrt (`protokoll_kette_pruefen()`), Weboberfläche gesund, Worker bereit.
 4. Mit **falschem Master-Key** zurückgespielt → Abbruch vor jeder Änderung.
 Dabei fielen zwei Fehler auf, die jetzt behoben sind: Das Schema der Warteschlange ließ sich mit
 `--clean` nicht zurückspielen, und ein Abbruch ohne Transaktion hatte es halb gelöscht.
 ## Nach einer Wiederherstellung
 - **„Jetzt abgleichen“** auf der Übersicht: Der Stand der Hosts kann neuer sein als die Sicherung.
 - Zuweisungen, die nach der Sicherung ausgerollt wurden, kennt sshkv nicht mehr – der Abgleich zeigt
  sie als unbekannte Schlüssel; übernehmen oder entfernen.
 - Wurde nach der Sicherung ein Schlüssel widerrufen, steht er wieder als aktiv da: erneut widerrufen.
@@ -1,23 +1,60 @@
 # #012 Schlüssel erzeugen, importieren, exportieren
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.2.0
 **Labels:** backend, ui
-**Geschätzt:** 4 h   **Tatsächlich:** –
+**Geschätzt:** 4 h   **Tatsächlich:** 0 h 25 min
 ## Ziel
 Schlüsselliste und -formular: erzeugen (ed25519, rsa-4096), importieren (Public oder Paar), exportieren; Kategorien, Tags, Ablaufdatum.
 ## Aufgaben
- [ ] Liste mit Filter
+- [x] Liste mit Filter
- [ ] Erzeugen-Dialog
+- [x] Erzeugen-Dialog
- [ ] Import mit Prüfung
+- [x] Import mit Prüfung
- [ ] Export Public Key
+- [x] Export Public Key
- [ ] Schlüsseldetail-Gerüst mit Verwendungen
+- [x] Schlüsseldetail-Gerüst mit Verwendungen
 ## Akzeptanzkriterien
- [ ] Private Keys erscheinen nie in Listen-Antworten
+- [x] Private Keys erscheinen nie in Listen-Antworten
 ## Abhängigkeiten
 #006
 ## Notizen / Entscheidungen
 - **Migration `20261012100000_schluessel_vorgaenge`:** Vorgangsarten `SCHLUESSEL_ERZEUGEN`,
  `SCHLUESSEL_IMPORTIEREN`, `PRIVATE_KEY_LOESCHEN` (für #014 gleich mit), CHECK
  `schluessel_slug_gueltig` (`^[a-z0-9-]{1,64}$`, der Slug landet in Dateinamen) und
  `schluessel_geloescht_ohne_private_key`.
 - **Erzeugen und Paar-Import laufen im Worker** (`src/worker/ablaeufe/schluessel.ts`). Das Web
  prüft nur Metadaten (Slug frei, Person/Vorlage vorhanden, Ablauf nicht in der Vergangenheit)
  und reiht den Vorgang ein. Passphrase und importierter Private Key reisen wie das
  Bootstrap-Passwort mit `SSHKV_APP_SECRET` verschlüsselt im Job (`geheim`), nie in
  `Vorgang.eingabe`; der Worker löscht den Job danach. Der Worker prüft die Metadaten erneut.
 - **Kategorie:** Erzeugen und Paar-Import legen immer `DIENST` an. Personen-Keys speichert sshkv
  nie mit Private Key (DB-CHECK), Deployment-Keys verwaltet der Worker selbst. Der
  Public-Key-Import kennt `PERSON` und `DIENST`.
 - **Passphrase:** beim Erzeugen optional; gespeichert wird dann der passphrasengeschützte
  OpenSSH-Key (`passphraseGeschuetzt = true`). Beim Import dient sie nur zum Lesen von Public Key
  und Fingerprint und wird verworfen; gespeichert wird der Key so, wie er kam. Hinweis in der
  Oberfläche: „Für automatische Anmeldungen (Host-zu-Host) ungeeignet.“
 - **Typ:** `RSA4096` nur bei genau 4096 Bit, sonst `ANDERER` (z. B. RSA-3072, ecdsa). Die RSA-
  Mindestlänge 2048 gilt beim Import.
 - **Slug:** aus dem Zweck abgeleitet (Umlaute gefaltet), bei Kollision `-2`, `-3` …; ein
  ausdrücklich gewünschter Kurzname muss frei sein. Slug, Typ und Kommentar sind danach nicht
  mehr änderbar – sie stehen schon in Dateinamen und authorized_keys-Zeilen.
 - **Status von Hand** nur `AKTIV` ↔ `ABGELAUFEN`; `ROTIERT`/`WIDERRUFEN` setzen #023/#024,
  Deployment-Keys sind ausgenommen (sonst erzeugte der Worker beim Start einen neuen).
 - **Ablaufdatum** ohne Angabe aus `Vorlage.standardLaufzeitTage`.
 - **„Private Key gespeichert?“** liest das Web aus `masterKeyVersion` (der CHECK
  `schluessel_umschlag_vollstaendig` koppelt sie an das Chiffrat) – das Chiffrat wird im Web
  nie selektiert.
 - **Grenze abgesichert:** `tests/schluessel-grenze.test.ts` verlangt für jeden zeilenliefernden
  `prisma.schluessel.*`-Aufruf außerhalb von `src/worker` ein `select` und verbietet
  `schluessel: true` als Relation; `tests/schluessel.test.ts` prüft, dass weder Vorgang,
  Protokoll noch pg-boss-Job nach Erzeugen/Import den Key oder die Passphrase enthalten.
 - **Platzhalter** für #016/#017: `src/app/(app)/schluessel/[id]/PublicAusrollenAktion.tsx` und
  `PrivateAusrollenAktion.tsx`, Props `{ schluesselId: string; darf: boolean }`, rendern `null`.
 - Personen-Keys zeigen im Detail nur die Karte „Public Key ausgerollt auf“ (eine Private-Karte
  wäre immer leer).
 - Prototyp `/schluessel/beispiel` samt `src/beispiel/schluessel.ts` entfernt; die Übersicht
  (noch Prototyp, #026) verlinkt auf `/schluessel`.
@@ -1,20 +1,41 @@
 # #013 Personen und Self-Service
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.2.0
 **Labels:** backend, ui
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 10 min
 ## Ziel
 Personen verwalten; jeder angemeldete Benutzer kann eigene Public Keys hinterlegen, wirksam erst nach Zuweisung.
 ## Aufgaben
- [ ] Personenliste/-detail
+- [x] Personenliste/-detail
- [ ] Seite „Meine Schlüssel“
+- [x] Seite „Meine Schlüssel“
 ## Akzeptanzkriterien
- [ ] Leser kann nur eigene Keys hinterlegen, nicht zuweisen
+- [x] Leser kann nur eigene Keys hinterlegen, nicht zuweisen
 ## Abhängigkeiten
 #012
 ## Notizen / Entscheidungen
 - **Personen pflegt, wer Schlüssel verwaltet** (Recht `schluesselVerwalten`, Admin und Operator) –
  ein eigenes Recht wäre nur ein Alias. Lesen dürfen alle Rollen.
 - **Archivieren statt Löschen:** die Schlüssel bleiben der Person zugeordnet (wer hatte bis wann
  welchen Key?), die Kontoverknüpfung entfällt, damit der Self-Service nicht bei einer
  archivierten Person landet. Die Notiz steht nicht im Protokoll, nur dass sie sich änderte.
 - **Self-Service `/meine-schluessel`** (Recht `eigeneSchluesselHinterlegen`, alle Rollen,
  Navigation „Meine Schlüssel“): beim ersten Aufruf wird die eigene Person angelegt oder
  verknüpft – per `benutzerId`, sonst per E-Mail, aber **nur bei vom Anbieter bestätigter
  Adresse** und genau einer freien, nicht archivierten Person. Dafür neue Spalte
  `Benutzer.emailBestaetigt` (Migration `20261012103000_benutzer_email_bestaetigt`), gesetzt bei
  jeder OIDC-Anmeldung. Ohne sie könnte jemand mit selbst gewählter Adresse die Keys einer fremden
  Person sehen.
 - Hinterlegte Keys: Kategorie `PERSON`, `selbstHinterlegt = true`, Protokoll
  `schluessel.selbst_hinterlegt`. Hinweis in der Oberfläche: „Wirksam erst, wenn ein Operator
  oder Admin den Schlüssel einem Host zuweist.“
 - **Entfernen** nur eigene, selbst hinterlegte Keys ohne jede Verwendung (auch keine entfernte –
  der Verlauf am Key bleibt). Das Löschen ist bedingt (`deleteMany` mit „keine Verwendungen“),
  damit eine gleichzeitige Zuweisung nicht per Cascade verschwindet. Fremde IDs gelten als „nicht
  vorhanden“. Tests: `tests/personen.test.ts`.
 - Die Services nehmen den angemeldeten Benutzer entgegen und leiten die Person selbst ab; die
  Actions reichen keine `personId` von außen durch (struktureller Test).
@@ -1,20 +1,52 @@
 # #014 Private Key anzeigen und herunterladen
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.2.0
 **Labels:** sicherheit
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 10 min
 ## Ziel
 Nur Admin, nur nach Re-Auth, immer protokolliert; Entschlüsselung im Worker.
 ## Aufgaben
- [ ] Einmal-Abholung
+- [x] Einmal-Abholung
- [ ] Option „Private Key nach Ausrollen löschen“
+- [x] Option „Private Key nach Ausrollen löschen“
 ## Akzeptanzkriterien
- [ ] Kein Caching, kein Logging
+- [x] Kein Caching, kein Logging
 ## Abhängigkeiten
 #012, #004
 ## Notizen / Entscheidungen
 - **Ablauf:** Web legt einen Vorgang `PRIVATE_KEY_ABHOLEN` an (Protokoll `privatekey.angefordert`)
  → der Worker öffnet den Umschlag und legt den Key mit `SSHKV_APP_SECRET` verschlüsselt in
  `Vorgang.ergebnis` ab (`{ abholung: "v1.…" }`) → das Web holt ihn **genau einmal** ab: ein
  einziges `UPDATE … FROM (SELECT … FOR UPDATE) RETURNING` liest das alte Ergebnis und setzt
  `{ abgeholt: true }`; fünf gleichzeitige Abholungen ergeben genau eine (Test). Abholen darf
  nur, wer angefordert hat. Protokoll `privatekey.angezeigt` / `privatekey.heruntergeladen` mit
  Fingerprint, nie mit Key.
 - **Die Status-Schnittstelle** `/api/vorgaenge/[id]` zeigt für eine bereitliegende Abholung nur
  `{ bereit: true }`, nie das Chiffrat.
 - **Verfall nach 2 Minuten** (`ABHOLFRIST_MS` in `src/lib/schluessel.ts`), dreifach abgesichert:
  der Worker räumt alle 30 s und vor jeder neuen Abholung auf (`abholungenAufraeumen`, ein
  einziges UPDATE → `{ verfallen: true }`), und das Web gibt eine ältere Abholung nicht mehr
  heraus (überschreibt sie aber trotzdem). Ein Worker-Takt statt pg-boss-Zeitplan: dessen Raster
  ist eine Minute.
 - **Anzeige** im Dialog (Monospace, Kopier-Knopf, „Wird nicht erneut angezeigt“); der Key lebt
  nur im Zustand des Dialogs und wird beim Schließen verworfen. **Download** als Datei `<slug>`
  über `POST /api/private-key/[vorgangId]` (Formular, kein GET – ein Link oder Vorabruf würde die
  einmalige Abholung verbrauchen), `Content-Disposition: attachment`,
  `Cache-Control: no-store`. Der Route Handler prüft selbst Recht, Bestätigung und Herkunft:
  wegen `Referrer-Policy: no-referrer` senden Browser bei Formular-POSTs `Origin: null`,
  maßgeblich ist deshalb `Sec-Fetch-Site: same-origin` (oder ein passender Origin).
 - **Re-Auth:** Fehlt die frische Bestätigung, leitet die Oberfläche nach
  `/bestaetigen?ziel=/schluessel/<id>?privatekey=1` und öffnet danach den Dialog wieder. Der
  Mock-OIDC liefert `auth_time` nur, wenn man es in die Claims schreibt – die E2E tut das.
 - **Löschen** („Private Key aus SSHKeyVault löschen“): neues Recht `privateKeyLoeschen` (nur
  Admin, mit Bestätigung), ausgeführt als Worker-Vorgang `PRIVATE_KEY_LOESCHEN`
  (`privateKeyVerwerfen` in `src/worker/geheimnisse.ts`), damit nur diese Datei die
  Chiffrat-Felder anfasst – auch zum Leeren. Setzt Chiffrat, DEK und Version auf `null` und
  `privatGeloeschtAm`; Protokoll `privatekey.geloescht`. CHECK
  `schluessel_geloescht_ohne_private_key` (Migration aus #012).
 - **Deployment-Keys** gibt sshkv weder heraus noch löscht es deren Private Key: der Key ist root
  auf allen Hosts, und ohne ihn käme der Worker nirgends mehr hin. Im Notfall wird rotiert.
@@ -1,22 +1,29 @@
 # #015 authorized_keys: Parser und Merge
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.2.0
 **Labels:** backend, test
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 15 min
 ## Ziel
 Reine Funktionen zum Lesen und Schreiben von `authorized_keys` mit verwaltetem Block.
 ## Aufgaben
- [ ] Optionen mit Anführungszeichen
+- [x] Optionen mit Anführungszeichen
- [ ] CRLF, BOM, Kommentare, Duplikate
+- [x] CRLF, BOM, Kommentare, Duplikate
- [ ] Block erzeugen/ersetzen, Rest bytegenau
+- [x] Block erzeugen/ersetzen, Rest bytegenau
- [ ] Aussperrschutz Deployment-Key
+- [x] Aussperrschutz Deployment-Key
 ## Akzeptanzkriterien
- [ ] Umfangreiche Unit-Tests der Randfälle
+- [x] Umfangreiche Unit-Tests der Randfälle
 ## Abhängigkeiten
 #001
 ## Notizen / Entscheidungen
 - **Bytegenau:** Zeilen werden an `\n` getrennt, ein `\r` bleibt Teil der Zeile; BOM und fehlende letzte Zeilenschaltung bleiben erhalten. Einzige Änderung außerhalb des Blocks: Fehlt der Block und der letzten Zeile die Zeilenschaltung, bekommt sie eine – sonst stünde der Block-Anfang in derselben Zeile.
 - **CRLF-Dateien** (überwiegend `\r\n`) bekommen auch im Block CRLF.
 - **Beschädigter Block** (Anfang ohne Ende, mehrere Blöcke, Ende vor Anfang): nie automatisch schreiben, `BlockFehler` mit Bitte um Handarbeit.
 - **Erkennung am Fingerprint**, nicht am Kommentar; der Typ im Blob muss zum Zeilentyp passen.
 - **Optionen:** Parser wie sshd (Kommas in Anführungszeichen, `\"`). Für Benutzereingaben strenger: nur bekannte Optionen, keine Steuerzeichen.
 - **Aussperrschutz:** Ein `pflicht`-Fingerprint (Deployment-Key), der im Block stand, darf nicht verschwinden.
 - Diff per LCS, für die Anzeige verdichtet (je 2 Zeilen Kontext).
@@ -1,21 +1,27 @@
 # #016 Public Key ausrollen mit Dry-Run und Backup
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.2.0
 **Labels:** backend, ui
-**Geschätzt:** 4 h   **Tatsächlich:** –
+**Geschätzt:** 4 h   **Tatsächlich:** 0 h 40 min
 ## Ziel
 Zuweisungen Schlüssel × Host/Gruppe × Benutzer; Dry-Run-Diff, Backup, atomares Schreiben, Rechte.
 ## Aufgaben
- [ ] Remote-Skript
+- [x] Remote-Skript
- [ ] Optimistische Sperre über Datei-Hash
+- [x] Optimistische Sperre über Datei-Hash
- [ ] Diff-Box im Schlüsseldetail
+- [x] Diff-Box im Schlüsseldetail
 ## Akzeptanzkriterien
- [ ] Integrationstest Ausrollen/Entfernen
+- [x] Integrationstest Ausrollen/Entfernen
 ## Abhängigkeiten
 #015, #010
 ## Notizen / Entscheidungen
 - **Zwei Schritte:** TROCKENLAUF hält je Ziel Diff, Hinweise und die Hashes vorher/nachher fest; AUSROLLEN führt genau diesen Plan aus und bricht je Ziel ab, wenn sich Datei **oder** Soll geändert hat. Ein Trockenlauf gilt 15 Minuten und nur einmal.
 - **Auf dem Host** alles als Zielbenutzer (`runuser`), Hash dort erneut geprüft, Sicherung (letzte 5 bleiben), Temp-Datei + `mv`, 0700/0600.
 - **Nur gültiges UTF-8** wird bearbeitet, sonst ginge „bytegenau“ verloren.
 - **Soll** = direkte und Gruppen-Zuweisungen; der Deployment-Key gehört immer zum Soll des Anmeldebenutzers (Aussperrschutz aus #015).
 - Gruppen-Verwendungen: Zustand je Verwendung, Fehlschlag auf einem Host gewinnt. Zustand je Host folgt mit dem Abgleich (#021).
 - Oberfläche: Zuweisen auf der Schlüsselseite, Dry-Run je Schlüssel und je Host.
@@ -1,21 +1,27 @@
 # #017 Private Key ausrollen und ~/.ssh/config
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.3.0
 **Labels:** backend, ui
-**Geschätzt:** 4 h   **Tatsächlich:** –
+**Geschätzt:** 4 h   **Tatsächlich:** 0 h 45 min
 ## Ziel
 Private Key auf Zielhost/-benutzer/-pfad, verwalteter Block in `~/.ssh/config`, `known_hosts`.
 ## Aufgaben
- [ ] Übertragung nur über stdin
+- [x] Übertragung nur über stdin
- [ ] Warnung bei Passphrase
+- [x] Warnung bei Passphrase
- [ ] nur Admin
+- [x] nur Admin
 ## Akzeptanzkriterien
- [ ] Integrationstest
+- [x] Integrationstest
 ## Abhängigkeiten
 #016
 ## Notizen / Entscheidungen
 - **Dateien je Ziel:** Private Key (0600, keine Sicherungskopie), `.pub` (0644), verwalteter Block **am Anfang** von `~/.ssh/config` (ssh nimmt den ersten Treffer), verwalteter Block in `known_hosts` mit den vertrauten Host-Keys des Ziels unter dem HostName/Port aus der config.
 - **Nie fremde Dateien überschreiben:** Liegt am Zielpfad schon etwas anderes, scheitert das Ziel im Trockenlauf.
 - **Plan ohne Inhalt:** Der Trockenlauf zeigt beim Private Key nur die Aktion; weder Vorgang noch Protokoll noch Browser sehen den Schlüssel.
 - **Nur Admins:** Zuweisen verlangt `privateKeyAusrollen`; der Trockenlauf nimmt Private-Key-Ziele nur für Admins auf.
 - **Widerruf:** löschen oder umbenennen (`…sshkv-widerrufen.<Zeit>`), config- und known_hosts-Einträge verschwinden mit.
 - Integrationstest: A meldet sich per Alias bei B an (StrictHostKeyChecking=yes). E2E im Browser für den ganzen Kern-Anwendungsfall.
@@ -1,20 +1,25 @@
 # #018 Zielbenutzer anlegen und sudoers
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.3.0
 **Labels:** backend, sicherheit
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 30 min
 ## Ziel
 Benutzer (z. B. `deploy`) anlegen, optional sudoers mit Vorschau und `visudo -c`.
 ## Aufgaben
- [ ] Auswahl keine/bestimmte Befehle/voll
+- [x] Auswahl keine/bestimmte Befehle/voll
- [ ] Entfernen beim Widerruf
+- [x] Entfernen beim Widerruf
 ## Akzeptanzkriterien
- [ ] Integrationstest
+- [x] Integrationstest
 ## Abhängigkeiten
 #016
 ## Notizen / Entscheidungen
 - **sudoers** entsteht als `/etc/sudoers.d/.sshkv.XXXX` (Punkt im Namen: sudo ignoriert die Datei), wird mit `visudo -cf` geprüft und erst dann nach `/etc/sudoers.d/sshkv-<benutzer>` verschoben. Kopfzeile kennzeichnet sshkv-Dateien; eine fremde Datei gleichen Namens wird nie überschrieben.
 - **Befehle:** absoluter Pfad, keine Zeichen mit Sonderbedeutung in sudoers (`, : = \`, Wildcards) – die Liste soll wirken, wie sie aussieht.
 - **Geschützte Konten** (root, sshkv, Systemkonten) verwaltet sshkv nie als Zielkonto.
 - **Herkunft gemerkt:** `vonSshkvAngelegt` – nur dann löscht ein Entfernen den Benutzer samt Home, sonst nur die sudoers-Datei.
 - Vorgänge `ZIELKONTO_ANLEGEN`/`ZIELKONTO_ENTFERNEN` (Migration `20261012110000`), Recht `zielkontenVerwalten` = Admin mit frischer Bestätigung. Oberfläche im Assistenten (#020) mit sudoers-Vorschau.
@@ -1,5 +1,5 @@
 # #019 Vorlagen
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.3.0
 **Labels:** backend, ui
 **Geschätzt:** 2 h   **Tatsächlich:** –
@@ -8,12 +8,25 @@
 Eingebaute Vorlagen „Deployment-Zugang“, „Backup-Zugang“, „Admin-Zugang Person“; eigene in den Einstellungen.
 ## Aufgaben
- [ ] Platzhalter `{{quellHostIp}}` usw.
+- [x] Platzhalter `{{quellHostIp}}` usw.
 - [x] Oberfläche: Liste `/vorlagen` (alle lesen), Anlegen/Bearbeiten/Archivieren nur Admin
 - [x] Live-Vorschau der aufgelösten Optionen, des Alias und der sudoers-Datei
 ## Akzeptanzkriterien
- [ ] Vorlage füllt Assistent vor
+- [ ] Vorlage füllt Assistent vor (folgt mit dem Assistenten, #020)
 ## Abhängigkeiten
 #017, #018
 ## Notizen / Entscheidungen
 - Vorlagen pflegt nur, wer `einstellungenVerwalten` darf (Admin); lesen darf jede Rolle, weil
  Vorlagen keine Geheimnisse enthalten und Operatoren sie im Assistenten sehen.
 - Die Vorschau im Formular ruft dieselben reinen Funktionen wie der Server
  (`platzhalterErsetzen`, `optionenPruefen`, `sudoersInhalt`) mit eigenen Beispielwerten auf;
  Fehler werden dort nur angezeigt, verbindlich prüft der Server beim Speichern.
 - Das Befehlsfeld wird bei anderem sudo-Modus nur ausgeblendet, nicht entfernt – so gehen
  eingegebene Befehle beim Umschalten nicht verloren; der Service verwirft sie ohnehin.
 - Die sudoers-Vorschau bricht nicht um: sudoers ist zeilenbasiert, ein optischer Umbruch sähe
  wie eine zweite Regel aus.
 - Eingebaute Vorlagen lassen sich bearbeiten, aber nicht archivieren; ihre Bearbeiten-Seite
  zeigt deshalb keinen Archivieren-Knopf.
@@ -1,21 +1,27 @@
 # #020 Host-zu-Host-Assistent und Verbindungstest
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.3.0
 **Labels:** ui, backend
-**Geschätzt:** 4 h   **Tatsächlich:** –
+**Geschätzt:** 4 h   **Tatsächlich:** 0 h 50 min
 ## Ziel
 Geführter Ablauf: Schlüssel erzeugen, Private auf A, Public auf B, Host-Key von B in known_hosts von A, Verbindungstest.
 ## Aufgaben
- [ ] Schrittanzeige
+- [x] Schrittanzeige
- [ ] Zusammenfassung + Dry-Run
+- [x] Zusammenfassung + Dry-Run
- [ ] `ssh -o BatchMode=yes … true` auf A
+- [x] `ssh -o BatchMode=yes … true` auf A
 ## Akzeptanzkriterien
- [ ] Kern-Anwendungsfall Ende-zu-Ende gegen zwei Test-Container
+- [x] Kern-Anwendungsfall Ende-zu-Ende gegen zwei Test-Container
 ## Abhängigkeiten
 #019
 ## Notizen / Entscheidungen
 - **Fünf Schritte:** Vorlage & Zweck, Quelle, Ziel (Zielbenutzer, optional anlegen mit sudo, Einschränkungen, Alias, HostName/Port aus Sicht von A, Fingerprint von B bestätigen), Zusammenfassung, Ausrollen (Dry-Run, anwenden, Verbindungstest).
 - **Vorlage** füllt Zielbenutzer, Anlegen/sudo, Ablaufdatum, `from=`-Muster und Alias vor; Platzhalter werden mit A und B aufgelöst. Ist die Adresse von A keine IP, fragt der Assistent nach.
 - **Wiederaufnehmbar:** Erledigte Schritte (Schlüssel, Zielkonto, Zuweisungen) werden beim „Fortsetzen“ übersprungen. Braucht das Zielkonto eine frische Bestätigung, geschieht sie in einem neuen Tab – die Eingaben bleiben stehen.
 - **root als Ziel:** deutlicher Hinweis, dass ein Agent wie Claude Code dann uneingeschränkten Zugriff hätte.
 - **Verbindungstest:** `ssh -o BatchMode=yes -o StrictHostKeyChecking=yes <alias> true` auf A als Zielbenutzer.
 - E2E: Vorlage „Deployment-Zugang“ → `deploy` auf B angelegt → A meldet sich als deploy bei B an.
@@ -1,20 +1,27 @@
 # #021 Abgleich und Drift-Erkennung
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.4.0
 **Labels:** backend
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 45 min
 ## Ziel
 Periodischer und manueller Abgleich, Befunde je Host/Benutzer.
 ## Aufgaben
- [ ] Zeitplan konfigurierbar
+- [x] Zeitplan konfigurierbar
- [ ] Befundarten
+- [x] Befundarten
 ## Akzeptanzkriterien
- [ ] Integrationstest
+- [x] Integrationstest
 ## Abhängigkeiten
 #016
 ## Notizen / Entscheidungen
 - **Ein SSH-Aufruf je Host** liest `authorized_keys` aller Benutzer mit UID 0 oder ≥ 1000 plus aller Benutzer mit Zuweisungen – als jeweiliger Benutzer, base64-kodiert (Zeilenenden und fremde Bytes kommen unversehrt an). Dazu Rechte und Eigentümer von `~/.ssh` und Datei.
 - **Befunde** (rein, `src/lib/ssh/abgleich.ts`): fehlender Key im Block, Block von Hand geändert (zusätzlicher Key oder andere Optionen), unbekannter Key außerhalb (bekannte Keys außerhalb sind kein Befund), Rechte (für Gruppe/Welt beschreibbar oder fremder Eigentümer), beschädigter Block, Private Key fehlt oder verändert (Hash gegen den versiegelten Key).
 - **Abweichungen** werden geöffnet und – sobald behoben – geschlossen, nie doppelt. Host-Key-Abweichungen bleiben bei #009.
 - **Zustände:** Public-Verwendungen AUSGEROLLT ↔ ABWEICHUNG, GEPLANT bleibt bis zum Ausrollen; Host SYNCHRON/DRIFT, letzter Abgleich, erreichbar.
 - **Zeitplan** über pg-boss (`SSHKV_SYNC_CRON`, Standard `30 2 * * *`, Europe/Berlin) – liegt in der Datenbank, feuert also auch bei mehreren Workern nur einmal. Hosts mit laufendem Abgleich werden übersprungen.
 - **Ändert nichts auf dem Host.** Korrekturen laufen über Dry-Run und Ausrollen.
 - `DATEI_GEAENDERT` meldet nur einen beschädigten Block; eine bloße Hash-Änderung ist kein Befund, weil sshkv selbst schreibt.
@@ -1,19 +1,23 @@
 # #022 Import bestehender Schlüssel
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.4.0
 **Labels:** backend, ui
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 20 min
 ## Ziel
 Unbekannte Schlüssel eines Hosts übernehmen und zuordnen.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] wird zu Beginn der Phase verfeinert
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] wird zu Beginn der Phase verfeinert
 ## Abhängigkeiten
 #021
 ## Notizen / Entscheidungen
 - **Grundlage ist die letzte Beobachtung** des Abgleichs: Übernommen wird nur, was sshkv dort wirklich gesehen hat.
 - **Zwei Wege:** „bekannt“ (nur als Schlüssel aufnehmen – der Befund verschwindet, auf dem Host ändert sich nichts) oder „verwalten“ (Zuweisung mit `ausserhalbEntfernen`: beim nächsten Ausrollen wandert die Zeile mit ihren Optionen in den Block, die alte Zeile außerhalb verschwindet – mit Dry-Run).
 - Neues Feld `PublicVerwendung.ausserhalbEntfernen` (Migration `20261012131000`). Ohne dieses Feld fasst sshkv Zeilen außerhalb des Blocks weiterhin nie an.
 - Optionen der Zeile werden mit `optionenPruefen` übernommen; unbekannte Optionen verhindern das Verwalten mit klarer Meldung.
@@ -1,19 +1,46 @@
 # #023 Geführte Rotation
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.4.0
 **Labels:** backend, ui
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 20 min
 ## Ziel
 Neuer Schlüssel an allen Verwendungen, Test, alter entfernt.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] „Rotieren“ auf der Schlüsselseite, Schrittfolge `/schluessel/[id]/rotieren` (wiederaufnehmbar)
 - [x] Neuer Schlüssel gleichen Typs, Name „… (rotiert TT.MM.JJJJ)“, `vorgaengerId` = alter
 - [x] Zuweisungen übernehmen: Public gleiche Ziele/Optionen, Private gleicher Host/Benutzer/Alias mit neuem Pfad
 - [x] Dry-Run + Ausrollen, Verbindungstests, erst dann den alten widerrufen (#024) → `ROTIERT`
 - [x] Personen-Key ohne Private Key: nur Hinweis „neuer Public Key nötig“
 - [x] Rotationskette auf der Schlüsselseite (Vorgänger/Nachfolger verlinkt)
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] DB-Tests: Schritte, Reihenfolge, Rechte, Namen/Pfade (`tests/rotation.test.ts`)
 - [x] Integrationstest: neuer Schlüssel funktioniert, alter von beiden Hosts weg, `ssh <alias>` geht weiter
 - [x] E2E im Browser (`tests/e2e/rotation.spec.ts`), Screenshot `rotation-desktop.png`
 ## Abhängigkeiten
-#020
+#020, #024
 ## Notizen / Entscheidungen
 - **Fünf Schritte:** Neuer Schlüssel → Zuweisungen übernehmen → Dry-Run & Ausrollen → Verbindungstests →
  Alten widerrufen. Der aktuelle Schritt wird aus der Datenbank errechnet (`rotationsStand`), deshalb
  lässt sich die Rotation jederzeit neu laden und fortsetzen; jeder Schritt ist idempotent.
 - **Kette sofort:** Der Worker setzt `vorgaengerId` schon beim Erzeugen (neues Feld in der
  Vorgangs-Eingabe) – auch ein abgebrochener Browser hinterlässt keinen verwaisten Schlüssel.
  `vorgaengerId` ist eindeutig: zwei gleichzeitige Rotationen scheitern verständlich.
 - **Gleicher Alias, zwei Zuweisungen:** `privat.ts` schreibt je Alias genau einen config-Eintrag, die
  jüngste Zuweisung gewinnt (an der Position der ersten). So zeigt `ssh <alias>` nach dem Ausrollen auf
  die neue Datei, während die alte bis zum Widerruf daneben liegt.
 - **Neuer Pfad:** `<alter Pfad ohne -rJJJJMMTT>-rJJJJMMTT`, bei Kollision mit laufender Nummer –
  auch entfernte Zuweisungen belegen einen Pfad (eindeutiger Index über alle Zustände).
 - **Grün heißt aktuell:** Der alte Schlüssel wird nur widerrufen, wenn für jede Private-Zuweisung mit
  Alias ein erfolgreicher `VERBINDUNGSTEST` nach dem letzten Ausrollen vorliegt (Server prüft das).
  Ohne Private-Zuweisung mit Alias entfällt der Test.
 - **Abschluss:** Widerruf aus #024 ohne Zielkonten (der Nachfolger nutzt sie weiter); ein aktiver
  Nachfolger macht aus `WIDERRUFEN` den Status `ROTIERT`.
 - Ablaufdatum: Der Nachfolger erbt es nur, wenn es in der Zukunft liegt. Eine Passphrase wird nicht
  übernommen (sshkv erzeugt ohne).
 - Rechte: `schluesselVerwalten` + `publicKeyAusrollen`, bei Private-Zuweisungen `privateKeyAusrollen`.
  Deployment-Key: eigene Rotation (später).
@@ -1,19 +1,49 @@
 # #024 Widerruf und Massenwiderruf
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.4.0
 **Labels:** backend, ui, sicherheit
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 25 min
 ## Ziel
 Ein-Klick-Widerruf inkl. Benutzer/sudoers; Massenwiderruf mit Re-Auth.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] „Widerrufen“ auf der Schlüsselseite mit Dialog, der jede Entfernung auflistet
 - [x] Public- und Private-Verwendungen → ENTFERNEN, Dry-Run, anwenden, erst dann `WIDERRUFEN`
 - [x] Zielkonten optional entfernen (nur `vonSshkvAngelegt`, nie ein noch genutztes)
 - [x] Massenwiderruf auf der Schlüsselliste, ein gemeinsamer Dry-Run, Protokoll je Schlüssel
 - [x] Abgelaufene Schlüssel erkennbar (Filter) und Widerruf anbieten – ohne automatisches Entfernen
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] DB-Tests: Zustände, Rechte, Zielkonten, Protokoll ohne Geheimnisse (`tests/widerruf.test.ts`)
 - [x] Integrationstest gegen zwei Hosts inkl. „Host nicht erreichbar“ (`tests/integration/widerruf.test.ts`)
 - [x] E2E im Browser (`tests/e2e/widerruf.spec.ts`), Screenshot `widerruf-desktop.png`
 ## Abhängigkeiten
 #018
 ## Notizen / Entscheidungen
 - **Zwischenzustand statt Sofort-Status:** neues Feld `Schluessel.widerrufEingeleitetAm` (Migration
  `20261012130000_widerruf_eingeleitet`). Der Status bleibt AKTIV/ABGELAUFEN, bis keine Verwendung mehr
  offen ist; erst `widerrufAbschliessen` setzt `WIDERRUFEN` (bzw. `ROTIERT`, wenn ein aktiver Nachfolger
  existiert, #023). Schlüsselseite und Liste zeigen „Widerruf unvollständig“ und die offenen Ziele.
 - **Reihenfolge:** vormerken → Dry-Run/Anwenden (bestehende Hash-Sperre aus #016/#017) → optional
  Zielkonten (`ZIELKONTO_ENTFERNEN`, erst wenn die Schlüssel überall weg sind) → abschließen.
  Ein Ziel, das im Dry-Run scheitert (nicht erreichbar), wird nicht angewendet; seine Verwendung bleibt
  ENTFERNEN, ein neuer Dry-Run versucht es erneut. Der Abschluss läuft nach erfolgreichem Anwenden
  automatisch und meldet, was noch fehlt.
 - **Nichts zu schreiben:** Steht der Schlüssel schon nirgends mehr, bietet das Dry-Run-Panel
  „Zustand übernehmen“ an (sonst bliebe der Widerruf hängen).
 - **Archivierte Hosts:** sshkv verbindet sich dort nicht mehr – deren Verwendungen gelten sofort als
  entfernt; der Dialog sagt das, das Protokoll nennt die Hosts.
 - **Zielkonten:** Ein Zielkonto kennt seinen Schlüssel nicht; Kandidat ist ein von sshkv angelegtes Konto
  auf (Host, Benutzer) einer Zuweisung der widerrufenen Schlüssel. Nutzt ein anderer, nicht im Widerruf
  befindlicher Schlüssel das Konto noch, bleibt es (Dialog nennt den Schlüssel).
 - **Rechte:** nur Public Keys → `publicKeyAusrollen`; Private Keys → `privateKeyAusrollen` (Admin);
  mehrere Schlüssel → `massenwiderruf`, Zielkonten → `zielkontenVerwalten` (jeweils Admin mit frischer
  Bestätigung). Der Deployment-Key ist nicht widerrufbar. Ein Schlüssel im Widerruf lässt sich nicht
  mehr zuweisen.
 - **Ablauf:** Status-Filter „abgelaufen“ umfasst aktive Schlüssel mit vergangenem Ablaufdatum; die
  Schlüsselseite bietet dann „Jetzt widerrufen“. Entfernt wird nie automatisch.
 - Massenwiderruf als GET-Formular `/schluessel/widerruf?id=…` – die Auswahl der Zielkonten reist als
  `?zielkonten=` mit und übersteht Neuladen und erneute Bestätigung.
@@ -1,19 +1,46 @@
 # #025 Zuweisungsmatrix
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.4.0
 **Labels:** ui
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0,5 h
 ## Ziel
 Matrix Schlüssel × Host.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] `/zuweisungen` ersetzt die Platzhalterseite: Matrix aktive Schlüssel (Zeilen) × nicht archivierte Hosts (Spalten), jede Rolle darf lesen
 - [x] Zelle: „P“ direkt, „P·G“ über Hostgruppe, „K“ Private Key; Zustand als Punkt + Kurztext, voller Text in `title` und für Screenreader; Zielbenutzer mono
 - [x] Filter per GET: Hostgruppe, Kategorie, Person, Suche über Schlüssel- und Hostnamen, „nur Zeilen/Spalten mit Zuweisungen“
 - [x] Eigener Scrollbereich mit sticky Kopfzeile und erster Spalte; unter `md` eine Liste je Schlüssel
 - [x] Zell-Dialog: Verwendungen mit Zustand, Optionen/Pfad, Links zu Schlüssel und Host; „Public Key zuweisen“ (vorhandenes Formular mit Vorauswahl) und „Entfernen“ für `publicKeyAusrollen`; Link „Zum Dry-Run“
 - [x] Kopf: Zähler (Schlüssel, Hosts, Zuweisungen, nicht synchron) und CSV-Export `/api/zuweisungen.csv`
 - [x] Reine Matrix-Funktion in `src/lib/zuweisungsmatrix.ts`, CSV-Helfer in `src/lib/csv.ts`, Query in `src/server/queries/zuweisungen.ts`
 - [x] Tests: `tests/zuweisungsmatrix.test.ts` (rein), `tests/zuweisungen.test.ts` (Query + CSV-Route), E2E `tests/e2e/zuweisungen.spec.ts`
 - [x] Screenshots `zuweisungen-desktop.png` / `zuweisungen-mobil.png`
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Gruppen-Zuweisungen erscheinen auf jedem Mitglied und sind von direkten unterscheidbar
 - [x] Zustand nie nur über Farbe
 - [x] Seite scrollt bei 390 px nicht horizontal (Screenshot-Skript prüft das)
 - [x] Leser sehen die Matrix, aber weder Zuweisen noch Entfernen
 - [x] CSV mit den Spalten Schlüssel, Fingerprint, Host, Zielbenutzer, Art, Über Gruppe, Optionen, Zustand; Formelbeginne `= + - @` mit `'` entschärft
 - [x] Route Handler prüft `rechtErforderlich("lesen")` selbst (`tests/zugang.test.ts` grün)
 ## Abhängigkeiten
 #016
 ## Notizen / Entscheidungen
 - Die Matrix plant nur: Zuweisen und Entfernen nutzen die vorhandenen Aktionen, ausgerollt wird
  weiter über den Dry-Run der Schlüsselseite (`AusrollenPanel`).
 - Suche: trifft der Begriff Schlüssel, werden die Zeilen eingeschränkt; trifft er Hosts, die
  Spalten; trifft er beides, beides. So zeigt „srv-pve“ alle Schlüssel auf diesen Hosts statt
  einer leeren Matrix.
 - Zähler „Zuweisungen“ zählt Zelleneinträge, eine Gruppen-Zuweisung also einmal je Mitglied –
  dasselbe, was der CSV-Export als Zeilen liefert. „Nicht synchron“ ist alles außer `AUSGEROLLT`.
 - Zellenzustand ist der dringendste der Einträge (Fehler > Drift > entfernen > geplant > synchron).
 - CSV: Semikolon, UTF-8-BOM und CRLF für ein deutsches Excel; bei Private Keys steht der Pfad
  als „Pfad: …“ in der Spalte Optionen. Der Export nimmt dieselben Filter wie die Seite.
 - Deployment-Keys erscheinen als Zeilen, sind aber nicht zuweisbar (verwaltet sshkv selbst).
 - Entfernen einer Gruppen-Zuweisung aus einer Zelle gilt für die ganze Gruppe; der Dialog sagt das.
 - `PublicZuweisenFormular` hat eine optionale `vorauswahl`; `VerwendungsZustand` exportiert seine
  Darstellungstabelle (`ZUSTAND_ANZEIGE`), damit die Zelle dieselben Punkte nutzt.
@@ -1,19 +1,24 @@
 # #026 Übersicht (Dashboard)
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.5.0
 **Labels:** ui
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 25 min
 ## Ziel
 Kennzahlen, Hosts mit Abweichung, bald ablaufend, letzte Aktionen.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Kennzahlen, Hosts mit Abweichung, bald ablaufend, letzte Aktionen aus der Datenbank
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Kennzahlen, Hosts mit Abweichung, bald ablaufend, letzte Aktionen aus der Datenbank
 ## Abhängigkeiten
 #021
 ## Notizen / Entscheidungen
 - **Alles berechnet, nichts hinterlegt** (`src/server/queries/uebersicht.ts`): Kacheln und Listen können einander nicht widersprechen. Die Prototyp-Beispieldaten sind entfernt.
 - **Hosts mit Abweichung** fasst Befunde je Host und Benutzer zusammen („2 unbekannte Schlüssel · Rechte falsch“, feste Reihenfolge) und zeigt nicht erreichbare Hosts; Link direkt auf die Hostseite.
 - **Bald ablaufend** zeigt auch bereits abgelaufene, noch aktive Schlüssel („abgelaufen · noch ausgerollt“ in Koralle).
 - **Letzte Aktionen** ohne Anmeldungen – die stehen im Audit-Log.
 - Knöpfe nur für passende Rollen (Abgleich: Hosts verwalten; Assistent: Private Keys ausrollen).
@@ -1,19 +1,40 @@
 # #027 Protokollansicht, CSV-Export, Syslog
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.5.0
 **Labels:** ui, backend
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 20 min
 ## Ziel
 Filterbare Ansicht, CSV, optionale Weiterleitung an Syslog.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] `/protokoll` statt Platzhalter, jede Rolle liest: Tabelle mit Zeitpunkt (TT.MM.JJJJ HH:MM:SS), Aktion (lesbar, farbig), Akteur, Host, Zielbenutzer, Fingerprint (gekürzt), Ergebnis; unter `md` Karten
 - [x] Zeile aufklappbar: Diff im Diff-Box-Stil, Details als Liste (Werte als JSON), Hash und Vorgänger-Hash
 - [x] Lesbare Texte für alle Aktionen in `src/lib/protokoll-aktionen.ts`, gruppiert (Anmeldung, Host-Key, Ausrollen, Schlüssel, Widerruf/Rotation, Zielkonto, Abgleich, Hosts, Personen und Vorlagen, Protokoll)
 - [x] Filter per GET: Zeitraum (Berliner Kalendertage), Aktionsgruppe, Akteur, Host, Ergebnis, Freitext (Fingerprint/Host/Benutzer)
 - [x] 50 je Seite, „Ältere laden“ hängt per Server Action an; Cursor über `id`, kein `OFFSET`; `?vor=<id>` als Einstieg
 - [x] Kopfzeile mit Anzahl und Syslog-Ziel; „Kette prüfen“ (Server Action) mit Ergebnis-Zwischenspeicher für 5 Minuten, Warnung mit Link auf die erste fehlerhafte ID
 - [x] CSV-Export `/api/protokoll.csv`: eigene Rechteprüfung, gleiche Filter, gestreamt in Stapeln zu 500, Formel-Entschärfung über `src/lib/csv.ts`, Export selbst als `protokoll.exportiert` protokolliert
 - [x] Kein Lösch-/Bearbeitungsweg; struktureller Test gegen `protokoll.update/delete…` und `UPDATE/DELETE/TRUNCATE "Protokoll"` in `src/`
 - [x] Syslog nach RFC 5424 (`src/lib/syslog.ts`, UDP oder TCP mit Oktettzählung, ohne neue Abhängigkeit), eingehängt in `protokollieren()` nach dem Schreiben
 - [x] `.env.example` und `docker-compose.yml` (web und worker) um `SSHKV_SYSLOG_*`
 - [x] Tests: Query/Cursor/Filter, CSV-Route, Kettenprüfung, Syslog (Format, Escaping, Länge, UDP-/TCP-Empfänger), Aktionstexte, Struktur; E2E `tests/e2e/protokoll.spec.ts`
 - [x] Screenshots `protokoll-desktop.png` und `protokoll-mobil.png`
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Jede `aktion: "…"` im Quellcode hat einen lesbaren Text (Test)
 - [x] Filter und „Ältere laden“ liefern weder Lücken noch Doppelte, auch wenn zwischendurch Einträge dazukommen
 - [x] CSV ohne Sitzung → 403; Kopfzeile `id;zeitpunkt;akteur;aktion;…;hash`; große Protokolle werden in Stapeln gelesen
 - [x] Manipulierte Zeile → Warnung mit ID; unversehrte Kette → „Hash-Kette unversehrt“
 - [x] Ausgefallener Syslog-Server verhindert keine Aktion; Fehler höchstens einmal je Minute im Log
 - [x] 1440 und 390 px ohne Querscrollen
 ## Abhängigkeiten
 #005
 ## Notizen / Entscheidungen
 - **Kettenprüfung nur auf Knopfdruck, 5 Minuten zwischengespeichert (je Prozess).** `protokoll_kette_pruefen()` rechnet SHA-256 über jede Zeile und wächst linear mit dem Protokoll; beim bloßen Seitenaufruf wäre das bei 100 000 Einträgen spürbar. Gleichzeitige Klicks teilen sich eine laufende Prüfung. Ein Bruch wird selbst als `protokoll.kette_beschaedigt` (FEHLER) protokolliert, damit er auch beim Syslog ankommt.
 - **CSV gestreamt** über einen `ReadableStream` mit `pull`: je Stapel 500 Zeilen (Cursor über `id`), der nächste Stapel erst, wenn der Client den vorigen abgenommen hat. Der Exporteintrag wird vor dem ersten Byte geschrieben – scheitert er, gibt es keinen Export.
 - **IDs sind nicht lückenlos** (Spalten-Default und Trigger ziehen beide aus der Sequenz); Cursor und Tests verlassen sich nur auf die Ordnung.
 - **Syslog:** RFC 5424, SD-ID `sshkv@32473`, Parameter id/akteur/aktion/ergebnis/host/zielbenutzer/fingerprint/hash (escaped nach §6.3.3, Steuerzeichen ersetzt, je Wert ≤ 120 Byte, Zeile ≤ 2048 Byte), MSGID = Aktion, Severity ERFOLG=notice, VERWEIGERT=warning, FEHLER=err, Facility standardmäßig `authpriv` (`SSHKV_SYSLOG_FACILITY`). Diff und Details gehen nie hinaus. Fire-and-forget nach dem `create`; innerhalb einer Transaktion kann ein späterer Rollback eine Syslog-Zeile ohne Gegenstück hinterlassen – das ist die harmlosere Richtung (ihr Hash fehlt dann in der Kette).
 - `--ok` nur für erfolgreiche Aktionen, die etwas ändern; Anmeldungen, Abrufe und Export bleiben neutral, Fehler/Verweigert immer `--danger`.
@@ -1,19 +1,65 @@
 # #028 Benachrichtigungen
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.5.0
 **Labels:** backend
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0,5 h
 ## Ziel
 E-Mail (M365 SMTP) und Webhook bei Drift und Ablauf.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Einstellungsseite `/einstellungen` statt Platzhalter: lesen alle Rollen, ändern nur
      `einstellungenVerwalten` (Admin). Abschnitte „Benachrichtigungen“, „Abgleich“ (Zeitpläne aus
      `SSHKV_SYNC_CRON`/`SSHKV_MELDUNG_CRON`, nur Anzeige) und „Instanz“ (Version,
      Deployment-Key-Fingerprint, OIDC-Anbieter, TOTP des Notfall-Admins). Platz für „Syslog“ markiert.
 - [x] Kanal E-Mail (SMTP): Vorbelegung Microsoft 365 (`smtp.office365.com:587`, STARTTLS), wahlweise
      TLS (465) oder unverschlüsselt (nur internes Relay, mit Warnung); Absender, Benutzer, Passwort,
      Empfängerliste.
 - [x] Kanal Webhook: JSON per POST, optional `X-Sshkv-Signatur: sha256=<HMAC>` über den Body; nur
      `https://`, `http://` nur per Häkchen mit Warnung; keine Weiterleitungen, Zeitlimit 15 s.
 - [x] Geheimnisse (SMTP-Passwort, Webhook-Geheimnis) mit `verschluesseln()` in `Einstellung`;
      die Oberfläche bekommt nur „gesetzt“, leeres Feld behält, Häkchen entfernt.
 - [x] „Testnachricht senden“ je Kanal als Vorgang `BENACHRICHTIGUNG_TEST` im Worker.
 - [x] Anlässe (je einzeln schaltbar): neue Abweichungen je Host, Ablauf in 30/14/7 Tagen,
      abgelaufen aber ausgerollt, Host nicht erreichbar – gesammelt in der täglichen Zusammenfassung
      (`SSHKV_MELDUNG_CRON`, Standard `0 7 * * *`); geänderter Host-Key sofort (Takt alle 5 Minuten).
 - [x] Versandprotokoll `Zustellung` (Migration `20261012161000_benachrichtigungen`) mit
      Anlass-Fingerabdruck, Kanal, Ergebnis, Fehler, Versuchen; Prüfung vor jedem Versand,
      Wiederholung nach 5/10/20/40 Minuten (höchstens 5 Versuche); „Letzte Zustellungen“ auf der Seite.
 - [x] Jede Zustellung in `protokollieren()` als `benachrichtigung.gesendet`/`…fehlgeschlagen`
      (Empfänger nur gezählt, Webhook nur Schema und Host).
 - [x] Zeitpläne in `src/worker/index.ts`; `.env.example` und `docker-compose.yml` ergänzt.
 - [x] Tests: Unit (Nachrichtenaufbau, Signatur, Stufen, Deduplizierung, Prüfungen), DB
      (Einstellungen, Versandprotokoll), Integration gegen Mailpit und lokalen HTTP-Empfänger,
      E2E `tests/e2e/einstellungen.spec.ts`; Screenshots `einstellungen-desktop/-mobil`.
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Admin speichert SMTP-Einstellungen, die Testnachricht kommt in Mailpit an (E2E).
 - [x] Das Passwort steht nie im Klartext in Datenbank, Protokoll oder Seite; das Feld zeigt nur „gesetzt“.
 - [x] Leser sieht die Seite ohne Ändern- und Test-Knöpfe.
 - [x] Dieselbe Abweichung, dieselbe Ablaufstufe und derselbe Ausfall werden je Kanal genau einmal gemeldet.
 - [x] Fehlgeschlagene Zustellungen werden begrenzt wiederholt und sind in der Oberfläche sichtbar.
 - [x] Ein geänderter Host-Key wird innerhalb von fünf Minuten gemeldet, ohne den Abgleich-Ablauf zu ändern.
 ## Abhängigkeiten
 #021
 ## Notizen / Entscheidungen
 - **Versand im Worker**, auch für die Testnachricht: der Webprozess braucht so keinen Weg zu
  Mailserver oder Webhook-Ziel, und regulärer Versand und Test laufen über denselben Code. Die
  Oberfläche verfolgt den Test wie andere Vorgänge über `VorgangsKnopf`.
 - **Anlässe aus der Datenbank**, nicht aus dem Abgleich: `src/worker/ablaeufe/abgleich.ts` bleibt
  unverändert; der Sammler liest offene `Abweichung`, `Host.erreichbar = false` und Ablaufdaten.
  Ein verpasster Lauf holt sich der nächste.
 - **Fingerabdrücke:** `drift:<abweichungId>`, `hostkey:<abweichungId>`,
  `ablauf:<schluesselId>:<stufe>:<ablaufdatum>` (mit Datum, damit ein verlängerter Schlüssel neu
  erinnert wird), `abgelaufen:<schluesselId>:<ablaufdatum>`,
  `unerreichbar:<hostId>:<letzterAbgleichAm>` (ändert sich nur bei gelungenem Abgleich → eine Meldung
  je Ausfall). Statt „seit der letzten Meldung“ zählt das Versandprotokoll – wer Benachrichtigungen
  erstmals einschaltet, bekommt die offenen Abweichungen einmal gemeldet.
 - Hosts mit offenem `HOSTKEY_GEAENDERT` erscheinen nicht zusätzlich als „nicht erreichbar“.
 - Der Fünf-Minuten-Takt verschickt dringende Host-Key-Meldungen und fällige Wiederholungen;
  Neues aus (a)–(d) wartet auf die Zusammenfassung. Läufe im selben Worker laufen nacheinander.
 - Leser sehen statt der Webhook-Adresse nur Schema und Host (Tokens im Pfad).
 - Mailpit für Tests mit `MP_SMTP_DISABLE_RDNS=true` starten, sonst wartet es je Verbindung 5 s.
 - `nodemailer@10.0.10` wie in ProxLedger, exakt gepinnt.
@@ -1,19 +1,29 @@
 # #029 Handbuch und Betriebsdokumentation
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.5.0
 **Labels:** docs
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 50 min
 ## Ziel
 Installation, Bootstrap, Kern-Anwendungsfall mit Bildern; Bedrohungsanalyse, Backup-Konzept.
 ## Aufgaben
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Handbuch mit Bildern (`docs/anleitung/README.md`, 12 Kapitel)
 - [x] Installation, authentik, Reverse Proxy (`docs/betrieb/installation.md`)
 - [x] Bedrohungsanalyse und Notfallplan (`docs/betrieb/sicherheit.md`)
 - [x] Backup-Konzept mit Skripten und geprobter Wiederherstellung (`docs/betrieb/sicherung.md`)
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] Handbuch mit Bildern (`docs/anleitung/README.md`, 12 Kapitel)
 - [x] Installation, authentik, Reverse Proxy (`docs/betrieb/installation.md`)
 - [x] Bedrohungsanalyse und Notfallplan (`docs/betrieb/sicherheit.md`)
 - [x] Backup-Konzept mit Skripten und geprobter Wiederherstellung (`docs/betrieb/sicherung.md`)
 ## Abhängigkeiten
 –
 ## Notizen / Entscheidungen
 - **Wiederherstellung geprobt** auf einem Wegwerf-Stapel – dabei zwei Fehler gefunden und behoben (Schema pgboss mit `--clean` nicht rückspielbar; Abbruch ohne Transaktion löschte es halb). Jetzt: nur Schema `public`, eine Transaktion, Warteschlange neu, offene Vorgänge abgebrochen.
 - **Master-Key wird nicht mitgesichert**, nur ein Prüfwert (SHA-256). Das Wiederherstellungsskript bricht vor jeder Änderung ab, wenn der bereitliegende Master-Key nicht passt; der Worker startet nicht mit einem falschen Master-Key.
 - **Notfallplan „sshkv kompromittiert“** beschreibt das Entfernen des Deployment-Keys auf allen Hosts von Hand – eine eingebaute Rotation des Deployment-Keys gibt es noch nicht.
 - Bilder entstehen aus `scripts/screenshots.ts` und den E2E-Abläufen.
@@ -1,19 +1,21 @@
 # #030 Issues nach Gitea übertragen
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.1.0
 **Labels:** chore
-**Geschätzt:** 1 h   **Tatsächlich:** –
+**Geschätzt:** 1 h   **Tatsächlich:** 0 h 10 min
 ## Ziel
 Issue-Dateien, Labels und Meilensteine in Gitea anlegen (wartet auf Zugangsdaten).
 ## Aufgaben
- [ ] `scripts/gitea-issues.ts`
+- [x] `scripts/gitea-issues.ts`
 ## Akzeptanzkriterien
- [ ] wird zu Beginn der Phase verfeinert
+- [x] wird zu Beginn der Phase verfeinert
 ## Abhängigkeiten
 –
 ## Notizen / Entscheidungen
 - Repo `florian.wilde/sshkeyvault` auf git.wilde-server.de (von Florian angelegt), `main` und Tags v0.1.0–v0.5.0 gepusht.
 - `pnpm issues:sync` liest Adresse und Repo aus dem Git-Remote und den Token aus den Git-Zugangsdaten; die Issue-Dateien bleiben die Quelle der Wahrheit.
@@ -0,0 +1,25 @@
 # #031 Rotation des Deployment-Keys
 **Status:** offen
 **Meilenstein:** v1.0.0
 **Labels:** sicherheit, backend
 **Geschätzt:** 3 h   **Tatsächlich:** –
 ## Ziel
 Den Deployment-Key der Instanz geführt tauschen – regelmäßig oder im Notfall (sshkv kompromittiert, siehe `docs/betrieb/sicherheit.md`).
 ## Aufgaben
 - [ ] Neuen Deployment-Key erzeugen, ohne den alten abzulösen (zweiter Instanz-Key im Übergang)
 - [ ] Auf jedem eingerichteten Host den neuen Key neben den alten in den verwalteten Block des Anmeldebenutzers schreiben (Dry-Run, Ausrollen)
 - [ ] Verbindung mit dem neuen Key je Host prüfen
 - [ ] Erst wenn alle Hosts den neuen Key akzeptieren: alten aus allen Blöcken entfernen, alten Key verwerfen
 - [ ] Nicht erreichbare Hosts sichtbar machen; Abschluss erst, wenn alle umgestellt sind (oder bewusst übergangen)
 - [ ] Nur Admin mit frischer Bestätigung, alles protokolliert
 ## Akzeptanzkriterien
 - [ ] Integrationstest: nach der Rotation meldet sich sshkv nur noch mit dem neuen Key an, der alte steht auf keinem Host mehr
 - [ ] Aussperrschutz: zu keinem Zeitpunkt steht ein Host ohne funktionierenden Deployment-Key da
 ## Abhängigkeiten
 #016, #021
 ## Notizen / Entscheidungen
@@ -0,0 +1,22 @@
 # #032 Nacharbeiten aus Phase 4/5
 **Status:** offen
 **Meilenstein:** v1.0.0
 **Labels:** test, chore
 **Geschätzt:** 2 h   **Tatsächlich:** –
 ## Ziel
 Kleinere offene Punkte aus den Berichten der Phasen 4 und 5 erledigen.
 ## Aufgaben
 - [ ] Massenwiderruf im Browser testen (E2E mit frischer Bestätigung über den Mock-OIDC)
 - [ ] Laufende Rotation abbrechen können (Nachfolger widerrufen, Vorgänger wieder aktiv)
 - [ ] Protokoll-IDs ohne Zweierschritte (Spalten-Default und Trigger ziehen beide `nextval`)
 - [ ] „Zum Dry-Run“ aus der Zuweisungsmatrix direkt zur Dry-Run-Karte springen (Anker)
 ## Akzeptanzkriterien
 - [ ] Alle Suiten grün
 ## Abhängigkeiten
 #023, #024, #025, #027
 ## Notizen / Entscheidungen
@@ -1,6 +1,6 @@
 {
  "name": "sshkv",
-  "version": "0.1.0",
+  "version": "0.5.0",
  "private": true,
  "type": "module",
  "description": "SSHKeyVault – zentrale Verwaltung von SSH-Schluesseln mit Weboberflaeche",
@@ -56,6 +56,7 @@
    "jose": "^6.2.12",
    "lucide-react": "1.47.0",
    "next": "16.3.6",
    "nodemailer": "10.0.10",
    "openid-client": "^6.8.8",
    "pg": "^8.23.1",
    "pg-boss": "^12.37.1",
@@ -71,6 +72,7 @@
    "@playwright/test": "1.63.0",
    "@tailwindcss/postcss": "^4.3.3",
    "@types/node": "^24.19.2",
    "@types/nodemailer": "8.0.2",
    "@types/pg": "^8.23.1",
    "@types/qrcode": "^1.5.6",
    "@types/react": "^19.3.0",
@@ -199,6 +199,9 @@ importers:
      next:
        specifier: 16.3.6
        version: 16.3.6(@babel/core@7.29.7(supports-color@7.2.0))(@opentelemetry/api@1.9.1)(@playwright/test@1.63.0)(@types/node@24.19.2)(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
      nodemailer:
        specifier: 10.0.10
        version: 10.0.10
      openid-client:
        specifier: ^6.8.8
        version: 6.8.8
@@ -239,6 +242,9 @@ importers:
      '@types/node':
        specifier: ^24.19.2
        version: 24.19.2
      '@types/nodemailer':
        specifier: 8.0.2
        version: 8.0.2
      '@types/pg':
        specifier: ^8.23.1
        version: 8.23.1
@@ -1481,6 +1487,9 @@ packages:
  '@types/node@26.6.5':
    resolution: {integrity: sha512-uMzsv9stDdofIZBx4UGh4Z9ZgXnGC9seRDscilBcTHAeOFk67MZg/k9bWVfO+bk4qZmG+l52hRnLwUiH2LnJTg==}
  '@types/nodemailer@8.0.2':
    resolution: {integrity: sha512-c7M5ox8p0nEOfbJ2E9Qcmt8/QCu/VzsiAhzBiZbvky2PhKZDHpKB3sQHBM5MEZNkCfBOaS6S9//AGPRTNB7IaA==}
  '@types/pg@8.23.1':
    resolution: {integrity: sha512-fKVHpikPdg4GKks3JuLEhvwSyvwzF23hnabPy6DD8ljVbC7+6J5dQzdv4arV6jqq57djnMgs1HKBxX4P8aBI3A==}
@@ -3067,6 +3076,10 @@ packages:
    resolution: {integrity: sha512-BdiKAgbfRlvfMq/XzO/AF9NPmaA8a+YpLAyAFTVFBj3gARrAIfWvNq7Q7NE4se3KgFu0KkrvQMxTS0XVnsGzHg==}
    engines: {node: '>=18'}
  nodemailer@10.0.10:
    resolution: {integrity: sha512-He9XskOFms62SyAKkLu8CcGcYHAo+BSHSsORI8s4PJH8qZgZY4L4lDfvyN0twvmbpyG+eGrxpyBlskj9d9rJ8A==}
    engines: {node: '>=20.0.0'}
  non-error@0.1.0:
    resolution: {integrity: sha512-TMB1uHiGsHRGv1uYclfhivcnf0/PdFp2pNqRxXjncaAsjYMoisaQJI+SSZCqRq+VliwRTC8tsMQfmrWjDMhkPQ==}
    engines: {node: '>=20'}
@@ -4910,6 +4923,10 @@ snapshots:
    dependencies:
      undici-types: 8.9.0
  '@types/nodemailer@8.0.2':
    dependencies:
      '@types/node': 24.19.2
  '@types/pg@8.23.1':
    dependencies:
      '@types/node': 26.6.5
@@ -6625,6 +6642,8 @@ snapshots:
  node-releases@2.0.58: {}
  nodemailer@10.0.10: {}
  non-error@0.1.0: {}
  oauth4webapi@3.8.8: {}
@@ -0,0 +1,19 @@
 -- Schluessel erzeugen, importieren, Private Key loeschen (#012, #014).
 --
 -- Neue Vorgangsarten: Erzeugen und Import eines Paars laufen im Worker, weil nur er den
 -- Master-Key hat. Das Loeschen eines gespeicherten Private Keys laeuft ebenfalls dort, damit
 -- die Grenze „nur src/worker/geheimnisse.ts fasst das Chiffrat an“ einfach bleibt.
 ALTER TYPE "VorgangsArt" ADD VALUE 'SCHLUESSEL_ERZEUGEN';
 ALTER TYPE "VorgangsArt" ADD VALUE 'SCHLUESSEL_IMPORTIEREN';
 ALTER TYPE "VorgangsArt" ADD VALUE 'PRIVATE_KEY_LOESCHEN';
 -- Der Slug landet in Dateinamen (<slug>.pub, ~/.ssh/id_<slug>) und Kommentaren. Was hier
 -- nicht passt, kommt nie bis in einen Pfad oder ein Shell-Skript.
 ALTER TABLE "Schluessel" ADD CONSTRAINT "schluessel_slug_gueltig" CHECK (
  "slug" ~ '^[a-z0-9-]{1,64}$'
 );
 -- „Private Key geloescht“ und ein gespeichertes Chiffrat schliessen sich aus (#014).
 ALTER TABLE "Schluessel" ADD CONSTRAINT "schluessel_geloescht_ohne_private_key" CHECK (
  "privatGeloeschtAm" IS NULL OR "privatVerschluesselt" IS NULL
 );
@@ -0,0 +1,4 @@
 -- Self-Service „Meine Schluessel“ (#013): ein Konto wird per E-Mail nur dann mit einer
 -- vorhandenen Person verknuepft, wenn der OIDC-Anbieter die Adresse bestaetigt hat. Sonst
 -- koennte jemand mit selbst gewaehlter Adresse die Schluessel einer fremden Person sehen.
 ALTER TABLE "Benutzer" ADD COLUMN "emailBestaetigt" BOOLEAN NOT NULL DEFAULT false;
@@ -0,0 +1,10 @@
 -- 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 "VorgangsArt" ADD VALUE 'ZIELKONTO_ANLEGEN';
 ALTER TYPE "VorgangsArt" ADD VALUE 'ZIELKONTO_ENTFERNEN';
@@ -0,0 +1,3 @@
 -- #024: Zwischenzustand „Widerruf eingeleitet“. Der Schluessel bleibt AKTIV (bzw. ABGELAUFEN),
 -- bis alle Verwendungen nachweislich entfernt sind; erst dann wird er WIDERRUFEN bzw. ROTIERT.
 ALTER TABLE "Schluessel" ADD COLUMN "widerrufEingeleitetAm" TIMESTAMP(3);
@@ -0,0 +1,2 @@
 -- AlterTable
 ALTER TABLE "PublicVerwendung" ADD COLUMN     "ausserhalbEntfernen" BOOLEAN NOT NULL DEFAULT false;
@@ -0,0 +1,36 @@
 -- #028: Benachrichtigungen. Versandprotokoll gegen Doppelmeldungen und eine Vorgangsart fuer
 -- die Testnachricht (Versand laeuft im Worker).
 -- CreateEnum
 CREATE TYPE "MeldungsKanal" AS ENUM ('EMAIL', 'WEBHOOK');
 -- CreateEnum
 CREATE TYPE "ZustellErgebnis" AS ENUM ('GESENDET', 'FEHLGESCHLAGEN');
 -- AlterEnum
 ALTER TYPE "VorgangsArt" ADD VALUE 'BENACHRICHTIGUNG_TEST';
 -- CreateTable
 CREATE TABLE "Zustellung" (
    "id" TEXT NOT NULL,
    "anlass" TEXT NOT NULL,
    "kanal" "MeldungsKanal" NOT NULL,
    "ergebnis" "ZustellErgebnis" NOT NULL,
    "fehler" TEXT,
    "versuche" INTEGER NOT NULL DEFAULT 1,
    "naechsterVersuchAm" TIMESTAMP(3),
    "sendung" TEXT NOT NULL,
    "betreff" TEXT NOT NULL,
    "zeitpunkt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT "Zustellung_pkey" PRIMARY KEY ("id")
 );
 -- CreateIndex
 CREATE INDEX "Zustellung_zeitpunkt_idx" ON "Zustellung"("zeitpunkt");
 -- CreateIndex
 CREATE INDEX "Zustellung_sendung_idx" ON "Zustellung"("sendung");
 -- CreateIndex
 CREATE UNIQUE INDEX "Zustellung_anlass_kanal_key" ON "Zustellung"("anlass", "kanal");
@@ -104,6 +104,18 @@ enum VorgangsArt {
  ROTATION
  WIDERRUF
  PRIVATE_KEY_ABHOLEN
  /// Schluesselpaar im Worker erzeugen und versiegeln (#012).
  SCHLUESSEL_ERZEUGEN
  /// Importiertes Paar im Worker pruefen und versiegeln (#012).
  SCHLUESSEL_IMPORTIEREN
  /// Gespeicherten Private Key endgueltig verwerfen (#014).
  PRIVATE_KEY_LOESCHEN
  /// Zielbenutzer anlegen und sudoers setzen (#018).
  ZIELKONTO_ANLEGEN
  /// sudoers und – falls von sshkv angelegt – den Benutzer entfernen (#018, #024).
  ZIELKONTO_ENTFERNEN
  /// Testnachricht ueber einen Benachrichtigungskanal (#028).
  BENACHRICHTIGUNG_TEST
 }
 enum VorgangsStatus {
@@ -115,6 +127,17 @@ enum VorgangsStatus {
  ABGEBROCHEN
 }
 /// Versandweg einer Benachrichtigung (#028).
 enum MeldungsKanal {
  EMAIL
  WEBHOOK
 }
 enum ZustellErgebnis {
  GESENDET
  FEHLGESCHLAGEN
 }
 enum ProtokollErgebnis {
  ERFOLG
  FEHLER
@@ -129,6 +152,9 @@ model Benutzer {
  /// `sub` des OIDC-Anbieters; leer beim Notfall-Admin.
  oidcSub            String?   @unique
  email              String?   @unique
  /// Hat der OIDC-Anbieter die Adresse bestaetigt (`email_verified`)? Nur dann verknuepft der
  /// Self-Service das Konto per E-Mail mit einer vorhandenen Person (#013).
  emailBestaetigt    Boolean   @default(false)
  /// Anmeldename des Notfall-Admins.
  anmeldename        String?   @unique
  name               String
@@ -289,6 +315,9 @@ model Schluessel {
  tags                  String[]
  ablaufAm              DateTime?
  zuletztVerwendetAm    DateTime?
  /// Widerruf eingeleitet (#024): Verwendungen stehen auf ENTFERNEN, der Status wechselt erst
  /// auf WIDERRUFEN/ROTIERT, wenn alle Entfernungen erfolgreich waren.
  widerrufEingeleitetAm DateTime?
  /// Rotationskette: der Schluessel, den dieser abgeloest hat.
  vorgaengerId          String?             @unique
  vorgaenger            Schluessel?         @relation("Rotation", fields: [vorgaengerId], references: [id], onDelete: SetNull)
@@ -320,6 +349,9 @@ model PublicVerwendung {
  zielbenutzer        String
  /// authorized_keys-Optionen, z. B. restrict,from="10.0.0.12".
  optionen            String?
  /// Beim Ausrollen dieselbe Zeile ausserhalb des Blocks entfernen – nur fuer uebernommene
  /// Keys (#022), sonst fasst sshkv fremde Zeilen nie an.
  ausserhalbEntfernen Boolean            @default(false)
  zustand             VerwendungsZustand @default(GEPLANT)
  zuletztAngewendetAm DateTime?
  angelegtVonId       String?
@@ -477,6 +509,30 @@ model Einstellung {
  geaendertAm DateTime @updatedAt
 }
 /// Versandprotokoll der Benachrichtigungen (#028): je Anlass und Kanal hoechstens eine Zeile.
 /// Vor jedem Versand wird hiergegen geprueft – so meldet sshkv dieselbe Abweichung oder dieselbe
 /// Ablaufstufe nie zweimal, auch wenn ein Zeitplan doppelt feuert oder der Worker neu startet.
 model Zustellung {
  id                 String          @id @default(cuid())
  /// Fingerabdruck des Anlasses, z. B. drift:<abweichungId>, ablauf:<schluesselId>:7:<datum>.
  anlass             String
  kanal              MeldungsKanal
  ergebnis           ZustellErgebnis
  /// Kurzer Fehlertext ohne Zugangsdaten.
  fehler             String?
  versuche           Int             @default(1)
  /// Wann ein Fehlschlag fruehestens erneut versucht wird; leer = nicht mehr.
  naechsterVersuchAm DateTime?
  /// Gemeinsame Kennung aller Anlaesse einer Nachricht – die Oberflaeche zeigt je Nachricht eine Zeile.
  sendung            String
  betreff            String
  zeitpunkt          DateTime        @default(now())
  @@unique([anlass, kanal])
  @@index([zeitpunkt])
  @@index([sendung])
 }
 /// Einfaches Rate-Limit fuer Anmeldung und Re-Auth (feste Fenster).
 model Ratenbegrenzung {
  schluessel   String   @id
@@ -124,10 +124,99 @@ async function demoDaten(): Promise<void> {
  console.log(`Demo-Daten geprüft: ${DEMO_HOSTS.length} Hosts, ${DEMO_GRUPPEN.length} Gruppen.`);
 }
 /**
 * Demo-Personen und -Schluessel (#012, #013). Nur Public Keys: einen Private Key kann nur
 * der Worker versiegeln. Die Paare werden hier frisch erzeugt und der Private Key sofort
 * verworfen – es sind Attrappen, die nirgends Zugang geben.
 */
 const DEMO_PERSONEN = [
  { name: "Florian Wilde", email: "florian@example.org", organisation: "IT" },
  { name: "Anna Berger", email: "a.berger@netzwerk-gmbh.example", organisation: "Netzwerk GmbH" },
  { name: "Mehmet Yılmaz", email: "mehmet@example.org", organisation: "IT" },
 ] as const;
 const TAG_MS = 24 * 60 * 60 * 1000;
 const DEMO_SCHLUESSEL: {
  name: string;
  slug: string;
  kategorie: "PERSON" | "DIENST";
  person?: string;
  tags: string[];
  ablaufInTagen?: number;
  kommentar: string;
 }[] = [
  {
    name: "Laptop Florian",
    slug: "laptop-florian",
    kategorie: "PERSON",
    person: "Florian Wilde",
    tags: ["laptop"],
    kommentar: "florian@laptop",
  },
  {
    name: "Wartungszugang Netzwerk GmbH",
    slug: "wartung-netzwerk-gmbh",
    kategorie: "PERSON",
    person: "Anna Berger",
    tags: ["dienstleister"],
    ablaufInTagen: 18,
    kommentar: "anna@netzwerk-gmbh",
  },
  {
    name: "Workstation Mehmet",
    slug: "workstation-mehmet",
    kategorie: "PERSON",
    person: "Mehmet Yılmaz",
    tags: [],
    ablaufInTagen: 200,
    kommentar: "mehmet@ws-07",
  },
  {
    name: "Monitoring zabbix → alle Hosts",
    slug: "monitoring-zabbix",
    kategorie: "DIENST",
    tags: ["monitoring"],
    kommentar: "zabbix@srv-mon01",
  },
 ];
 async function demoSchluessel(): Promise<void> {
  if (process.env["SSHKV_SEED_DEMO"] !== "1") return;
  const { schluesselpaarErzeugen } = await import("../src/lib/ssh/openssh");
  const personen = new Map<string, string>();
  for (const p of DEMO_PERSONEN) {
    const vorhanden = await prisma.person.findFirst({ where: { name: p.name }, select: { id: true } });
    const person = vorhanden ?? (await prisma.person.create({ data: p, select: { id: true } }));
    personen.set(p.name, person.id);
  }
  for (const s of DEMO_SCHLUESSEL) {
    if (await prisma.schluessel.findUnique({ where: { slug: s.slug }, select: { id: true } })) continue;
    const paar = await schluesselpaarErzeugen("ED25519", { kommentar: s.kommentar });
    await prisma.schluessel.create({
      data: {
        name: s.name,
        slug: s.slug,
        typ: "ED25519",
        kategorie: s.kategorie,
        publicKey: paar.publicKeyZeile,
        fingerprint: paar.fingerprint,
        kommentar: s.kommentar,
        tags: s.tags,
        personId: s.person ? (personen.get(s.person) ?? null) : null,
        ablaufAm: s.ablaufInTagen ? new Date(Date.now() + s.ablaufInTagen * TAG_MS) : null,
      },
      select: { id: true },
    });
  }
  console.log(`Demo-Daten geprüft: ${DEMO_PERSONEN.length} Personen, ${DEMO_SCHLUESSEL.length} Schlüssel.`);
 }
 try {
  await notfallAdmin();
  await vorlagen();
  await demoDaten();
  await demoSchluessel();
 } finally {
  await prisma.$disconnect();
 }
@@ -0,0 +1,284 @@
 /**
 * Überträgt die Issue-Dateien aus `docs/issues/` in den Gitea-Issue-Tracker.
 *
 *   GITEA_URL=https://git.wilde-server.de \
 *   GITEA_REPO=florian.wilde/sshkv \
 *   GITEA_TOKEN=... \
 *   npm run issues:sync
 *
 * Ohne Token oder mit `--dry-run` läuft nur ein Trockenlauf: Es wird ausgegeben, was passieren würde.
 * Die Markdown-Dateien bleiben die Quelle der Wahrheit; Gitea erhält eine Kopie zum Kommentieren.
 */
 import { execFileSync } from "node:child_process";
 import { readFile, readdir } from "node:fs/promises";
 import "dotenv/config";
 import path from "node:path";
 interface IssueDatei {
  nummer: number;
  titel: string;
  status: string;
  meilenstein: string | null;
  labels: string[];
  koerper: string;
  dateiname: string;
 }
 /** Farben der Labels, angelehnt an die Design-Tokens (#030). */
 const LABEL_FARBEN: Record<string, string> = {
  backend: "#6aa8ff",
  ui: "#f0b43c",
  datenbank: "#3cc9a7",
  sicherheit: "#f2714b",
  test: "#3cc9a7",
  docs: "#8b96a3",
  infrastruktur: "#2a323b",
  chore: "#8b96a3",
 };
 function feld(inhalt: string, name: string): string | null {
  const treffer = new RegExp(`^\\*\\*${name}:\\*\\*\\s*(.+)$`, "m").exec(inhalt);
  return treffer ? (treffer[1] ?? "").trim() : null;
 }
 async function dateienLesen(verzeichnis: string): Promise<IssueDatei[]> {
  const namen = (await readdir(verzeichnis)).filter((name) => /^\d{3}-.*\.md$/.test(name)).sort();
  const issues: IssueDatei[] = [];
  for (const dateiname of namen) {
    const inhalt = await readFile(path.join(verzeichnis, dateiname), "utf8");
    const kopf = /^#\s*#(\d+)\s+(.+)$/m.exec(inhalt);
    if (!kopf) {
      console.warn(`Übersprungen (keine Überschrift „# #NNN Titel“): ${dateiname}`);
      continue;
    }
    // Der Körper beginnt nach den Kopfzeilen (Status, Meilenstein, Labels, Zeiten).
    const körperStart = inhalt.indexOf("## Ziel");
    issues.push({
      nummer: Number(kopf[1]),
      titel: (kopf[2] ?? "").trim(),
      status: feld(inhalt, "Status") ?? "offen",
      meilenstein: feld(inhalt, "Meilenstein"),
      labels: (feld(inhalt, "Labels") ?? "")
        .split(",")
        .map((label) => label.trim().toLowerCase())
        .filter(Boolean),
      koerper: körperStart >= 0 ? inhalt.slice(körperStart).trim() : inhalt,
      dateiname,
    });
  }
  return issues;
 }
 class Gitea {
  constructor(
    private readonly basis: string,
    private readonly repo: string,
    /** Fertiger Wert fuer den Authorization-Header (`token …` oder `Basic …`). */
    private readonly autorisierung: string,
  ) {}
  private async anfrage<T>(pfad: string, optionen: RequestInit = {}): Promise<T> {
    const antwort = await fetch(`${this.basis}/api/v1/repos/${this.repo}${pfad}`, {
      ...optionen,
      headers: {
        Authorization: this.autorisierung,
        "Content-Type": "application/json",
        ...optionen.headers,
      },
    });
    if (!antwort.ok) {
      throw new Error(`Gitea antwortet mit ${antwort.status} auf ${pfad}: ${await antwort.text()}`);
    }
    return (await antwort.json()) as T;
  }
  labels() {
    return this.anfrage<{ id: number; name: string }[]>("/labels?limit=100");
  }
  labelAnlegen(name: string) {
    return this.anfrage<{ id: number; name: string }>("/labels", {
      method: "POST",
      body: JSON.stringify({ name, color: LABEL_FARBEN[name] ?? "#6c757d" }),
    });
  }
  meilensteine() {
    return this.anfrage<{ id: number; title: string }[]>("/milestones?state=all&limit=100");
  }
  meilensteinAnlegen(title: string) {
    return this.anfrage<{ id: number; title: string }>("/milestones", {
      method: "POST",
      body: JSON.stringify({ title }),
    });
  }
  issues() {
    return this.anfrage<{ number: number; title: string; state: string }[]>("/issues?state=all&limit=200");
  }
  issueAnlegen(daten: Record<string, unknown>) {
    return this.anfrage<{ number: number }>("/issues", { method: "POST", body: JSON.stringify(daten) });
  }
  issueAendern(nummer: number, daten: Record<string, unknown>) {
    return this.anfrage<{ number: number }>(`/issues/${nummer}`, {
      method: "PATCH",
      body: JSON.stringify(daten),
    });
  }
 }
 /**
 * Ermittelt Serveradresse und Repo aus dem Git-Remote, damit beides nicht doppelt gepflegt werden muss.
 * Beispiel: https://git.example.de/benutzer/sshkv.git → { basis, repo }
 */
 function ausRemote(): { basis: string; repo: string } | null {
  try {
    const url = execFileSync("git", ["remote", "get-url", "origin"], { encoding: "utf8" }).trim();
    const treffer = /^https?:\/\/(?:[^@/]*@)?([^/]+)\/(.+?)(?:\.git)?$/.exec(url);
    if (!treffer) return null;
    return { basis: `https://${treffer[1]}`, repo: treffer[2] ?? "" };
  } catch {
    return null;
  }
 }
 /**
 * Holt die Zugangsdaten aus Git (Schlüsselbund oder `~/.git-credentials`), damit sie nicht
 * zusätzlich in der .env stehen müssen. Hinterlegt ist dort ein API-Token oder – wie bei
 * sshkeyvault – das Konto-Passwort; Gitea nimmt beides an, das Passwort aber nur per Basic-Auth
 * (#030).
 */
 function zugangAusGitCredentials(basis: string): { benutzer: string; geheimnis: string } | null {
  const host = new URL(basis).host;
  // Erst die eingerichteten Helfer (z. B. Schlüsselbund), dann zusätzlich die Datei
  // ~/.git-credentials – je nach Rechner ist mal das eine, mal das andere gefüllt.
  for (const zusatz of [[], ["-c", "credential.helper=store"]]) {
    try {
      const antwort = execFileSync("git", [...zusatz, "credential", "fill"], {
        input: `protocol=https\nhost=${host}\n\n`,
        encoding: "utf8",
        // Keine Rückfrage im Terminal: Wenn nichts hinterlegt ist, soll der Aufruf scheitern.
        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
        stdio: ["pipe", "pipe", "ignore"],
      });
      const passwort = /^password=(.*)$/m.exec(antwort);
      const benutzer = /^username=(.*)$/m.exec(antwort);
      if (passwort?.[1]) return { benutzer: benutzer?.[1] ?? "", geheimnis: passwort[1] };
    } catch {
      // Nächste Möglichkeit versuchen.
    }
  }
  return null;
 }
 /** Titel in Gitea, z. B. „#004 Agent-Skript“ – daran werden vorhandene Issues wiedererkannt. */
 function giteaTitel(issue: IssueDatei): string {
  return `#${String(issue.nummer).padStart(3, "0")} ${issue.titel}`;
 }
 async function main() {
  const trockenlauf = process.argv.includes("--dry-run");
  const remote = ausRemote();
  const basis = (process.env.GITEA_URL ?? remote?.basis ?? "").replace(/\/$/, "");
  const repo = process.env.GITEA_REPO ?? remote?.repo ?? "";
  const zugang = process.env.GITEA_TOKEN ? null : basis ? zugangAusGitCredentials(basis) : null;
  const token = process.env.GITEA_TOKEN || zugang?.geheimnis || "";
  const tokenQuelle = process.env.GITEA_TOKEN ? "Umgebungsvariable" : "Git-Zugangsdaten";
  // Ein Gitea-Token sind 40 Hex-Zeichen; alles andere ist ein Passwort und geht per Basic-Auth.
  const autorisierung =
    process.env.GITEA_TOKEN || /^[0-9a-f]{40}$/.test(token) || !zugang?.benutzer
      ? `token ${token}`
      : `Basic ${Buffer.from(`${zugang.benutzer}:${token}`).toString("base64")}`;
  const verzeichnis = path.join(process.cwd(), "docs", "issues");
  const issues = await dateienLesen(verzeichnis);
  console.log(`${issues.length} Issue-Dateien gelesen.`);
  if (trockenlauf || !basis || !repo || !token) {
    if (!trockenlauf) {
      console.log(
        "\nAdresse, Repo oder Token nicht ermittelbar – es läuft nur ein Trockenlauf.\n" +
          "Entweder GITEA_TOKEN setzen oder einmal `git push` ausführen, damit der Token hinterlegt wird.\n",
      );
    }
    for (const issue of issues) {
      console.log(
        `  ${giteaTitel(issue)}  [${issue.status}]  Meilenstein ${issue.meilenstein ?? "–"}  Labels: ${
          issue.labels.join(", ") || "–"
        }`,
      );
    }
    console.log(
      `\nZiel wäre: ${basis || "?"}/${repo || "?"} – Token ${token ? "vorhanden" : "fehlt"}.` +
        "\nDer Token wird aus den Git-Zugangsdaten gelesen; er braucht zusätzlich das Recht „issue:write“.",
    );
    return;
  }
  console.log(`Ziel: ${basis}/${repo} (Token aus: ${tokenQuelle})`);
  const gitea = new Gitea(basis, repo, autorisierung);
  const vorhandeneLabels = new Map((await gitea.labels()).map((l) => [l.name.toLowerCase(), l.id]));
  const benoetigteLabels = [...new Set(issues.flatMap((issue) => issue.labels))];
  for (const name of benoetigteLabels) {
    if (!vorhandeneLabels.has(name)) {
      const neu = await gitea.labelAnlegen(name);
      vorhandeneLabels.set(name, neu.id);
      console.log(`Label angelegt: ${name}`);
    }
  }
  const vorhandeneMeilensteine = new Map((await gitea.meilensteine()).map((m) => [m.title, m.id]));
  const benoetigteMeilensteine = [
    ...new Set(issues.map((issue) => issue.meilenstein).filter((m): m is string => Boolean(m))),
  ].sort();
  for (const titel of benoetigteMeilensteine) {
    if (!vorhandeneMeilensteine.has(titel)) {
      const neu = await gitea.meilensteinAnlegen(titel);
      vorhandeneMeilensteine.set(titel, neu.id);
      console.log(`Meilenstein angelegt: ${titel}`);
    }
  }
  const vorhandeneIssues = new Map((await gitea.issues()).map((i) => [i.title, i]));
  for (const issue of issues) {
    const titel = giteaTitel(issue);
    const daten = {
      title: titel,
      body: `${issue.koerper}\n\n---\nQuelle: \`docs/issues/${issue.dateiname}\` – dort wird dieses Issue gepflegt.`,
      labels: issue.labels
        .map((name) => vorhandeneLabels.get(name))
        .filter((id): id is number => Boolean(id)),
      milestone: issue.meilenstein ? vorhandeneMeilensteine.get(issue.meilenstein) : undefined,
    };
    const vorhanden = vorhandeneIssues.get(titel);
    const zustand = issue.status.startsWith("erledigt") ? "closed" : "open";
    if (vorhanden) {
      await gitea.issueAendern(vorhanden.number, { ...daten, state: zustand });
      console.log(`Aktualisiert: ${titel} (${zustand})`);
    } else {
      const neu = await gitea.issueAnlegen(daten);
      if (zustand === "closed") await gitea.issueAendern(neu.number, { state: "closed" });
      console.log(`Angelegt: ${titel} (${zustand})`);
    }
  }
  console.log("\nAbgleich abgeschlossen.");
 }
 main().catch((fehler) => {
  console.error(fehler instanceof Error ? fehler.message : fehler);
  process.exit(1);
 });
@@ -27,9 +27,32 @@ const ZIEL = process.env["SSHKV_BILDER"] ?? join(process.cwd(), "docs/anleitung/
 const SEITEN: { name: string; pfad: string; oeffentlich?: boolean; folgen?: string }[] = [
  { name: "anmelden", pfad: "/anmelden", oeffentlich: true },
  { name: "uebersicht", pfad: "/" },
-  { name: "schluessel-detail", pfad: "/schluessel/beispiel" },
+  { name: "schluessel", pfad: "/schluessel" },
  { name: "schluessel-neu", pfad: "/schluessel/neu" },
  // Der Demo-Key mit nahem Ablaufdatum zeigt die meisten Badges (SSHKV_SEED_DEMO=1, #012).
  {
    name: "schluessel-detail",
    pfad: "/schluessel?q=wartung",
    folgen: 'main table a[href^="/schluessel/"]',
  },
  { name: "personen", pfad: "/personen" },
  { name: "meine-schluessel", pfad: "/meine-schluessel" },
  { name: "hosts", pfad: "/hosts" },
  { name: "host-detail", pfad: "/hosts", folgen: 'main table a[href^="/hosts/"]' },
  // Matrix Schluessel × Host (#025): die Seite darf auf 390 px nicht seitwaerts scrollen –
  // nur der Matrix-Container. „belegt=1“, damit das Bild Zellen zeigt statt leerer Zeilen.
  { name: "zuweisungen", pfad: "/zuweisungen?belegt=1" },
  { name: "vorlagen", pfad: "/vorlagen" },
  // Die eingebaute „Deployment-Zugang“ zeigt Platzhalter, Laufzeit und Benutzer-Anlegen (#019).
  {
    name: "vorlage-bearbeiten",
    pfad: "/vorlagen",
    folgen: 'main a[aria-label="Deployment-Zugang bearbeiten"]',
  },
  // Audit-Log (#027): unter md Karten statt Tabelle, die Seite darf nicht seitwaerts scrollen.
  { name: "protokoll", pfad: "/protokoll" },
  // Benachrichtigungen, Zeitplaene, Instanz (#028) – als Admin mit Formular und Testknoepfen.
  { name: "einstellungen", pfad: "/einstellungen" },
 ];
 const ANSICHTEN = [
@@ -0,0 +1,16 @@
 import type { Metadata } from "next";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 export const metadata: Metadata = { title: "Bestätigt" };
 /** Ziel der Bestaetigung aus dem Assistenten (#020): der Assistent wartet im anderen Tab. */
 export default async function BestaetigtSeite() {
  await sitzungErforderlich();
  return (
    <Leerzustand
      titel="Anmeldung bestätigt"
      text="Die Bestätigung gilt fünf Minuten. Diesen Tab schließen und im Assistenten „Fortsetzen“ wählen."
    />
  );
 }
@@ -0,0 +1,27 @@
 import type { Metadata } from "next";
 import { Assistent } from "@/components/assistent/Assistent";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { assistentDaten } from "@/server/queries/assistent";
 import { bestaetigungFrisch, sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 export const metadata: Metadata = { title: "Host-zu-Host-Assistent" };
 /**
 * Host-zu-Host-Assistent (#020): ein Schluesselpaar fuer genau einen Zweck, Private Key auf
 * Host A, Public Key auf Host B, Verbindungstest. Nur Admins – es wird ein Private Key ausgerollt.
 */
 export default async function AssistentSeite() {
  const { benutzer } = await sitzungErforderlich("privateKeyAusrollen", "/assistent");
  const daten = await assistentDaten();
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={<Breadcrumb pfad={[{ titel: "Übersicht", href: "/" }, { titel: "Host-zu-Host-Assistent" }]} />}
        titel="Host-zu-Host-Assistent"
        untertitel="Host A soll sich per SSH an Host B anmelden – Schlüssel, Ausrollen und Test in einem Durchgang."
      />
      <Assistent daten={daten} bestaetigt={bestaetigungFrisch(benutzer.bestaetigtAm)} />
    </div>
  );
 }
@@ -1,18 +1,196 @@
 import { Inbox } from "lucide-react";
 import type { Metadata } from "next";
-import { Platzhalterseite } from "@/components/huelle/Platzhalterseite";
+import type { ReactNode } from "react";
 import { BenachrichtigungFormular } from "@/components/einstellungen/BenachrichtigungFormular";
 import { Badge } from "@/components/ui/Badge";
 import { Karte } from "@/components/ui/Karte";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { MonoKopieren } from "@/components/ui/MonoKopieren";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { Tabelle, TabellenZeile, TabellenZelle } from "@/components/ui/Tabelle";
 import { datumZeit } from "@/lib/format";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { einstellungenSeite, type Zeitplan, type ZustellungZeile } from "@/server/queries/einstellungen";
 export const metadata: Metadata = { title: "Einstellungen" };
-export default async function Einstellungen() {
+function Info({ titel, children }: { titel: string; children: ReactNode }) {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
  await sitzungErforderlich();
  return (
-    <Platzhalterseite
+    <div className="min-w-0">
-      titel="Einstellungen"
+      <dt className="text-muted text-[13px] font-medium">{titel}</dt>
-      untertitel="Deployment-Key, eigene Vorlagen, Benachrichtigungen"
+      <dd className="text-text mt-1 text-[14.5px] break-words">{children}</dd>
-      phase={3}
+    </div>
-      issue="#019"
+  );
 }
 function Abschnitt({ titel, id, children }: { titel: string; id: string; children: ReactNode }) {
  return (
    <section aria-labelledby={id} className="flex min-w-0 flex-col gap-4">
      <h2 id={id} className="text-muted text-[12.5px] font-semibold tracking-[0.08em] uppercase">
        {titel}
      </h2>
      {children}
    </section>
  );
 }
 function ZeitplanAnzeige({ plan }: { plan: Zeitplan }) {
  return (
    <span className="flex flex-col gap-0.5">
      {plan.beschreibung && <span>{plan.beschreibung}</span>}
      <code className="text-muted font-mono text-[13px]">{plan.ausdruck}</code>
    </span>
  );
 }
 const KANAL_TEXT = { EMAIL: "E-Mail", WEBHOOK: "Webhook" } as const;
 function Zustellungen({ zeilen }: { zeilen: readonly ZustellungZeile[] }) {
  if (zeilen.length === 0) {
    return (
      <Leerzustand
        icon={<Inbox className="size-5" />}
        titel="Noch nichts versendet"
        text="Hier erscheinen die letzten Zustellungen samt Ergebnis – auch Testnachrichten."
      />
    );
  }
  return (
    <Tabelle
      beschriftung="Letzte Zustellungen"
      spalten={[{ titel: "Zeitpunkt" }, { titel: "Kanal" }, { titel: "Nachricht" }, { titel: "Ergebnis" }]}
    >
      {zeilen.map((z) => (
        <TabellenZeile key={z.sendung}>
          <TabellenZelle className="whitespace-nowrap">
            <time dateTime={z.zeitpunkt.toISOString()}>{datumZeit(z.zeitpunkt)}</time>
          </TabellenZelle>
          <TabellenZelle className="whitespace-nowrap">{KANAL_TEXT[z.kanal]}</TabellenZelle>
          <TabellenZelle className="min-w-[16rem]">
            <span className="block">{z.betreff}</span>
            <span className="text-muted block text-[12.5px]">
              {z.anlaesse === 1 ? "1 Anlass" : `${z.anlaesse} Anlässe`}
              {z.versuche > 1 && ` · ${z.versuche}. Versuch`}
            </span>
          </TabellenZelle>
          <TabellenZelle className="min-w-[12rem]">
            {z.ergebnis === "GESENDET" ? (
              <Badge variante="ok">gesendet</Badge>
            ) : (
              <span className="flex flex-col items-start gap-1">
                <Badge variante="gefahr">fehlgeschlagen</Badge>
                {z.fehler && <span className="text-danger text-[12.5px] break-words">{z.fehler}</span>}
                <span className="text-muted text-[12.5px]">
                  {z.naechsterVersuchAm
                    ? `neuer Versuch ab ${datumZeit(z.naechsterVersuchAm)}`
                    : "kein weiterer Versuch"}
                </span>
              </span>
            )}
          </TabellenZelle>
        </TabellenZeile>
      ))}
    </Tabelle>
  );
 }
 /** Einstellungen (#028): lesen duerfen alle, aendern nur `einstellungenVerwalten` (Admin). */
 export default async function Einstellungen() {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
  const { benutzer } = await sitzungErforderlich("lesen", "/einstellungen");
  const darfAendern = darf(benutzer.rolle, "einstellungenVerwalten");
  const seite = await einstellungenSeite();
  // Eine Webhook-Adresse traegt oft ein Token im Pfad – Leser sehen nur Schema und Host.
  const ansicht = darfAendern
    ? seite.benachrichtigung
    : {
        ...seite.benachrichtigung,
        webhook: { ...seite.benachrichtigung.webhook, url: seite.webhookZiel ?? "" },
      };
  const { instanz } = seite;
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        titel="Einstellungen"
        untertitel={
          darfAendern
            ? "Benachrichtigungen, Zeitpläne und Angaben zu dieser Instanz"
            : "Nur Ansicht – ändern dürfen Administratoren."
        }
      />
      <div className="grid min-w-0 gap-6 sm:gap-7 xl:grid-cols-[minmax(0,1fr)_22rem] xl:items-start">
        <Abschnitt titel="Benachrichtigungen" id="abschnitt-benachrichtigungen">
          <BenachrichtigungFormular ansicht={ansicht} darfAendern={darfAendern} />
          <Karte
            titel="Letzte Zustellungen"
            untertitel="Fehlgeschlagene Zustellungen wiederholt der Worker bis zu fünfmal."
          >
            <Zustellungen zeilen={seite.zustellungen} />
          </Karte>
        </Abschnitt>
        <div className="flex min-w-0 flex-col gap-6 sm:gap-7">
          <Abschnitt titel="Abgleich" id="abschnitt-abgleich">
            <Karte as="div">
              <dl className="grid gap-4">
                <Info titel="Abgleich aller Hosts">
                  <ZeitplanAnzeige plan={seite.abgleich} />
                </Info>
                <Info titel="Tägliche Zusammenfassung">
                  <ZeitplanAnzeige plan={seite.meldung} />
                </Info>
                <Info titel="Geänderte Host-Keys">alle 5 Minuten geprüft</Info>
              </dl>
              <p className="text-muted mt-4 text-[13px]">
                Zeitzone Europe/Berlin. Gesetzt über <code className="font-mono">SSHKV_SYNC_CRON</code> und{" "}
                <code className="font-mono">SSHKV_MELDUNG_CRON</code> in der Umgebung des Workers.
              </p>
            </Karte>
          </Abschnitt>
          {/* Platz fuer den Abschnitt „Syslog“ – folgt in einem eigenen Issue. */}
          <Abschnitt titel="Instanz" id="abschnitt-instanz">
            <Karte as="div">
              <dl className="grid gap-4">
                <Info titel="Version">
                  <span className="font-mono text-[13.5px]">{instanz.version}</span>
                </Info>
                <Info titel="Deployment-Key">
                  {instanz.deploymentKey ? (
                    <MonoKopieren
                      wert={instanz.deploymentKey.fingerprint}
                      beschriftung="Fingerprint des Deployment-Keys"
                      umbrechen
                    />
                  ) : (
                    <span className="text-accent">noch nicht erzeugt – läuft der Worker?</span>
                  )}
                </Info>
                <Info titel="Anmeldung (OIDC)">
                  {instanz.oidc.konfiguriert ? (
                    instanz.oidc.name
                  ) : (
                    <span className="text-muted">nicht eingerichtet</span>
                  )}
                </Info>
                <Info titel="Notfall-Admin">
                  {!instanz.notfall.vorhanden ? (
                    <span className="text-muted">nicht angelegt</span>
                  ) : instanz.notfall.totpEingerichtet ? (
                    <Badge variante="ok">TOTP eingerichtet</Badge>
                  ) : (
                    <Badge variante="messing">TOTP noch nicht eingerichtet</Badge>
                  )}
                </Info>
              </dl>
            </Karte>
          </Abschnitt>
        </div>
      </div>
    </div>
  );
 }
@@ -18,6 +18,11 @@ import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { hostDetail, type HostDetail } from "@/server/queries/hosts";
 import { BootstrapAktionen } from "./BootstrapAktionen";
 import { sshdHinweise } from "@/lib/sshd-hinweise";
 import { AbgleichKarten } from "@/components/abgleich/AbgleichKarten";
 import { AusrollenPanel } from "@/components/ausrollen/AusrollenPanel";
 import { istZustand } from "@/server/queries/abgleich";
 import { VerwendungsZustand } from "@/components/ausrollen/VerwendungsZustand";
 import { verwendungenAufHost } from "@/server/queries/ziele";
 import { HostKeyAktionen } from "./HostKeyAktionen";
 import { HostKeyEntscheidung } from "./HostKeyEntscheidung";
 import { bootstrapBefehlFuer } from "@/server/queries/bootstrap";
@@ -95,6 +100,9 @@ export default async function HostSeite({ params }: { params: Promise<{ id: stri
  const archiviert = host.archiviertAm !== null;
  const verwalten = darf(benutzer.rolle, "hostsVerwalten") && !archiviert;
  const darfEntscheiden = darf(benutzer.rolle, "hostKeyEntscheiden") && !archiviert;
  const darfAusrollen = darf(benutzer.rolle, "publicKeyAusrollen") && !archiviert;
  const verwendungen = await verwendungenAufHost(host.id);
  const ist = await istZustand(host.id);
  const jetzt = new Date();
  return (
@@ -217,7 +225,7 @@ export default async function HostSeite({ params }: { params: Promise<{ id: stri
      <Karte
        titel="Schlüssel auf diesem Host"
-        untertitel={`${host.publicVerwendungen} Public-Key-Verwendungen · ${host.privateVerwendungen} Private-Key-Verwendungen`}
+        untertitel="Public Keys in authorized_keys und Private Keys, die sshkv hier verwaltet"
      >
        {host.zielkonten.length > 0 && (
          <p className="text-muted mb-4 text-[14px]">
@@ -230,13 +238,76 @@ export default async function HostSeite({ params }: { params: Promise<{ id: stri
            ))}
          </p>
        )}
        {verwendungen.oeffentlich.length === 0 && verwendungen.privat.length === 0 ? (
          <Leerzustand
            icon={<KeyRound className="size-5" />}
-          titel="Folgt mit #016"
+            titel="Noch keine Schlüssel zugewiesen"
-          text="Hier erscheinen die Public und Private Keys, die sshkv auf diesem Host verwaltet."
+            text="Zuweisen geht über die Seite eines Schlüssels („+ Ausrollen“)."
          />
        ) : (
          <ul className="flex flex-col">
            {verwendungen.oeffentlich.map((v) => (
              <li
                key={v.id}
                className="border-border flex flex-col gap-1 border-b py-3 first:pt-0 last:border-b-0 sm:flex-row sm:items-center sm:justify-between sm:gap-4"
              >
                <span className="min-w-0">
                  <a
                    href={`/schluessel/${v.schluessel.id}`}
                    className="text-text hover:text-accent font-medium"
                  >
                    {v.schluessel.name}
                  </a>
                  <span className="text-muted block font-mono text-[12.5px] break-all">
                    Public · {v.zielbenutzer}@{host.name}
                    {v.hostgruppe ? ` · über ${v.hostgruppe.name}` : ""}
                    {v.optionen ? ` · ${v.optionen}` : ""}
                  </span>
                </span>
                <VerwendungsZustand zustand={v.zustand} />
              </li>
            ))}
            {verwendungen.privat.map((v) => (
              <li
                key={v.id}
                className="border-border flex flex-col gap-1 border-b py-3 first:pt-0 last:border-b-0 sm:flex-row sm:items-center sm:justify-between sm:gap-4"
              >
                <span className="min-w-0">
                  <a
                    href={`/schluessel/${v.schluessel.id}`}
                    className="text-text hover:text-accent font-medium"
                  >
                    {v.schluessel.name}
                  </a>
                  <span className="text-muted block font-mono text-[12.5px] break-all">
                    Private · {v.zielbenutzer}@{host.name}:{v.pfad}
                  </span>
                </span>
                <VerwendungsZustand zustand={v.zustand} />
              </li>
            ))}
          </ul>
        )}
        {darfAusrollen && verwendungen.oeffentlich.length > 0 && host.bootstrapAm && (
          <div className="border-border mt-5 border-t pt-5">
            <AusrollenPanel
              auswahl={{ hostId: host.id }}
              offen={verwendungen.oeffentlich.filter((v) => v.zustand !== "AUSGEROLLT").length}
            />
          </div>
        )}
      </Karte>
      {host.bootstrapAm && (
        <AbgleichKarten
          hostId={host.id}
          zustand={ist}
          darfAbgleichen={verwalten}
          darfUebernehmen={darf(benutzer.rolle, "schluesselVerwalten") && !archiviert}
          darfVerwalten={darfAusrollen}
        />
      )}
      {verwalten && (
        <Karte titel="Archivieren" untertitel="Host stilllegen, ohne die Historie zu verlieren">
          <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
@@ -0,0 +1,78 @@
 import { KeyRound } from "lucide-react";
 import type { Metadata } from "next";
 import { KeyEntfernen, KeyHinterlegen } from "@/components/personen/MeineSchluessel";
 import { StatusBadge, TypBadge } from "@/components/schluessel/Anzeige";
 import { Badge } from "@/components/ui/Badge";
 import { Karte } from "@/components/ui/Karte";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { MonoKopieren } from "@/components/ui/MonoKopieren";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { datum } from "@/lib/format";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { eigeneSchluessel } from "@/server/services/meine-schluessel";
 export const metadata: Metadata = { title: "Meine Schlüssel" };
 /**
 * Self-Service (#013): eigene Public Keys hinterlegen und – solange nirgends zugewiesen –
 * wieder entfernen. Beim ersten Aufruf entsteht die eigene Person (oder wird verknuepft).
 */
 export default async function MeineSchluesselSeite() {
  const { benutzer } = await sitzungErforderlich("eigeneSchluesselHinterlegen", "/meine-schluessel");
  const { schluessel } = await eigeneSchluessel(benutzer);
  return (
    <div className="flex max-w-4xl flex-col gap-6 sm:gap-7">
      <Seitenkopf
        titel="Meine Schlüssel"
        untertitel="Ihre Public Keys für die Anmeldung an Servern. Wirksam erst, wenn ein Operator oder Admin den Schlüssel einem Host zuweist."
      />
      <Karte titel="Hinterlegt" untertitel={`${schluessel.length} Schlüssel`}>
        {schluessel.length === 0 ? (
          <Leerzustand
            icon={<KeyRound className="size-5" />}
            titel="Noch keine Schlüssel"
            text="Hinterlegen Sie unten Ihren Public Key. Danach kann ein Operator oder Admin ihn den Servern zuweisen, auf die Sie Zugriff brauchen."
          />
        ) : (
          <ul className="flex flex-col">
            {schluessel.map((s) => (
              <li
                key={s.id}
                className="border-border flex flex-col gap-2 border-b py-4 first:pt-0 last:border-b-0 last:pb-0 sm:flex-row sm:items-start sm:justify-between"
              >
                <div className="min-w-0">
                  <p className="text-text text-[14.5px] font-medium">{s.name}</p>
                  <MonoKopieren
                    wert={s.fingerprint}
                    beschriftung="Fingerprint"
                    umbrechen
                    className="text-[12.5px]"
                  />
                  <span className="mt-1 flex flex-wrap items-center gap-1.5">
                    <TypBadge typ={s.typ} publicKey={s.publicKey} />
                    <StatusBadge status={s.status} />
                    {s.verwendungen > 0 ? (
                      <Badge variante="ok">
                        {s.verwendungen === 1 ? "1 Host-Zuweisung" : `${s.verwendungen} Host-Zuweisungen`}
                      </Badge>
                    ) : (
                      <Badge variante="messing">noch nicht zugewiesen</Badge>
                    )}
                    <span className="text-muted text-[13px]">seit {datum(s.angelegtAm)}</span>
                  </span>
                </div>
                {s.selbstHinterlegt && s.verwendungen === 0 && (
                  <KeyEntfernen schluesselId={s.id} name={s.name} />
                )}
              </li>
            ))}
          </ul>
        )}
      </Karte>
      <KeyHinterlegen />
    </div>
  );
 }
@@ -1,15 +1,7 @@
-import { ArrowRight, Plus, RefreshCw, Route } from "lucide-react";
+import { ArrowRight, Plus, Route } from "lucide-react";
 import type { Metadata } from "next";
 import Link from "next/link";
-import {
+import { AlleAbgleichenKnopf } from "@/components/abgleich/AlleAbgleichenKnopf";
  abweichungen,
  BEISPIEL_JETZT,
  baldAblaufend,
  kennzahlen,
  letzteAktionen,
  letzterAbgleich,
  type AktionsArt,
 } from "@/beispiel/uebersicht";
 import { Badge } from "@/components/ui/Badge";
 import { Button } from "@/components/ui/Button";
 import { Karte } from "@/components/ui/Karte";
@@ -18,7 +10,10 @@ import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { Statuspunkt } from "@/components/ui/Statuspunkt";
 import { Tabelle, TabellenZeile, TabellenZelle } from "@/components/ui/Tabelle";
 import { datum, datumZeit, relativ, tageBis, uhrzeit } from "@/lib/format";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { uebersicht, type AktionsArt } from "@/server/queries/uebersicht";
 export const metadata: Metadata = { title: "Übersicht" };
@@ -28,36 +23,45 @@ const AKTION: Record<AktionsArt, { text: string; farbe: string }> = {
  erstellt: { text: "Erstellt", farbe: "text-text" },
  abgleich: { text: "Abgleich", farbe: "text-info" },
  rotiert: { text: "Rotiert", farbe: "text-accent" },
  anmeldung: { text: "Anmeldung", farbe: "text-muted" },
  verweigert: { text: "Verweigert", farbe: "text-danger" },
  sonstiges: { text: "Aktion", farbe: "text-text" },
 };
-/**
+/** Übersicht (#026): Aufbau aus dem Prototyp (#002), Zahlen aus der Datenbank. */
 * Prototyp der Übersicht mit Beispieldaten (#002). Die echte Übersicht mit Lesemodellen
 * folgt in #026; Aufbau und Komponenten bleiben.
 */
 export default async function Uebersicht() {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
-  await sitzungErforderlich();
+  const { benutzer } = await sitzungErforderlich();
  const jetzt = new Date();
  const { letzterAbgleich, kennzahlen, mitAbweichung, weitereAbweichungen, baldAblaufend, letzteAktionen } =
    await uebersicht(jetzt);
  const verwalten = darf(benutzer.rolle, "hostsVerwalten");
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        titel="Übersicht"
        badges={<Badge variante="messing">Prototyp · Beispieldaten</Badge>}
        untertitel={
          letzterAbgleich ? (
            <>
-            Letzter Abgleich {relativ(letzterAbgleich, BEISPIEL_JETZT)} ·{" "}
+              Letzter Abgleich {relativ(letzterAbgleich, jetzt)} ·{" "}
-            <time dateTime={letzterAbgleich} className="font-mono text-[13px]">
+              <time dateTime={letzterAbgleich.toISOString()} className="font-mono text-[13px]">
                {datumZeit(letzterAbgleich)}
              </time>
            </>
          ) : (
            "Noch kein Abgleich gelaufen."
          )
        }
        aktionen={
          <>
-            <Button icon={<RefreshCw className="size-4" />}>Jetzt abgleichen</Button>
+            {verwalten && <AlleAbgleichenKnopf />}
-            <Button href="/zuweisungen" icon={<Route className="size-4" />}>
+            {darf(benutzer.rolle, "privateKeyAusrollen") && (
              <Button href="/assistent" icon={<Route className="size-4" />}>
                Host-zu-Host-Assistent
              </Button>
            )}
            <Button
-              href="/schluessel"
+              href="/schluessel/neu"
              variante="primaer"
              icon={<Plus className="size-4" strokeWidth={2.4} />}
            >
@@ -97,7 +101,17 @@ export default async function Uebersicht() {
      </div>
      <div className="grid gap-6 xl:grid-cols-[minmax(0,1.55fr)_minmax(0,1fr)]">
-        <Karte titel="Hosts mit Abweichung" untertitel="Ergebnis des letzten Abgleichs">
+        <Karte
          titel="Hosts mit Abweichung"
          untertitel={
            weitereAbweichungen
              ? `Ergebnis des letzten Abgleichs · ${weitereAbweichungen} weitere`
              : "Ergebnis des letzten Abgleichs"
          }
        >
          {mitAbweichung.length === 0 ? (
            <p className="text-ok text-[14px]">● Alle Hosts synchron – keine offenen Abweichungen.</p>
          ) : (
            <Tabelle
              beschriftung="Hosts mit Abweichung"
              spalten={[
@@ -107,8 +121,8 @@ export default async function Uebersicht() {
                { titel: "Aktion", rechts: true, versteckt: true },
              ]}
            >
-            {abweichungen.map((a) => (
+              {mitAbweichung.map((a) => (
-              <TabellenZeile key={`${a.host}-${a.benutzer}`}>
+                <TabellenZeile key={`${a.hostId}-${a.benutzer}-${a.status}`}>
                  <TabellenZelle mono className="whitespace-nowrap">
                    {a.host}
                  </TabellenZelle>
@@ -118,7 +132,7 @@ export default async function Uebersicht() {
                  </TabellenZelle>
                  <TabellenZelle rechts>
                    <Link
-                    href="/hosts"
+                      href={`/hosts/${a.hostId}`}
                      className="text-accent -my-2 inline-flex min-h-11 items-center px-1 font-medium hover:underline"
                    >
                      Prüfen<span className="sr-only"> – {a.host}</span>
@@ -127,16 +141,20 @@ export default async function Uebersicht() {
                </TabellenZeile>
              ))}
            </Tabelle>
          )}
        </Karte>
        <Karte titel="Bald ablaufend" untertitel="Schlüssel mit Ablaufdatum in den nächsten 30 Tagen">
          {baldAblaufend.length === 0 && (
            <p className="text-muted text-[14px]">Kein Schlüssel läuft in den nächsten 30 Tagen ab.</p>
          )}
          <ul className="flex flex-col">
            {baldAblaufend.map((s) => {
-              const tage = tageBis(s.ablauf, BEISPIEL_JETZT);
+              const tage = tageBis(s.ablauf, jetzt);
              return (
-                <li key={s.zweck} className="border-border border-b last:border-b-0">
+                <li key={s.id} className="border-border border-b last:border-b-0">
                  <Link
-                    href="/schluessel/beispiel"
+                    href={`/schluessel/${s.id}`}
                    className="hover:bg-raised/50 rounded-box -mx-2 flex min-h-11 items-center justify-between gap-3 px-2 py-2.5 transition-colors"
                  >
                    <span className="min-w-0">
@@ -145,8 +163,16 @@ export default async function Uebersicht() {
                        {s.person} · <span className="font-mono">{s.typ}</span>
                      </span>
                    </span>
-                    <Badge variante="messing" className="shrink-0">
+                    <Badge variante={tage < 0 ? "gefahr" : "messing"} className="shrink-0">
-                      <time dateTime={s.ablauf}>{tage === 1 ? "morgen" : `in ${tage} Tagen`}</time>
+                      <time dateTime={s.ablauf.toISOString()}>
                        {tage < 0
                          ? `abgelaufen${s.ausgerollt ? " · noch ausgerollt" : ""}`
                          : tage === 0
                            ? "heute"
                            : tage === 1
                              ? "morgen"
                              : `in ${tage} Tagen`}
                      </time>
                    </Badge>
                  </Link>
                </li>
@@ -167,13 +193,17 @@ export default async function Uebersicht() {
          </Link>
        }
      >
        {letzteAktionen.length === 0 && <Leerzustand titel="Noch keine Aktionen" />}
        <ol className="flex flex-col">
          {letzteAktionen.map((a) => (
            <li
-              key={a.zeit}
+              key={a.id}
              className="border-border grid grid-cols-[auto_1fr] gap-x-4 gap-y-0.5 border-b py-3 text-[14px] last:border-b-0 md:grid-cols-[8.5rem_6.5rem_1fr_auto] md:items-baseline"
            >
-              <time dateTime={a.zeit} className="text-muted font-mono text-[12.5px] whitespace-nowrap">
+              <time
                dateTime={a.zeit.toISOString()}
                className="text-muted font-mono text-[12.5px] whitespace-nowrap"
              >
                {datum(a.zeit)} {uhrzeit(a.zeit)}
              </time>
              <span className={`${AKTION[a.art].farbe} font-medium md:order-none`}>{AKTION[a.art].text}</span>
@@ -0,0 +1,44 @@
 import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import { PersonFormular } from "@/components/personen/PersonFormular";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { kontenAuswahl, personDetail } from "@/server/queries/personen";
 export const metadata: Metadata = { title: "Person bearbeiten" };
 export default async function PersonBearbeiten({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  await sitzungErforderlich("schluesselVerwalten", `/personen/${id}/bearbeiten`);
  const [person, konten] = await Promise.all([personDetail(id), kontenAuswahl(id)]);
  if (!person || person.archiviertAm) notFound();
  return (
    <div className="flex max-w-3xl flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={
          <Breadcrumb
            pfad={[
              { titel: "Personen", href: "/personen" },
              { titel: person.name, href: `/personen/${person.id}` },
              { titel: "Bearbeiten" },
            ]}
          />
        }
        titel="Person bearbeiten"
      />
      <PersonFormular
        vorgabe={{
          id: person.id,
          name: person.name,
          email: person.email ?? "",
          organisation: person.organisation ?? "",
          notiz: person.notiz ?? "",
          benutzerId: person.benutzerId ?? "",
        }}
        konten={konten}
        abbrechenZiel={`/personen/${person.id}`}
      />
    </div>
  );
 }
@@ -0,0 +1,153 @@
 import { KeyRound, Pencil, Plus } from "lucide-react";
 import type { Metadata } from "next";
 import Link from "next/link";
 import { notFound } from "next/navigation";
 import type { ReactNode } from "react";
 import { PersonArchivieren } from "@/components/personen/PersonFormular";
 import { AblaufBadge, KategorieBadge, StatusBadge, TypBadge } from "@/components/schluessel/Anzeige";
 import { Badge } from "@/components/ui/Badge";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Button } from "@/components/ui/Button";
 import { Karte } from "@/components/ui/Karte";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { datum } from "@/lib/format";
 import { fingerprintKurz } from "@/lib/schluessel";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { personDetail } from "@/server/queries/personen";
 export const metadata: Metadata = { title: "Person" };
 function Info({ titel, children }: { titel: string; children: ReactNode }) {
  return (
    <div className="min-w-0">
      <dt className="text-muted text-[13px] font-medium">{titel}</dt>
      <dd className="text-text mt-1 text-[14.5px] break-words">{children}</dd>
    </div>
  );
 }
 /** Persondetail (#013) mit ihren Schlüsseln. */
 export default async function PersonSeite({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const { benutzer } = await sitzungErforderlich("lesen", `/personen/${id}`);
  const person = await personDetail(id);
  if (!person) notFound();
  const archiviert = person.archiviertAm !== null;
  const verwalten = darf(benutzer.rolle, "schluesselVerwalten") && !archiviert;
  const jetzt = new Date();
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={<Breadcrumb pfad={[{ titel: "Personen", href: "/personen" }, { titel: person.name }]} />}
        titel={person.name}
        badges={
          <>
            {archiviert && person.archiviertAm && (
              <Badge variante="gefahr">archiviert am {datum(person.archiviertAm)}</Badge>
            )}
            {person.organisation && <Badge>{person.organisation}</Badge>}
            {person.benutzer && <Badge variante="ok">Konto verknüpft</Badge>}
          </>
        }
        aktionen={
          verwalten && (
            <Button href={`/personen/${person.id}/bearbeiten`} icon={<Pencil className="size-4" />}>
              Bearbeiten
            </Button>
          )
        }
      />
      <Karte as="div">
        <dl className="grid grid-cols-1 gap-x-6 gap-y-4 min-[480px]:grid-cols-2 xl:grid-cols-3">
          <Info titel="E-Mail">{person.email ?? <span className="text-muted">–</span>}</Info>
          <Info titel="Konto">
            {person.benutzer ? (
              <>
                {person.benutzer.name}
                {person.benutzer.email && (
                  <span className="text-muted block text-[13px]">{person.benutzer.email}</span>
                )}
              </>
            ) : (
              <span className="text-muted">nicht verknüpft</span>
            )}
          </Info>
          <Info titel="Angelegt">{datum(person.angelegtAm)}</Info>
        </dl>
        {person.notiz && (
          <p className="border-border text-muted mt-5 border-t pt-4 text-[14px] whitespace-pre-line">
            {person.notiz}
          </p>
        )}
      </Karte>
      <Karte
        titel="Schlüssel"
        untertitel={`${person.schluessel.length} Schlüssel dieser Person`}
        aktionen={
          verwalten && (
            <Button
              href={`/schluessel/neu?person=${person.id}`}
              klein
              icon={<Plus className="size-4" strokeWidth={2.4} />}
            >
              Public Key hinterlegen
            </Button>
          )
        }
      >
        {person.schluessel.length === 0 ? (
          <Leerzustand
            icon={<KeyRound className="size-5" />}
            titel="Noch keine Schlüssel"
            text="Die Person kann ihre Public Keys auch selbst unter „Meine Schlüssel“ hinterlegen, sobald ihr Konto verknüpft ist."
          />
        ) : (
          <ul className="flex flex-col">
            {person.schluessel.map((s) => (
              <li key={s.id} className="border-border border-b py-3 first:pt-0 last:border-b-0 last:pb-0">
                <Link
                  href={`/schluessel/${s.id}`}
                  className="text-text hover:text-accent text-[14.5px] font-medium transition-colors"
                >
                  {s.name}
                </Link>
                <span className="text-muted block font-mono text-[12.5px]">
                  {fingerprintKurz(s.fingerprint)}
                </span>
                <span className="mt-1.5 flex flex-wrap items-center gap-1.5">
                  <TypBadge typ={s.typ} publicKey={s.publicKey} />
                  <KategorieBadge kategorie={s.kategorie} />
                  <StatusBadge status={s.status} />
                  {s.selbstHinterlegt && <Badge>selbst hinterlegt</Badge>}
                  <AblaufBadge ablaufAm={s.ablaufAm} jetzt={jetzt} />
                  <span className="text-muted text-[13px]">
                    {s.verwendungen === 0
                      ? "· noch keinem Host zugewiesen"
                      : `· ${s.verwendungen} ${s.verwendungen === 1 ? "Verwendung" : "Verwendungen"}`}
                  </span>
                </span>
              </li>
            ))}
          </ul>
        )}
      </Karte>
      {verwalten && (
        <Karte titel="Archivieren" untertitel="Person stilllegen, ohne die Historie zu verlieren">
          <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
            <p className="text-muted max-w-xl text-[14px]">
              Archivierte Personen verschwinden aus Listen. Ihre Schlüssel bleiben bestehen und lassen sich
              weiterhin widerrufen.
            </p>
            <PersonArchivieren personId={person.id} name={person.name} />
          </div>
        </Karte>
      )}
    </div>
  );
 }
@@ -0,0 +1,23 @@
 import type { Metadata } from "next";
 import { LEERE_PERSON, PersonFormular } from "@/components/personen/PersonFormular";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { kontenAuswahl } from "@/server/queries/personen";
 export const metadata: Metadata = { title: "Person anlegen" };
 export default async function PersonNeu() {
  await sitzungErforderlich("schluesselVerwalten", "/personen/neu");
  const konten = await kontenAuswahl();
  return (
    <div className="flex max-w-3xl flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={<Breadcrumb pfad={[{ titel: "Personen", href: "/personen" }, { titel: "Neue Person" }]} />}
        titel="Person anlegen"
        untertitel="Mitarbeitende, Admins oder Dienstleister, denen Personen-Keys gehören."
      />
      <PersonFormular vorgabe={LEERE_PERSON} konten={konten} abbrechenZiel="/personen" />
    </div>
  );
 }
@@ -1,13 +1,137 @@
 import { Plus, Search, Users } from "lucide-react";
 import type { Metadata } from "next";
-import { Platzhalterseite } from "@/components/huelle/Platzhalterseite";
+import Link from "next/link";
 import { Badge } from "@/components/ui/Badge";
 import { Button } from "@/components/ui/Button";
 import { Feld } from "@/components/ui/Feld";
 import { Karte } from "@/components/ui/Karte";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { Tabelle, TabellenZeile, TabellenZelle } from "@/components/ui/Tabelle";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { personenListe } from "@/server/queries/personen";
 export const metadata: Metadata = { title: "Personen" };
-export default async function Personen() {
+type Suchparameter = Promise<Record<string, string | string[] | undefined>>;
 function einzeln(wert: string | string[] | undefined): string {
  return (Array.isArray(wert) ? wert[0] : wert)?.trim() ?? "";
 }
 function Anzahl({ n }: { n: number }) {
  return n === 0 ? <span className="text-muted">keine</span> : <>{n}</>;
 }
 /** Personenliste (#013): wem welche Schlüssel gehören. */
 export default async function Personen({ searchParams }: { searchParams: Suchparameter }) {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
-  await sitzungErforderlich();
+  const { benutzer } = await sitzungErforderlich("lesen", "/personen");
  const q = einzeln((await searchParams)["q"]);
  const personen = await personenListe({ q });
  const verwalten = darf(benutzer.rolle, "schluesselVerwalten");
  const anlegen = verwalten && (
    <Button href="/personen/neu" variante="primaer" icon={<Plus className="size-4" strokeWidth={2.4} />}>
      Person anlegen
    </Button>
  );
  return (
-    <Platzhalterseite titel="Personen" untertitel="Wem welche Schlüssel gehören" phase={2} issue="#013" />
+    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        titel="Personen"
        untertitel={q ? `${personen.length} Treffer` : "Wem welche Schlüssel gehören"}
        aktionen={anlegen}
      />
      <form method="get" role="search" className="grid items-end gap-3 sm:grid-cols-[minmax(0,1fr)_auto]">
        <Feld
          beschriftung="Suche"
          name="q"
          type="search"
          defaultValue={q}
          placeholder="Name, E-Mail oder Organisation"
          autoComplete="off"
        />
        <div className="flex gap-2.5">
          <Button type="submit" icon={<Search className="size-4" />} className="flex-1 sm:flex-none">
            Suchen
          </Button>
          {q && (
            <Button href="/personen" className="flex-1 sm:flex-none">
              Zurücksetzen
            </Button>
          )}
        </div>
      </form>
      {personen.length === 0 ? (
        <Leerzustand
          icon={<Users className="size-5" />}
          titel={q ? "Keine Treffer" : "Noch keine Personen"}
          text={
            q
              ? "Keine Person passt zur Suche."
              : "Personen entstehen hier oder von selbst, wenn jemand unter „Meine Schlüssel“ einen Key hinterlegt."
          }
          aktion={q ? <Button href="/personen">Suche zurücksetzen</Button> : anlegen}
        />
      ) : (
        <Karte>
          <ul className="flex flex-col md:hidden">
            {personen.map((p) => (
              <li key={p.id} className="border-border border-b last:border-b-0">
                <Link
                  href={`/personen/${p.id}`}
                  className="hover:bg-raised/50 rounded-box -mx-2 flex min-h-11 flex-col gap-1 px-2 py-3 transition-colors"
                >
                  <span className="text-text text-[14.5px] font-medium">{p.name}</span>
                  {p.email && <span className="text-muted truncate text-[13px]">{p.email}</span>}
                  <span className="flex flex-wrap items-center gap-1.5 pt-1">
                    {p.organisation && <Badge>{p.organisation}</Badge>}
                    {p.benutzer && <Badge variante="ok">Konto verknüpft</Badge>}
                  </span>
                  <span className="text-muted text-[13px]">
                    Aktive Schlüssel: <Anzahl n={p.aktiveSchluessel} />
                  </span>
                </Link>
              </li>
            ))}
          </ul>
          <Tabelle
            className="hidden md:block"
            beschriftung="Personen"
            spalten={[
              { titel: "Name" },
              { titel: "E-Mail" },
              { titel: "Organisation" },
              { titel: "Konto" },
              { titel: "Aktive Schlüssel" },
            ]}
          >
            {personen.map((p) => (
              <TabellenZeile key={p.id}>
                <TabellenZelle>
                  <Link
                    href={`/personen/${p.id}`}
                    className="text-text hover:text-accent -my-2 inline-flex min-h-11 items-center text-[14px] font-medium transition-colors"
                  >
                    {p.name}
                  </Link>
                </TabellenZelle>
                <TabellenZelle className="text-muted">{p.email ?? "–"}</TabellenZelle>
                <TabellenZelle>{p.organisation ?? <span className="text-muted">–</span>}</TabellenZelle>
                <TabellenZelle className="whitespace-nowrap">
                  {p.benutzer ? p.benutzer.name : <span className="text-muted">–</span>}
                </TabellenZelle>
                <TabellenZelle className="whitespace-nowrap">
                  <Anzahl n={p.aktiveSchluessel} />
                </TabellenZelle>
              </TabellenZeile>
            ))}
          </Tabelle>
        </Karte>
      )}
    </div>
  );
 }
@@ -1,18 +1,202 @@
 import { Download, ScrollText, Search } from "lucide-react";
 import type { Metadata } from "next";
-import { Platzhalterseite } from "@/components/huelle/Platzhalterseite";
+import { KettenPruefung } from "@/components/protokoll/KettenPruefung";
 import { ProtokollListe } from "@/components/protokoll/ProtokollListe";
 import { Button, buttonKlassen } from "@/components/ui/Button";
 import { Auswahlliste, Feld } from "@/components/ui/Feld";
 import { Karte } from "@/components/ui/Karte";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { AKTIONSGRUPPEN } from "@/lib/protokoll-aktionen";
 import {
  cursorAus,
  ERGEBNIS_TEXT,
  protokollFilterAktiv,
  protokollFilterAus,
  protokollFilterQuery,
 } from "@/lib/protokoll-filter";
 import { syslogZielText } from "@/lib/syslog";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { protokollAkteure, protokollSeite, protokollZaehlen } from "@/server/queries/protokoll";
 import { ketteZwischengespeichert, syslogKonfig } from "@/server/services/protokoll";
 export const metadata: Metadata = { title: "Audit-Log" };
-export default async function Protokoll() {
+type Suchparameter = Promise<Record<string, string | string[] | undefined>>;
 /**
 * Audit-Log (#027): jede Rolle darf lesen. Filter per GET, damit Links, „ältere laden“ und
 * der CSV-Export denselben Ausschnitt meinen. Es gibt hier bewusst keinen Knopf, der einen
 * Eintrag aendert oder loescht.
 */
 export default async function Protokoll({ searchParams }: { searchParams: Suchparameter }) {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
-  await sitzungErforderlich();
+  await sitzungErforderlich("lesen", "/protokoll");
  const parameter = await searchParams;
  const filter = protokollFilterAus(parameter);
  const vor = cursorAus(parameter["vor"]);
  const [seite, zaehler, akteure] = await Promise.all([
    protokollSeite(filter, vor),
    protokollZaehlen(filter),
    protokollAkteure(),
  ]);
  const gefiltert = protokollFilterAktiv(filter);
  const query = protokollFilterQuery(filter);
  const kette = ketteZwischengespeichert();
  const syslog = syslogKonfig();
  return (
-    <Platzhalterseite
+    <div className="flex min-w-0 flex-col gap-6 sm:gap-7">
      <Seitenkopf
        titel="Audit-Log"
-      untertitel="Lückenloses, verkettetes Protokoll aller Aktionen"
+        untertitel="Lückenloses, verkettetes Protokoll aller Aktionen – nur lesbar, nicht änderbar"
-      phase={5}
+        aktionen={
-      issue="#027"
+          <a href={`/api/protokoll.csv${query}`} download className={buttonKlassen("sekundaer")}>
            <Download className="size-4" aria-hidden />
            CSV exportieren
          </a>
        }
      />
      <Karte innen="ohne" className="divide-border divide-y">
        <div className="flex flex-wrap items-baseline gap-x-6 gap-y-1 px-5 py-4 sm:px-6">
          <p className="text-[14px]">
            <span className="font-display text-text text-[22px] font-semibold tabular-nums">
              {zaehler.gesamt.toLocaleString("de-DE")}
            </span>{" "}
            <span className="text-muted">Einträge insgesamt</span>
          </p>
          {gefiltert && (
            <p className="text-muted text-[14px]">
              <span className="text-text font-medium tabular-nums">
                {zaehler.treffer.toLocaleString("de-DE")}
              </span>{" "}
              passen zum Filter
            </p>
          )}
          <p className="text-muted text-[13px] sm:ml-auto">
            Syslog:{" "}
            {syslog ? (
              <span className="text-text font-mono">{syslogZielText(syslog)}</span>
            ) : (
              <span>nicht eingerichtet</span>
            )}
          </p>
        </div>
        <div className="px-5 py-4 sm:px-6">
          <KettenPruefung
            anfang={
              kette
                ? {
                    fehlerhafteId: kette.fehlerhafteId,
                    eintraege: kette.eintraege,
                    geprueftAm: kette.geprueftAm.toISOString(),
                  }
                : null
            }
          />
        </div>
      </Karte>
      <form method="get" role="search" className="grid grid-cols-2 items-end gap-3 lg:grid-cols-4">
        <Feld
          beschriftung="Suche"
          name="q"
          type="search"
          defaultValue={filter.q}
          placeholder="Fingerprint, Host oder Benutzer"
          autoComplete="off"
          spellCheck={false}
          className="col-span-2"
        />
        <Feld
          beschriftung="Host"
          name="host"
          defaultValue={filter.host}
          placeholder="z. B. srv-pve01"
          autoComplete="off"
          spellCheck={false}
          mono
          className="col-span-2 sm:col-span-1"
        />
        <Auswahlliste
          beschriftung="Akteur"
          name="akteur"
          defaultValue={filter.akteur}
          className="col-span-2 sm:col-span-1"
        >
          <option value="">Alle</option>
          {/* Ein gefilterter Name, der nicht mehr unter den haeufigsten ist, bleibt waehlbar. */}
          {[...new Set([...akteure, ...(filter.akteur ? [filter.akteur] : [])])].map((name) => (
            <option key={name} value={name}>
              {name}
            </option>
          ))}
        </Auswahlliste>
        <Auswahlliste beschriftung="Aktion" name="gruppe" defaultValue={filter.gruppe}>
          <option value="">Alle Aktionen</option>
          {Object.entries(AKTIONSGRUPPEN).map(([wert, text]) => (
            <option key={wert} value={wert}>
              {text}
            </option>
          ))}
        </Auswahlliste>
        <Auswahlliste beschriftung="Ergebnis" name="ergebnis" defaultValue={filter.ergebnis}>
          <option value="">Alle</option>
          {Object.entries(ERGEBNIS_TEXT).map(([wert, text]) => (
            <option key={wert} value={wert}>
              {text}
            </option>
          ))}
        </Auswahlliste>
        <Feld beschriftung="Von" name="von" type="date" defaultValue={filter.von} />
        <Feld beschriftung="Bis" name="bis" type="date" defaultValue={filter.bis} />
        <div className="col-span-2 flex gap-2.5 sm:justify-end lg:col-span-4">
          <Button type="submit" icon={<Search className="size-4" />} className="flex-1 sm:flex-none">
            Filtern
          </Button>
          {gefiltert && (
            <Button href="/protokoll" className="flex-1 sm:flex-none">
              Zurücksetzen
            </Button>
          )}
        </div>
      </form>
      {vor !== undefined && (
        <p className="text-muted text-[14px]">
          Einträge älter als #{String(vor)}.{" "}
          <a href={`/protokoll${query}`} className="text-accent underline-offset-2 hover:underline">
            Zu den neuesten
          </a>
        </p>
      )}
      {seite.zeilen.length === 0 ? (
        gefiltert ? (
          <Leerzustand
            icon={<Search className="size-5" />}
            titel="Keine Treffer"
            text="Kein Eintrag passt zu Suche und Filter."
            aktion={<Button href="/protokoll">Filter zurücksetzen</Button>}
          />
        ) : (
          <Leerzustand
            icon={<ScrollText className="size-5" />}
            titel="Noch keine Einträge"
            text="Sobald jemand sich anmeldet oder etwas ändert, steht es hier."
          />
        )
      ) : (
        <Karte>
          {/* key: neue Filter oder ein neuer Cursor beginnen eine frische Liste. */}
          <ProtokollListe
            key={`${query}|${String(vor ?? "")}`}
            seite={seite}
            query={query.replace(/^\?/, "")}
          />
        </Karte>
      )}
    </div>
  );
 }
@@ -0,0 +1,35 @@
 "use client";
 import { AusrollDialog } from "@/components/ausrollen/AusrollDialog";
 import { PrivateZuweisenFormular } from "@/components/ausrollen/PrivateZuweisenFormular";
 import type { ZielAuswahl } from "@/server/queries/ziele";
 /** „+ Ausrollen“ in der Karte „Private Key ausgerollt auf“ (#017) – nur Admins. */
 export function PrivateAusrollenAktion({
  schluesselId,
  darf,
  auswahl,
  slug,
  passphraseGeschuetzt = false,
 }: {
  schluesselId: string;
  darf: boolean;
  auswahl?: ZielAuswahl;
  slug?: string;
  passphraseGeschuetzt?: boolean;
 }) {
  if (!darf || !auswahl || !slug) return null;
  return (
    <AusrollDialog titel="Private Key ausrollen">
      {(schliessen) => (
        <PrivateZuweisenFormular
          schluesselId={schluesselId}
          slug={slug}
          auswahl={auswahl}
          passphraseGeschuetzt={passphraseGeschuetzt}
          beiErfolg={schliessen}
        />
      )}
    </AusrollDialog>
  );
 }
@@ -0,0 +1,224 @@
 "use client";
 import { Download, Eye, Trash2, TriangleAlert } from "lucide-react";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import { useEffect, useRef, useState, useTransition } from "react";
 import { Ankreuzfeld, Button, Formularfehler } from "@/components/ui";
 import { MonoBlock } from "@/components/ui/MonoBlock";
 import { istLaufend, useVorgang } from "@/components/vorgang/useVorgang";
 import {
  abholungAnfordernAktion,
  privateKeyAnzeigenAktion,
  privateKeyLoeschenAktion,
  type PrivateKeyAntwort,
 } from "@/server/actions/privatekey";
 /**
 * Private Key anzeigen, herunterladen und loeschen (#014). Alles verlangt frische
 * Bestaetigung; fehlt sie, geht es nach /bestaetigen und von dort mit `?privatekey=1` zurueck,
 * damit der Dialog gleich wieder offen ist.
 *
 * Der Key lebt nur im Zustand dieses Dialogs und wird beim Schliessen verworfen.
 */
 const DIALOG_KLASSEN =
  "border-border-strong bg-surface text-text rounded-karte m-auto w-[calc(100%-32px)] max-w-2xl border p-5 backdrop:bg-black/70 sm:p-6";
 function useBestaetigungUmleitung() {
  const router = useRouter();
  const pfad = usePathname();
  return (antwort: PrivateKeyAntwort): boolean => {
    if (!antwort.bestaetigen) return false;
    router.push(`/bestaetigen?ziel=${encodeURIComponent(`${pfad}?privatekey=1`)}`);
    return true;
  };
 }
 export function PrivateKeyAnzeigen({ schluesselId, name }: { schluesselId: string; name: string }) {
  const dialog = useRef<HTMLDialogElement>(null);
  const download = useRef<HTMLFormElement>(null);
  const suche = useSearchParams();
  const umleiten = useBestaetigungUmleitung();
  const [zweck, setZweck] = useState<"anzeigen" | "herunterladen">();
  const [vorgangId, setVorgangId] = useState<string>();
  const [privateKey, setPrivateKey] = useState<string>();
  const [fehler, setFehler] = useState<string>();
  const [startet, starten] = useTransition();
  const { stand, abfrageFehler } = useVorgang(vorgangId);
  const abgeholt = useRef<string | undefined>(undefined);
  // Zurueck von /bestaetigen: Dialog gleich oeffnen.
  useEffect(() => {
    if (suche.get("privatekey") === "1") dialog.current?.showModal();
  }, [suche]);
  // Bereit? Dann genau einmal abholen – als Anzeige oder als Download-Formular.
  useEffect(() => {
    if (!vorgangId || stand?.status !== "ERLEDIGT" || abgeholt.current === vorgangId) return;
    abgeholt.current = vorgangId;
    if (zweck === "herunterladen") {
      download.current?.submit();
      return;
    }
    void privateKeyAnzeigenAktion(vorgangId).then((antwort) => {
      if (umleiten(antwort)) return;
      if (antwort.fehler) setFehler(antwort.fehler);
      else setPrivateKey(antwort.privateKey);
    });
  }, [vorgangId, stand?.status, zweck, umleiten]);
  function anfordern(art: "anzeigen" | "herunterladen") {
    starten(async () => {
      setFehler(undefined);
      setPrivateKey(undefined);
      setZweck(art);
      const antwort = await abholungAnfordernAktion(schluesselId, art);
      if (umleiten(antwort)) return;
      if (antwort.fehler) setFehler(antwort.fehler);
      else setVorgangId(antwort.vorgangId);
    });
  }
  function schliessen() {
    // Nichts vom Key bleibt im Zustand stehen.
    setPrivateKey(undefined);
    setVorgangId(undefined);
    setFehler(undefined);
    dialog.current?.close();
  }
  const laeuft = startet || (vorgangId !== undefined && istLaufend(stand) && !abfrageFehler);
  const vorgangsFehler = stand?.status === "FEHLGESCHLAGEN" ? (stand.fehler ?? undefined) : undefined;
  const downloadGestartet =
    zweck === "herunterladen" && vorgangId !== undefined && stand?.status === "ERLEDIGT";
  return (
    <>
      <button
        type="button"
        onClick={() => dialog.current?.showModal()}
        className="text-accent -my-3 inline-flex min-h-11 items-center font-medium hover:underline"
      >
        anzeigen (Re-Auth)
      </button>
      <dialog ref={dialog} aria-labelledby="privatekey-titel" className={DIALOG_KLASSEN} onClose={schliessen}>
        <div className="flex flex-col gap-4">
          <h2 id="privatekey-titel" className="text-[17px] font-semibold">
            Private Key von „{name}“
          </h2>
          {privateKey ? (
            <>
              <MonoBlock wert={privateKey} beschriftung="Private Key" hoehe="22rem" />
              <p className="text-accent flex items-start gap-2 text-[14px]">
                <TriangleAlert className="mt-0.5 size-4 shrink-0" aria-hidden />
                Wird nicht erneut angezeigt. Kopieren Sie ihn jetzt an einen sicheren Ort.
              </p>
            </>
          ) : downloadGestartet ? (
            <p role="status" className="text-ok text-[14.5px]">
              Download gestartet. Der Private Key wird nicht erneut angeboten.
            </p>
          ) : (
            <>
              <p className="text-muted text-[14.5px]">
                Der Private Key wird im Worker entschlüsselt und genau einmal ausgeliefert. Jede Anzeige und
                jeder Download steht im Audit-Log.
              </p>
              <div className="flex flex-wrap gap-2.5">
                <Button
                  variante="primaer"
                  icon={<Eye className="size-4" />}
                  disabled={laeuft}
                  onClick={() => anfordern("anzeigen")}
                >
                  {laeuft && zweck === "anzeigen" ? "Entschlüssele …" : "Anzeigen"}
                </Button>
                <Button
                  icon={<Download className="size-4" />}
                  disabled={laeuft}
                  onClick={() => anfordern("herunterladen")}
                >
                  {laeuft && zweck === "herunterladen" ? "Entschlüssele …" : "Herunterladen"}
                </Button>
              </div>
            </>
          )}
          <Formularfehler text={fehler ?? abfrageFehler ?? vorgangsFehler} />
          <div className="flex justify-end">
            <Button onClick={schliessen}>Schließen</Button>
          </div>
        </div>
        {vorgangId && <form ref={download} method="post" action={`/api/private-key/${vorgangId}`} hidden />}
      </dialog>
    </>
  );
 }
 /** „Private Key aus SSHKeyVault loeschen“ (#014) – endgueltig, mit Rueckfrage. */
 export function PrivateKeyLoeschen({ schluesselId, name }: { schluesselId: string; name: string }) {
  const dialog = useRef<HTMLDialogElement>(null);
  const router = useRouter();
  const umleiten = useBestaetigungUmleitung();
  const [verstanden, setVerstanden] = useState(false);
  const [vorgangId, setVorgangId] = useState<string>();
  const [fehler, setFehler] = useState<string>();
  const [startet, starten] = useTransition();
  const { stand, abfrageFehler } = useVorgang(vorgangId);
  useEffect(() => {
    if (stand?.status === "ERLEDIGT") {
      dialog.current?.close();
      router.refresh();
    }
  }, [stand?.status, router]);
  const laeuft = startet || (vorgangId !== undefined && istLaufend(stand) && !abfrageFehler);
  const vorgangsFehler = stand?.status === "FEHLGESCHLAGEN" ? (stand.fehler ?? undefined) : undefined;
  return (
    <>
      <Button
        variante="gefahr"
        icon={<Trash2 className="size-4" />}
        onClick={() => dialog.current?.showModal()}
      >
        Private Key löschen
      </Button>
      <dialog ref={dialog} aria-labelledby="privatekey-loeschen-titel" className={DIALOG_KLASSEN}>
        <div className="flex flex-col gap-4">
          <h2 id="privatekey-loeschen-titel" className="text-[17px] font-semibold">
            Private Key von „{name}“ aus SSHKeyVault löschen?
          </h2>
          <p className="text-muted text-[14.5px]">
            sshkv verwirft den verschlüsselten Private Key endgültig. Der Public Key und alle Zuweisungen
            bleiben; auf den Hosts ändert sich nichts. Danach kann sshkv den Private Key weder anzeigen noch
            auf weitere Hosts ausrollen.
          </p>
          <Ankreuzfeld
            checked={verstanden}
            onChange={(e) => setVerstanden(e.target.checked)}
            beschriftung="Ich habe verstanden, dass sich das nicht rückgängig machen lässt."
          />
          <Formularfehler text={fehler ?? abfrageFehler ?? vorgangsFehler} />
          <div className="flex flex-wrap justify-end gap-2.5">
            <Button onClick={() => dialog.current?.close()}>Abbrechen</Button>
            <Button
              variante="gefahr"
              disabled={!verstanden || laeuft}
              onClick={() =>
                starten(async () => {
                  setFehler(undefined);
                  const antwort = await privateKeyLoeschenAktion(schluesselId);
                  if (umleiten(antwort)) return;
                  if (antwort.fehler) setFehler(antwort.fehler);
                  else setVorgangId(antwort.vorgangId);
                })
              }
            >
              {laeuft ? "Lösche …" : "Endgültig löschen"}
            </Button>
          </div>
        </div>
      </dialog>
    </>
  );
 }
@@ -0,0 +1,25 @@
 "use client";
 import { AusrollDialog } from "@/components/ausrollen/AusrollDialog";
 import { PublicZuweisenFormular } from "@/components/ausrollen/PublicZuweisenFormular";
 import type { ZielAuswahl } from "@/server/queries/ziele";
 /** „+ Ausrollen“ in der Karte „Public Key ausgerollt auf“ (#016). */
 export function PublicAusrollenAktion({
  schluesselId,
  darf,
  auswahl,
 }: {
  schluesselId: string;
  darf: boolean;
  auswahl?: ZielAuswahl;
 }) {
  if (!darf || !auswahl) return null;
  return (
    <AusrollDialog titel="Public Key zuweisen">
      {(schliessen) => (
        <PublicZuweisenFormular schluesselId={schluesselId} auswahl={auswahl} beiErfolg={schliessen} />
      )}
    </AusrollDialog>
  );
 }
@@ -0,0 +1,65 @@
 import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import { SchluesselBearbeiten } from "@/components/schluessel/SchluesselBearbeiten";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { personenAuswahl, schluesselDetail, vorlagenAuswahl } from "@/server/queries/schluessel";
 export const metadata: Metadata = { title: "Schlüssel bearbeiten" };
 export default async function SchluesselBearbeitenSeite({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  await sitzungErforderlich("schluesselVerwalten", `/schluessel/${id}/bearbeiten`);
  const [s, personen, vorlagen] = await Promise.all([
    schluesselDetail(id),
    personenAuswahl(),
    vorlagenAuswahl(),
  ]);
  if (!s) notFound();
  // Eine inzwischen archivierte Person oder Vorlage bleibt waehlbar, solange sie zugeordnet
  // ist – sonst loeschte schon das blosse Speichern die Zuordnung.
  const personListe = personen.map((p) => ({ id: p.id, name: p.name, zusatz: p.organisation }));
  if (s.person && !personListe.some((p) => p.id === s.person?.id))
    personListe.push({ ...s.person, zusatz: null });
  const vorlagenListe = vorlagen.map((v) => ({ id: v.id, name: v.name }));
  if (s.vorlage && !vorlagenListe.some((v) => v.id === s.vorlage?.id)) vorlagenListe.push(s.vorlage);
  return (
    <div className="flex max-w-3xl flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={
          <Breadcrumb
            pfad={[
              { titel: "Schlüssel", href: "/schluessel" },
              { titel: s.name, href: `/schluessel/${s.id}` },
              { titel: "Bearbeiten" },
            ]}
          />
        }
        titel="Schlüssel bearbeiten"
        untertitel={
          <>
            Kurzname <span className="text-text font-mono">{s.slug}</span> und Kommentar bleiben unverändert.
          </>
        }
      />
      <SchluesselBearbeiten
        werte={{
          id: s.id,
          name: s.name,
          tags: s.tags,
          ablaufAm: s.ablaufAm ? s.ablaufAm.toISOString().slice(0, 10) : "",
          personId: s.personId ?? "",
          vorlageId: s.vorlageId ?? "",
          status: s.status,
          statusAenderbar:
            s.kategorie !== "DEPLOYMENT" && (s.status === "AKTIV" || s.status === "ABGELAUFEN"),
        }}
        personen={personListe}
        vorlagen={vorlagenListe}
      />
    </div>
  );
 }
@@ -0,0 +1,543 @@
 import { Download, Lock, LockOpen, Pencil, RefreshCw } from "lucide-react";
 import type { Metadata } from "next";
 import Link from "next/link";
 import { notFound } from "next/navigation";
 import type { ReactNode } from "react";
 import { AblaufBadge, KategorieBadge, StatusBadge, TypBadge } from "@/components/schluessel/Anzeige";
 import { Badge } from "@/components/ui/Badge";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Button } from "@/components/ui/Button";
 import { InnereBox, Karte } from "@/components/ui/Karte";
 import { MonoBlock } from "@/components/ui/MonoBlock";
 import { MonoKopieren } from "@/components/ui/MonoKopieren";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { Statuspunkt, type HostStatus } from "@/components/ui/Statuspunkt";
 import { datum, datumZeit } from "@/lib/format";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { rotationsKette, schluesselDetail, type SchluesselDetail } from "@/server/queries/schluessel";
 import { AusrollenPanel } from "@/components/ausrollen/AusrollenPanel";
 import { EintragAktionen } from "@/components/ausrollen/EintragAktionen";
 import { zielAuswahl } from "@/server/queries/ziele";
 import { widerrufUebersicht } from "@/server/queries/widerruf";
 import { WiderrufAblauf } from "@/components/widerruf/WiderrufAblauf";
 import { WiderrufKnopf } from "@/components/widerruf/WiderrufKnopf";
 import { ablaufZustand } from "@/lib/schluessel";
 import { rotationGesperrt } from "@/server/services/rotation";
 import { PrivateAusrollenAktion } from "./PrivateAusrollenAktion";
 import { PrivateKeyAnzeigen, PrivateKeyLoeschen } from "./PrivateKeyAktionen";
 import { PublicAusrollenAktion } from "./PublicAusrollenAktion";
 export const metadata: Metadata = { title: "Schlüssel" };
 function InfoFeld({ titel, children }: { titel: string; children: ReactNode }) {
  return (
    <div className="min-w-0 px-5 py-4 sm:px-6">
      <dt className="text-muted mb-1.5 text-[13px] font-medium">{titel}</dt>
      <dd className="min-w-0">{children}</dd>
    </div>
  );
 }
 /** Soll-Zustand einer Verwendung als Statuspunkt – Form und Text tragen die Information mit. */
 const ZUSTAND: Record<string, { status: HostStatus; text: string }> = {
  GEPLANT: { status: "unbekannt", text: "geplant" },
  AUSGEROLLT: { status: "synchron", text: "ausgerollt" },
  ABWEICHUNG: { status: "drift", text: "Abweichung" },
  ENTFERNEN: { status: "unbekannt", text: "wird entfernt" },
  FEHLGESCHLAGEN: { status: "drift", text: "fehlgeschlagen" },
 };
 type Eintrag = {
  id: string;
  ziel: string;
  href?: string;
  pfad: string;
  zusatz?: string;
  zustand: string;
  aktionen?: ReactNode;
 };
 function AusrollKarte({
  titel,
  untertitel,
  eintraege,
  leer,
  aktion,
 }: {
  titel: string;
  untertitel: string;
  eintraege: Eintrag[];
  leer: string;
  aktion: ReactNode;
 }) {
  return (
    <Karte titel={titel} untertitel={untertitel} aktionen={aktion}>
      {eintraege.length === 0 ? (
        <p className="text-muted border-border-strong rounded-box border border-dashed px-4 py-6 text-center text-[14px]">
          {leer}
        </p>
      ) : (
        <ul className="flex flex-col gap-3">
          {eintraege.map((e) => {
            const z = ZUSTAND[e.zustand] ?? { status: "unbekannt" as const, text: e.zustand };
            return (
              <li key={e.id}>
                <InnereBox className="flex flex-col gap-2">
                  <div className="flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between">
                    <div className="min-w-0">
                      <p className="text-text font-mono text-[13.5px] font-medium break-all">
                        {e.href ? (
                          <Link href={e.href} className="hover:text-accent transition-colors">
                            {e.ziel}
                          </Link>
                        ) : (
                          e.ziel
                        )}
                      </p>
                      <p className="text-muted mt-1 font-mono text-[12.5px] break-all">{e.pfad}</p>
                      {e.zusatz && <p className="text-muted font-mono text-[12.5px] break-all">{e.zusatz}</p>}
                    </div>
                    <Statuspunkt status={z.status} text={z.text} className="shrink-0 sm:pt-0.5" />
                  </div>
                  {/* Aktionen unter dem Eintrag, damit lange Hostnamen nicht umbrechen (#016). */}
                  {e.aktionen}
                </InnereBox>
              </li>
            );
          })}
        </ul>
      )}
    </Karte>
  );
 }
 function privateEintraege(s: SchluesselDetail, rechte: Rechte): Eintrag[] {
  return s.privateVerwendungen.map((v) => {
    const config =
      v.sshConfig && typeof v.sshConfig === "object" ? (v.sshConfig as { alias?: unknown }) : null;
    return {
      id: v.id,
      ziel: `${v.zielbenutzer}@${v.host.name}`,
      href: `/hosts/${v.host.id}`,
      pfad: v.pfad,
      ...(typeof config?.alias === "string" ? { zusatz: `config: Host ${config.alias}` } : {}),
      zustand: v.zustand,
      aktionen: (
        <EintragAktionen
          art="privat"
          verwendungId={v.id}
          schluesselId={s.id}
          darfEntfernen={rechte.privat && v.zustand !== "ENTFERNEN"}
          testbar={rechte.testen && v.zustand === "AUSGEROLLT" && typeof config?.alias === "string"}
        />
      ),
    };
  });
 }
 type Rechte = { readonly public: boolean; readonly privat: boolean; readonly testen: boolean };
 function publicEintraege(s: SchluesselDetail, rechte: Rechte): Eintrag[] {
  return s.publicVerwendungen.map((v) => ({
    id: v.id,
    ziel: v.host
      ? `${v.zielbenutzer}@${v.host.name}`
      : `${v.zielbenutzer}@${v.hostgruppe?.name ?? "?"} (Gruppe)`,
    ...(v.host
      ? { href: `/hosts/${v.host.id}` }
      : v.hostgruppe
        ? { href: `/hostgruppen/${v.hostgruppe.id}` }
        : {}),
    pfad: "~/.ssh/authorized_keys",
    ...(v.optionen ? { zusatz: v.optionen } : {}),
    zustand: v.zustand,
    aktionen: (
      <EintragAktionen
        art="public"
        verwendungId={v.id}
        schluesselId={s.id}
        darfEntfernen={rechte.public && v.zustand !== "ENTFERNEN"}
        testbar={false}
      />
    ),
  }));
 }
 /** Was mit dem Private Key ist – ohne ihn je zu lesen (masterKeyVersion verraet es). */
 function PrivatStatus({ s, anzeigen }: { s: SchluesselDetail; anzeigen?: ReactNode }) {
  if (s.privatGespeichert) {
    return (
      <span className="inline-flex flex-wrap items-center gap-x-1.5 text-[14px]">
        <Lock className="text-ok size-3.5" aria-hidden />
        verschlüsselt gespeichert
        {s.passphraseGeschuetzt && <span className="text-muted">· mit Passphrase</span>}
        {anzeigen}
      </span>
    );
  }
  if (s.privatGeloeschtAm) {
    return (
      <span className="text-muted inline-flex items-center gap-1.5 text-[14px]">
        <LockOpen className="size-3.5" aria-hidden />
        gelöscht am <time dateTime={s.privatGeloeschtAm.toISOString()}>{datum(s.privatGeloeschtAm)}</time>
      </span>
    );
  }
  return (
    <span className="text-muted text-[14px]">
      nicht gespeichert{s.kategorie === "PERSON" ? " (Personen-Key)" : ""}
    </span>
  );
 }
 /** Schlüsseldetail (#012) nach dem Prototyp aus #002; Ausrollen folgt mit #016/#017. */
 export default async function SchluesselSeite({
  params,
  searchParams,
 }: {
  params: Promise<{ id: string }>;
  searchParams: Promise<{ zielkonten?: string | string[] }>;
 }) {
  const { id } = await params;
  const { benutzer } = await sitzungErforderlich("lesen", `/schluessel/${id}`);
  const s = await schluesselDetail(id);
  if (!s) notFound();
  const zielkontenParameter = (await searchParams).zielkonten;
  // Im Widerruf (#024) bleibt der Status AKTIV, bis alles entfernt ist – zuweisen geht aber nicht mehr.
  const imWiderruf = Boolean(s.widerrufEingeleitetAm) && (s.status === "AKTIV" || s.status === "ABGELAUFEN");
  const aktiv = s.status === "AKTIV" && !imWiderruf;
  const rechte: Rechte = {
    public: darf(benutzer.rolle, "publicKeyAusrollen"),
    privat: darf(benutzer.rolle, "privateKeyAusrollen"),
    testen: darf(benutzer.rolle, "hostsVerwalten"),
  };
  const jetzt = new Date();
  const abgelaufen = s.status === "ABGELAUFEN" || ablaufZustand(s.ablaufAm, jetzt).art === "abgelaufen";
  const verwaltenRecht = darf(benutzer.rolle, "schluesselVerwalten");
  const widerrufbar =
    !imWiderruf &&
    !(s.nachfolger?.status === "AKTIV") &&
    s.kategorie !== "DEPLOYMENT" &&
    (s.status === "AKTIV" || s.status === "ABGELAUFEN") &&
    rechte.public &&
    (s.privateVerwendungen.length === 0 || rechte.privat);
  const widerruf = widerrufbar || imWiderruf ? await widerrufUebersicht([s.id]) : undefined;
  // Rotation (#023): Kette, Knopf bzw. Hinweis fuer Schluessel ohne Private Key in sshkv.
  const kette = await rotationsKette(s.id);
  const aktivePrivat = s.privateVerwendungen.filter((v) => v.zustand !== "ENTFERNEN").length;
  const rotationsSperre = rotationGesperrt({
    kategorie: s.kategorie,
    status: s.status,
    masterKeyVersion: s.privatGespeichert ? 1 : null,
    widerrufEingeleitetAm: s.widerrufEingeleitetAm,
    privatZuweisungen: aktivePrivat,
  });
  const rotationLaeuft = s.nachfolger?.status === "AKTIV" && s.status !== "ROTIERT";
  const darfRotieren = verwaltenRecht && rechte.public && (aktivePrivat === 0 || rechte.privat);
  const rotierbar = darfRotieren && (rotationLaeuft || (!rotationsSperre && !imWiderruf));
  // Auf dem Nachfolger: die laufende Rotation gehoert zum Vorgaenger.
  const rotationDesVorgaengers =
    s.vorgaenger && (s.vorgaenger.status === "AKTIV" || s.vorgaenger.status === "ABGELAUFEN")
      ? s.vorgaenger
      : null;
  const vorauswahl = (
    Array.isArray(zielkontenParameter) ? zielkontenParameter.join(",") : (zielkontenParameter ?? "")
  )
    .split(",")
    .filter(Boolean);
  const auswahl = aktiv && rechte.public ? await zielAuswahl() : undefined;
  const personenKey = s.kategorie === "PERSON";
  const verwalten = darf(benutzer.rolle, "schluesselVerwalten");
  // Den Deployment-Key gibt sshkv nie heraus (#014) – Knoepfe dafuer erscheinen gar nicht erst.
  const privatHerausgebbar = s.privatGespeichert && s.kategorie !== "DEPLOYMENT";
  const darfAnzeigen = privatHerausgebbar && darf(benutzer.rolle, "privateKeyAnzeigen");
  const darfLoeschen = privatHerausgebbar && darf(benutzer.rolle, "privateKeyLoeschen");
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={<Breadcrumb pfad={[{ titel: "Schlüssel", href: "/schluessel" }, { titel: s.name }]} />}
        titel={s.name}
        untertitel={
          s.person ? (
            <>
              Person:{" "}
              <Link href={`/personen/${s.person.id}`} className="text-accent hover:underline">
                {s.person.name}
              </Link>
            </>
          ) : undefined
        }
        badges={
          <>
            <TypBadge typ={s.typ} publicKey={s.publicKey} />
            <KategorieBadge kategorie={s.kategorie} />
            <StatusBadge status={s.status} />
            {imWiderruf && <Badge variante="gefahr">Widerruf unvollständig</Badge>}
            {s.instanzStandard && <Badge variante="messing">Instanz-Standard</Badge>}
            {s.selbstHinterlegt && <Badge>selbst hinterlegt</Badge>}
            {s.vorlage && <Badge>Vorlage: {s.vorlage.name}</Badge>}
            <AblaufBadge ablaufAm={s.ablaufAm} jetzt={jetzt} lang />
            {s.tags.map((t) => (
              <Badge key={t} mono className="text-muted">
                #{t}
              </Badge>
            ))}
          </>
        }
        aktionen={
          (verwalten || rotierbar || (widerrufbar && widerruf)) && (
            <>
              {verwalten && (
                <Button href={`/schluessel/${s.id}/bearbeiten`} icon={<Pencil className="size-4" />}>
                  Bearbeiten
                </Button>
              )}
              {rotierbar && (
                <Button href={`/schluessel/${s.id}/rotieren`} icon={<RefreshCw className="size-4" />}>
                  {rotationLaeuft ? "Rotation fortsetzen" : "Rotieren"}
                </Button>
              )}
              {widerrufbar && widerruf && (
                <WiderrufKnopf uebersicht={widerruf} ruecksprung={`/schluessel/${s.id}`} />
              )}
            </>
          )
        }
      />
      {rotationDesVorgaengers && (
        <Karte titel="Rotation läuft" className="border-accent">
          <p className="text-muted text-[14px]">
            Dieser Schlüssel löst „{rotationDesVorgaengers.name}“ ab. Die Rotation ist erst fertig, wenn der
            neue Schlüssel ausgerollt und getestet und der alte entfernt ist.{" "}
            <Link
              href={`/schluessel/${rotationDesVorgaengers.id}/rotieren`}
              className="text-accent hover:underline"
            >
              Rotation fortsetzen
            </Link>
          </p>
        </Karte>
      )}
      {imWiderruf && widerruf && (
        <Karte
          titel="Widerruf läuft"
          untertitel="Der Schlüssel gilt erst als widerrufen, wenn er von allen Hosts entfernt ist."
          className="border-danger-border"
        >
          <WiderrufAblauf
            schluesselIds={[s.id]}
            offen={widerruf.offen}
            zielkonten={widerruf.zielkonten}
            vorauswahl={vorauswahl}
            ruecksprung={`/schluessel/${s.id}`}
            darfPrivat={rechte.privat}
            ohneZielkonten={rotationLaeuft}
          />
        </Karte>
      )}
      {abgelaufen && widerrufbar && widerruf && (
        <Karte titel="Abgelaufen" className="border-danger-border">
          <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
            <p className="text-muted max-w-xl text-[14px]">
              {s.ablaufAm ? (
                <>
                  Das Ablaufdatum (<time dateTime={s.ablaufAm.toISOString()}>{datum(s.ablaufAm)}</time>) ist
                  überschritten.{" "}
                </>
              ) : null}
              Nach Projektende bzw. Ablaufdatum: Widerruf mit einem Klick. sshkv entfernt abgelaufene
              Schlüssel nie von selbst – erst nach Ihrer Bestätigung und dem Dry-Run.
            </p>
            <WiderrufKnopf
              uebersicht={widerruf}
              ruecksprung={`/schluessel/${s.id}`}
              beschriftung="Jetzt widerrufen"
            />
          </div>
        </Karte>
      )}
      {(s.status === "WIDERRUFEN" || s.status === "ROTIERT") && (
        <Karte titel={s.status === "WIDERRUFEN" ? "Widerrufen" : "Rotiert"}>
          <p className="text-muted text-[14px]">
            Von allen Hosts entfernt; der Schlüssel lässt sich nicht mehr zuweisen.
            {s.nachfolger && (
              <>
                {" "}
                Ersetzt durch{" "}
                <Link href={`/schluessel/${s.nachfolger.id}`} className="text-accent hover:underline">
                  {s.nachfolger.name}
                </Link>
                .
              </>
            )}
          </p>
        </Karte>
      )}
      <Karte as="div" innen="ohne">
        <dl className="divide-border grid divide-y md:grid-cols-[minmax(0,1.6fr)_minmax(0,0.8fr)_minmax(0,1.1fr)] md:divide-x md:divide-y-0">
          <InfoFeld titel="Fingerprint">
            <MonoKopieren wert={s.fingerprint} beschriftung="Fingerprint" umbrechen className="-my-[11px]" />
          </InfoFeld>
          <InfoFeld titel="Erstellt">
            <time dateTime={s.angelegtAm.toISOString()} className="font-mono text-[13px]">
              {datumZeit(s.angelegtAm)}
            </time>
            <span className="text-muted block text-[13px]">
              {s.erstelltVon ? `von ${s.erstelltVon.name}` : "von sshkv"}
            </span>
          </InfoFeld>
          <InfoFeld titel="Private Key">
            <PrivatStatus
              s={s}
              anzeigen={
                darfAnzeigen && (
                  <>
                    <span aria-hidden>·</span>
                    <PrivateKeyAnzeigen schluesselId={s.id} name={s.name} />
                  </>
                )
              }
            />
          </InfoFeld>
        </dl>
      </Karte>
      {/* Personen-Keys haben nie einen gespeicherten Private Key (DB-CHECK) – die Karte dafuer
          waere immer leer. */}
      <div className={personenKey ? "grid gap-6" : "grid gap-6 lg:grid-cols-2"}>
        {!personenKey && (
          <AusrollKarte
            titel="Private Key ausgerollt auf"
            untertitel="Hosts, die sich mit diesem Schlüssel anmelden"
            eintraege={privateEintraege(s, rechte)}
            leer={
              s.privatGespeichert
                ? "Der Private Key liegt noch auf keinem Host."
                : "Ohne gespeicherten Private Key kann sshkv ihn nicht ausrollen."
            }
            aktion={
              <PrivateAusrollenAktion
                schluesselId={s.id}
                darf={aktiv && s.privatGespeichert && rechte.privat}
                {...(auswahl ? { auswahl } : {})}
                slug={s.slug}
                passphraseGeschuetzt={s.passphraseGeschuetzt}
              />
            }
          />
        )}
        <AusrollKarte
          titel="Public Key ausgerollt auf"
          untertitel="Konten, die diesen Schlüssel annehmen"
          eintraege={publicEintraege(s, rechte)}
          leer={
            personenKey
              ? "Noch keinem Konto zugewiesen – wirksam erst, wenn ein Operator oder Admin den Schlüssel einem Host zuweist."
              : "Noch keinem Konto zugewiesen."
          }
          aktion={
            <PublicAusrollenAktion
              schluesselId={s.id}
              darf={aktiv && rechte.public}
              {...(auswahl ? { auswahl } : {})}
            />
          }
        />
      </div>
      {rechte.public &&
        !imWiderruf &&
        (s.publicVerwendungen.length > 0 || (rechte.privat && s.privateVerwendungen.length > 0)) && (
          <Karte
            titel="Dry-Run-Vorschau"
            untertitel="Erst prüfen, dann anwenden – auf den Hosts ändert sich vorher nichts"
          >
            <AusrollenPanel
              auswahl={{ schluesselId: s.id }}
              offen={
                s.publicVerwendungen.filter((v) => v.zustand !== "AUSGEROLLT").length +
                (rechte.privat ? s.privateVerwendungen.filter((v) => v.zustand !== "AUSGEROLLT").length : 0)
              }
            />
          </Karte>
        )}
      {(kette.length > 1 || (rotationsSperre?.neuerPublicKeyNoetig && !imWiderruf)) && (
        <Karte
          titel="Rotation"
          untertitel={kette.length > 1 ? "Vorgänger und Nachfolger dieses Schlüssels" : undefined}
        >
          {kette.length > 1 && (
            <ol className="flex flex-wrap items-center gap-2 text-[14px]" aria-label="Rotationskette">
              {kette.map((glied, index) => (
                <li key={glied.id} className="flex items-center gap-2">
                  {index > 0 && (
                    <span className="text-muted" aria-hidden>
                      →
                    </span>
                  )}
                  {glied.id === s.id ? (
                    <span className="font-medium" aria-current="true">
                      {glied.name}
                    </span>
                  ) : (
                    <Link href={`/schluessel/${glied.id}`} className="text-accent hover:underline">
                      {glied.name}
                    </Link>
                  )}
                  <StatusBadge status={glied.status} />
                </li>
              ))}
            </ol>
          )}
          {rotationsSperre?.neuerPublicKeyNoetig && !imWiderruf && (
            <p className={`text-muted text-[14px] ${kette.length > 1 ? "mt-3" : ""}`}>
              {rotationsSperre.grund}
            </p>
          )}
        </Karte>
      )}
      <Karte
        titel="Public Key"
        untertitel={
          <>
            Kommentar: <span className="font-mono">{s.kommentar || "–"}</span>
          </>
        }
        aktionen={
          <a
            href={`/api/schluessel/${s.id}/public-key`}
            download={`${s.slug}.pub`}
            className="border-border-strong bg-surface text-text hover:bg-raised rounded-box inline-flex min-h-11 items-center gap-2 border px-3 text-[13px] font-medium transition-colors"
          >
            <Download className="size-4" aria-hidden />
            {s.slug}.pub
          </a>
        }
      >
        <MonoBlock wert={s.publicKey} beschriftung="Public Key" umbrechen />
      </Karte>
      {darfLoeschen && (
        <Karte titel="Private Key löschen" untertitel="Nur noch auf den Hosts, nicht mehr in SSHKeyVault">
          <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
            <p className="text-muted max-w-xl text-[14px]">
              Sinnvoll, sobald der Private Key ausgerollt ist und sshkv ihn nicht mehr braucht. Danach kann
              ihn niemand mehr aus SSHKeyVault holen – auch kein Admin.
            </p>
            <PrivateKeyLoeschen schluesselId={s.id} name={s.name} />
          </div>
        </Karte>
      )}
    </div>
  );
 }
@@ -0,0 +1,82 @@
 import { KeyRound } from "lucide-react";
 import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import { Rotation } from "@/components/rotation/Rotation";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Button } from "@/components/ui/Button";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { RotationsFehler, rotationsStand } from "@/server/services/rotation";
 import { offeneEntfernungen } from "@/server/services/widerruf";
 export const metadata: Metadata = { title: "Schlüssel rotieren" };
 /** Gefuehrte Rotation (#023): Schrittfolge, wiederaufnehmbar. */
 export default async function RotierenSeite({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const { benutzer } = await sitzungErforderlich("schluesselVerwalten", `/schluessel/${id}/rotieren`);
  if (!darf(benutzer.rolle, "publicKeyAusrollen")) notFound();
  let stand;
  try {
    stand = await rotationsStand(id);
  } catch (fehler) {
    if (fehler instanceof RotationsFehler) notFound();
    throw fehler;
  }
  const { alt } = stand;
  const kopf = (
    <Seitenkopf
      oben={
        <Breadcrumb
          pfad={[
            { titel: "Schlüssel", href: "/schluessel" },
            { titel: alt.name, href: `/schluessel/${alt.id}` },
            { titel: "Rotieren" },
          ]}
        />
      }
      titel={`„${alt.name}“ rotieren`}
      untertitel="Neuer Schlüssel an allen Stellen, testen, erst dann den alten entfernen."
    />
  );
  // Ohne Nachfolger und nicht rotierbar: nur der Hinweis, keine halbe Rotation.
  if (!stand.neu && stand.gesperrt) {
    return (
      <div className="flex flex-col gap-6 sm:gap-7">
        {kopf}
        <Leerzustand
          icon={<KeyRound className="size-5" />}
          titel={stand.gesperrt.neuerPublicKeyNoetig ? "Neuer Public Key nötig" : "Nicht rotierbar"}
          text={stand.gesperrt.grund}
          aktion={<Button href={`/schluessel/${alt.id}`}>Zurück zum Schlüssel</Button>}
        />
      </div>
    );
  }
  const widerruf =
    stand.neu && alt.widerrufEingeleitetAm && alt.status !== "ROTIERT"
      ? await offeneEntfernungen([alt.id])
      : null;
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      {kopf}
      <Rotation
        daten={{
          alt: { id: alt.id, name: alt.name },
          neu: stand.neu ? { id: stand.neu.id, name: stand.neu.name } : null,
          schritt: stand.schritt,
          neuOffen: stand.neu ? stand.neuOffen : 0,
          tests: stand.neu ? stand.tests : [],
          widerruf,
          darfPrivat: darf(benutzer.rolle, "privateKeyAusrollen"),
        }}
      />
    </div>
  );
 }
@@ -1,184 +0,0 @@
 import { Ban, Check, Lock, PlugZap, Plus, RotateCw } from "lucide-react";
 import type { Metadata } from "next";
 import type { ReactNode } from "react";
 import {
  beispielSchluessel as s,
  dryRunDatei,
  dryRunDiff,
  privatAusgerollt,
  publicAusgerollt,
  zusatzaktionen,
  type Ausrollung,
 } from "@/beispiel/schluessel";
 import { BEISPIEL_JETZT } from "@/beispiel/uebersicht";
 import { Badge } from "@/components/ui/Badge";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Button } from "@/components/ui/Button";
 import { DiffBox } from "@/components/ui/DiffBox";
 import { InnereBox, Karte } from "@/components/ui/Karte";
 import { MonoKopieren } from "@/components/ui/MonoKopieren";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { Statuspunkt } from "@/components/ui/Statuspunkt";
 import { datum, datumZeit, tageBis } from "@/lib/format";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 export const metadata: Metadata = { title: `${s.zweck} (Beispiel)` };
 /** Prototyp des Schlüsseldetails mit Beispieldaten (#002); echte Daten ab #012/#016/#017. */
 export default async function SchluesselBeispiel() {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
  await sitzungErforderlich();
  const tage = tageBis(s.ablauf, BEISPIEL_JETZT);
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={<Breadcrumb pfad={[{ titel: "Schlüssel", href: "/schluessel" }, { titel: s.zweck }]} />}
        titel={s.zweck}
        badges={
          <>
            <Badge mono>{s.typ}</Badge>
            <Badge>{s.kategorie}</Badge>
            <Badge>Vorlage: {s.vorlage}</Badge>
            <Badge variante="messing">
              <span>
                läuft ab am <time dateTime={s.ablauf}>{datum(s.ablauf)}</time> · in {tage} Tagen
              </span>
            </Badge>
            <Badge variante="neutral" className="text-muted">
              Beispieldaten
            </Badge>
          </>
        }
        aktionen={
          <>
            <Button icon={<PlugZap className="size-4" />}>Verbindung testen</Button>
            <Button icon={<RotateCw className="size-4" />}>Rotieren</Button>
            <Button variante="gefahr" icon={<Ban className="size-4" />}>
              Widerrufen
            </Button>
          </>
        }
      />
      <Karte as="div" innen="ohne">
        <dl className="divide-border grid divide-y md:grid-cols-[minmax(0,1.6fr)_minmax(0,0.8fr)_minmax(0,1.1fr)] md:divide-x md:divide-y-0">
          <InfoFeld titel="Fingerprint">
            <MonoKopieren wert={s.fingerprint} beschriftung="Fingerprint" umbrechen className="-my-[11px]" />
          </InfoFeld>
          <InfoFeld titel="Erstellt">
            <time dateTime={s.erstellt} className="font-mono text-[13px]">
              {datumZeit(s.erstellt)}
            </time>
            <span className="text-muted block text-[13px]">von {s.erstelltVon}</span>
          </InfoFeld>
          <InfoFeld titel="Private Key">
            <span className="inline-flex flex-wrap items-center gap-x-1.5 text-[14px]">
              <Lock className="text-ok size-3.5" aria-hidden />
              verschlüsselt gespeichert ·
              <button
                type="button"
                className="text-accent -my-3 inline-flex min-h-11 items-center font-medium hover:underline"
              >
                anzeigen (Re-Auth)
              </button>
            </span>
          </InfoFeld>
        </dl>
      </Karte>
      <div className="grid gap-6 lg:grid-cols-2">
        <AusrollKarte
          titel="Private Key ausgerollt auf"
          untertitel="Hosts, die sich mit diesem Schlüssel anmelden"
          eintraege={privatAusgerollt}
        />
        <AusrollKarte
          titel="Public Key ausgerollt auf"
          untertitel="Konten, die diesen Schlüssel annehmen"
          eintraege={publicAusgerollt}
        />
      </div>
      <Karte
        titel="Dry-Run-Vorschau"
        untertitel={
          <>
            Abgleich für <span className="font-mono">backup@srv-pve02</span> – noch nichts geschrieben
          </>
        }
      >
        <DiffBox datei={dryRunDatei} zeilen={dryRunDiff} />
        <fieldset className="mt-5">
          <legend className="text-muted mb-1 text-[13px] font-medium">Zusätzlich ausführen</legend>
          <ul className="flex flex-col">
            {zusatzaktionen.map((z) => (
              <li key={z.id}>
                <label className="flex min-h-11 cursor-pointer items-center gap-3 text-[14.5px]">
                  <input
                    type="checkbox"
                    name={z.id}
                    defaultChecked={z.an}
                    className="accent-accent size-[18px] shrink-0"
                  />
                  <span>{z.text}</span>
                </label>
              </li>
            ))}
          </ul>
        </fieldset>
        <div className="border-border mt-5 flex flex-wrap gap-2.5 border-t pt-5">
          <Button variante="primaer" icon={<Check className="size-4" strokeWidth={2.4} />}>
            Änderung anwenden
          </Button>
          <Button>Verwerfen</Button>
        </div>
      </Karte>
    </div>
  );
 }
 function InfoFeld({ titel, children }: { titel: string; children: ReactNode }) {
  return (
    <div className="min-w-0 px-5 py-4 sm:px-6">
      <dt className="text-muted mb-1.5 text-[13px] font-medium">{titel}</dt>
      <dd className="min-w-0">{children}</dd>
    </div>
  );
 }
 function AusrollKarte({
  titel,
  untertitel,
  eintraege,
 }: {
  titel: string;
  untertitel: string;
  eintraege: Ausrollung[];
 }) {
  return (
    <Karte
      titel={titel}
      untertitel={untertitel}
      aktionen={
        <Button klein icon={<Plus className="size-4" strokeWidth={2.4} />}>
          Ausrollen
        </Button>
      }
    >
      <ul className="flex flex-col gap-3">
        {eintraege.map((e) => (
          <li key={`${e.ziel}${e.pfad}`}>
            <InnereBox className="flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between">
              <div className="min-w-0">
                <p className="text-text font-mono text-[13.5px] font-medium break-all">{e.ziel}</p>
                <p className="text-muted mt-1 font-mono text-[12.5px] break-all">{e.pfad}</p>
                {e.zusatz && <p className="text-muted font-mono text-[12.5px] break-all">{e.zusatz}</p>}
              </div>
              <Statuspunkt status={e.status} text={e.statusText} className="shrink-0 sm:pt-0.5" />
            </InnereBox>
          </li>
        ))}
      </ul>
    </Karte>
  );
 }
@@ -0,0 +1,38 @@
 import type { Metadata } from "next";
 import { SchluesselNeu } from "@/components/schluessel/SchluesselNeu";
 import { Breadcrumb } from "@/components/ui/Breadcrumb";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { personenAuswahl, vorlagenAuswahl } from "@/server/queries/schluessel";
 export const metadata: Metadata = { title: "Schlüssel anlegen" };
 type Suchparameter = Promise<Record<string, string | string[] | undefined>>;
 export default async function SchluesselNeuSeite({ searchParams }: { searchParams: Suchparameter }) {
  await sitzungErforderlich("schluesselVerwalten", "/schluessel/neu");
  const person = (await searchParams)["person"];
  const [personen, vorlagen] = await Promise.all([personenAuswahl(), vorlagenAuswahl()]);
  const vorgabePersonId =
    typeof person === "string" && personen.some((p) => p.id === person) ? person : undefined;
  return (
    <div className="flex max-w-3xl flex-col gap-6 sm:gap-7">
      <Seitenkopf
        oben={
          <Breadcrumb pfad={[{ titel: "Schlüssel", href: "/schluessel" }, { titel: "Neuer Schlüssel" }]} />
        }
        titel="Schlüssel anlegen"
        untertitel="Neu erzeugen oder einen vorhandenen Schlüssel übernehmen."
      />
      <SchluesselNeu
        personen={personen.map((p) => ({ id: p.id, name: p.name, zusatz: p.organisation }))}
        vorlagen={vorlagen.map((v) => ({
          id: v.id,
          name: v.name,
          zusatz: v.standardLaufzeitTage ? `${v.standardLaufzeitTage} Tage` : null,
        }))}
        {...(vorgabePersonId ? { vorgabePersonId } : {})}
      />
    </div>
  );
 }
@@ -1,27 +1,274 @@
 import { Ban, KeyRound, Lock, Plus, Search } from "lucide-react";
 import type { Metadata } from "next";
 import Link from "next/link";
-import { Platzhalterseite } from "@/components/huelle/Platzhalterseite";
+import { AblaufBadge, KategorieBadge, StatusBadge, TypBadge } from "@/components/schluessel/Anzeige";
 import { Badge } from "@/components/ui/Badge";
 import { Button } from "@/components/ui/Button";
 import { AlleAuswaehlen } from "@/components/widerruf/AlleAuswaehlen";
 import { Auswahlliste, Feld } from "@/components/ui/Feld";
 import { Karte } from "@/components/ui/Karte";
 import { Leerzustand } from "@/components/ui/Leerzustand";
 import { Seitenkopf } from "@/components/ui/Seitenkopf";
 import { Tabelle, TabellenZeile, TabellenZelle } from "@/components/ui/Tabelle";
 import { datum } from "@/lib/format";
 import { ablaufZustand, fingerprintKurz, KATEGORIE_TEXT, STATUS_TEXT } from "@/lib/schluessel";
 import { darf } from "@/server/auth/rechte";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { schluesselListe, type SchluesselListenEintrag } from "@/server/queries/schluessel";
 export const metadata: Metadata = { title: "Schlüssel" };
-export default async function Schluessel() {
+type Suchparameter = Promise<Record<string, string | string[] | undefined>>;
-  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
+
-  await sitzungErforderlich();
+function einzeln(wert: string | string[] | undefined): string {
  return (Array.isArray(wert) ? wert[0] : wert)?.trim() ?? "";
 }
 function Verwendungen({ anzahl }: { anzahl: number }) {
  if (anzahl === 0) return <span className="text-muted">keine</span>;
  return <>{anzahl}</>;
 }
 /** In der Tabelle: Badge, wenn es drängt; sonst nur das Datum. */
 function Ablauf({ ablaufAm, jetzt }: { ablaufAm: Date | null; jetzt: Date }) {
  if (!ablaufAm) return <span className="text-muted">–</span>;
  if (ablaufZustand(ablaufAm, jetzt).art === "spaeter") {
    return (
-    <div className="flex flex-col gap-5">
+      <time dateTime={ablaufAm.toISOString()} className="text-muted">
-      <Platzhalterseite
+        {datum(ablaufAm)}
-        titel="Schlüssel"
+      </time>
-        untertitel="SSH-Schlüssel erzeugen, importieren und ausrollen"
+    );
-        phase={2}
+  }
-        issue="#012"
+  return <AblaufBadge ablaufAm={ablaufAm} jetzt={jetzt} />;
 }
 function PrivatHinweis({ s }: { s: SchluesselListenEintrag }) {
  if (!s.privatGespeichert) return null;
  return (
    <span title="Private Key verschlüsselt gespeichert" className="text-muted inline-flex">
      <Lock className="size-3.5" aria-hidden />
      <span className="sr-only">Private Key gespeichert</span>
    </span>
  );
 }
 const MASSEN_FORMULAR = "massenwiderruf";
 /** Nur Schluessel, die sich widerrufen lassen, sind waehlbar (#024). */
 function Auswahl({ s }: { s: SchluesselListenEintrag }) {
  const gesperrt = s.kategorie === "DEPLOYMENT" || s.status === "WIDERRUFEN" || s.status === "ROTIERT";
  return (
    <label className="flex size-11 shrink-0 cursor-pointer items-center justify-center">
      <input
        type="checkbox"
        name="id"
        value={s.id}
        form={MASSEN_FORMULAR}
        disabled={gesperrt}
        aria-label={`${s.name} für den Massenwiderruf auswählen`}
        className="accent-accent size-[18px] cursor-pointer disabled:cursor-not-allowed disabled:opacity-30"
      />
-      <p className="text-muted text-[14px]">
+    </label>
-        Prototyp ansehen:{" "}
+  );
-        <Link href="/schluessel/beispiel" className="text-accent font-medium hover:underline">
+}
-          Schlüsseldetail mit Beispieldaten
+
 function WiderrufBadge({ s }: { s: SchluesselListenEintrag }) {
  if (!s.widerrufEingeleitetAm || (s.status !== "AKTIV" && s.status !== "ABGELAUFEN")) return null;
  return <Badge variante="gefahr">Widerruf unvollständig</Badge>;
 }
 /** Schlüsselliste mit Filter (#012). Filter per GET, damit Links teilbar sind. */
 export default async function Schluessel({ searchParams }: { searchParams: Suchparameter }) {
  // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
  const { benutzer } = await sitzungErforderlich("lesen", "/schluessel");
  const parameter = await searchParams;
  const q = einzeln(parameter["q"]);
  const kategorie = einzeln(parameter["kategorie"]);
  const status = einzeln(parameter["status"]);
  const liste = await schluesselListe({ q, kategorie, status });
  const verwalten = darf(benutzer.rolle, "schluesselVerwalten");
  // Massenwiderruf (#024): Auswahl nur fuer Admins; die frische Bestaetigung prueft die Aktion.
  const massen = darf(benutzer.rolle, "massenwiderruf");
  const gefiltert = q !== "" || kategorie !== "" || status !== "";
  const jetzt = new Date();
  const anlegen = verwalten && (
    <Button href="/schluessel/neu" variante="primaer" icon={<Plus className="size-4" strokeWidth={2.4} />}>
      Schlüssel anlegen
    </Button>
  );
  return (
    <div className="flex flex-col gap-6 sm:gap-7">
      <Seitenkopf
        titel="Schlüssel"
        untertitel={
          gefiltert
            ? `${liste.length} Treffer`
            : `${liste.length} ${liste.length === 1 ? "verwalteter Schlüssel" : "verwaltete Schlüssel"}`
        }
        aktionen={anlegen}
      />
      <form
        method="get"
        role="search"
        className="grid items-end gap-3 sm:grid-cols-2 lg:grid-cols-[minmax(0,1fr)_11rem_11rem_auto]"
      >
        <Feld
          beschriftung="Suche"
          name="q"
          type="search"
          defaultValue={q}
          placeholder="Zweck, Fingerprint, Tag, Person"
          autoComplete="off"
          spellCheck={false}
          className="sm:col-span-2 lg:col-span-1"
        />
        <Auswahlliste beschriftung="Kategorie" name="kategorie" defaultValue={kategorie}>
          <option value="">Alle Kategorien</option>
          {Object.entries(KATEGORIE_TEXT).map(([wert, text]) => (
            <option key={wert} value={wert}>
              {text}
            </option>
          ))}
        </Auswahlliste>
        <Auswahlliste beschriftung="Status" name="status" defaultValue={status}>
          <option value="">Alle</option>
          {Object.entries(STATUS_TEXT).map(([wert, text]) => (
            <option key={wert} value={wert}>
              {text}
            </option>
          ))}
        </Auswahlliste>
        <div className="flex gap-2.5 sm:col-span-2 lg:col-span-1">
          <Button type="submit" icon={<Search className="size-4" />} className="flex-1 lg:flex-none">
            Filtern
          </Button>
          {gefiltert && (
            <Button href="/schluessel" className="flex-1 lg:flex-none">
              Zurücksetzen
            </Button>
          )}
        </div>
      </form>
      {liste.length === 0 ? (
        gefiltert ? (
          <Leerzustand
            icon={<Search className="size-5" />}
            titel="Keine Treffer"
            text="Kein Schlüssel passt zu Suche und Filter."
            aktion={<Button href="/schluessel">Filter zurücksetzen</Button>}
          />
        ) : (
          <Leerzustand
            icon={<KeyRound className="size-5" />}
            titel="Noch keine Schlüssel"
            text="Erzeugen Sie einen Schlüssel oder importieren Sie einen vorhandenen Public Key."
            aktion={anlegen}
          />
        )
      ) : (
        <Karte>
          {massen && (
            <form
              id={MASSEN_FORMULAR}
              method="get"
              action="/schluessel/widerruf"
              className="border-border mb-3 flex flex-wrap items-center justify-between gap-2 border-b pb-3"
            >
              <AlleAuswaehlen formular={MASSEN_FORMULAR} />
              <Button type="submit" variante="gefahr" klein icon={<Ban className="size-4" />}>
                Ausgewählte widerrufen
              </Button>
            </form>
          )}
          {/* Unter md eine Liste statt der Tabelle: sechs Spalten passen nicht auf 390 px. */}
          <ul className="flex flex-col md:hidden">
            {liste.map((s) => (
              <li key={s.id} className="border-border flex items-start gap-1 border-b last:border-b-0">
                {massen && <Auswahl s={s} />}
                <Link
                  href={`/schluessel/${s.id}`}
                  className="hover:bg-raised/50 rounded-box -mx-2 flex min-h-11 min-w-0 flex-1 flex-col gap-2 px-2 py-3 transition-colors"
                >
                  <span className="text-text flex min-w-0 items-center gap-2 text-[14.5px] font-medium">
                    <span className="truncate">{s.name}</span>
                    <PrivatHinweis s={s} />
                  </span>
                  <span className="text-muted block truncate font-mono text-[12.5px]">
                    {fingerprintKurz(s.fingerprint)}
                  </span>
                  <span className="flex flex-wrap items-center gap-1.5">
                    <TypBadge typ={s.typ} publicKey={s.publicKey} />
                    <KategorieBadge kategorie={s.kategorie} />
                    <StatusBadge status={s.status} />
                    <WiderrufBadge s={s} />
                    <AblaufBadge ablaufAm={s.ablaufAm} jetzt={jetzt} />
                  </span>
                  <span className="text-muted text-[13px]">
                    Verwendungen: <Verwendungen anzahl={s.verwendungen} />
                    {s.person && <> · {s.person.name}</>}
                  </span>
                </Link>
-      </p>
+              </li>
            ))}
          </ul>
          <Tabelle
            className="hidden md:block"
            beschriftung="Schlüssel"
            spalten={[
              ...(massen ? [{ titel: "Auswahl", versteckt: true, className: "w-10" }] : []),
              { titel: "Name" },
              { titel: "Typ" },
              { titel: "Kategorie" },
              { titel: "Fingerprint" },
              { titel: "Ablauf" },
              { titel: "Verwendungen" },
            ]}
          >
            {liste.map((s) => (
              <TabellenZeile key={s.id}>
                {massen && (
                  <TabellenZelle className="w-10">
                    <Auswahl s={s} />
                  </TabellenZelle>
                )}
                <TabellenZelle>
                  <span className="flex min-w-0 items-center gap-2">
                    <Link
                      href={`/schluessel/${s.id}`}
                      className="text-text hover:text-accent -my-2 inline-flex min-h-11 items-center text-[14px] font-medium transition-colors"
                    >
                      {s.name}
                    </Link>
                    <PrivatHinweis s={s} />
                    <StatusBadge status={s.status} />
                    <WiderrufBadge s={s} />
                  </span>
                  {s.person && <span className="text-muted block text-[12.5px]">{s.person.name}</span>}
                </TabellenZelle>
                <TabellenZelle className="whitespace-nowrap">
                  <TypBadge typ={s.typ} publicKey={s.publicKey} />
                </TabellenZelle>
                <TabellenZelle className="whitespace-nowrap">
                  <KategorieBadge kategorie={s.kategorie} />
                </TabellenZelle>
                <TabellenZelle mono className="text-muted whitespace-nowrap">
                  <span title={s.fingerprint}>{fingerprintKurz(s.fingerprint)}</span>
                </TabellenZelle>
                <TabellenZelle className="whitespace-nowrap">
                  <Ablauf ablaufAm={s.ablaufAm} jetzt={jetzt} />
                </TabellenZelle>
                <TabellenZelle className="whitespace-nowrap">
                  <Verwendungen anzahl={s.verwendungen} />
                </TabellenZelle>
              </TabellenZeile>
            ))}
          </Tabelle>
        </Karte>
      )}
    </div>
  );
 }
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1,2 @@`
							`-- AlterTable`
							`ALTER TABLE "PublicVerwendung" ADD COLUMN "ausserhalbEntfernen" BOOLEAN NOT NULL DEFAULT false;`